foundationdb/fdbserver/workloads/AsyncFileCorrectness.actor.cpp

/*
 * AsyncFileCorrectness.actor.cpp
 *
 * This source file is part of the FoundationDB open source project
 *
 * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <cinttypes>

#include "fmt/format.h"
#include "fdbserver/workloads/workloads.actor.h"
#include "flow/ActorCollection.h"
#include "flow/IRandom.h"
#include "flow/SystemMonitor.h"
#include "fdbserver/workloads/AsyncFile.actor.h"
#include "flow/actorcompiler.h" // This must be the last #include.

// An enumeration representing the type of operation to be performed in a correctness test operation
enum OperationType { READ, WRITE, SYNC, REOPEN, TRUNCATE };

// Stores information about an operation that is executed on the file
struct OperationInfo {
	Reference<AsyncFileBuffer> data;

	uint64_t offset;
	uint64_t length;

	bool flushOperations;
	OperationType operation;
	int index;
};

struct AsyncFileCorrectnessWorkload : public AsyncFileWorkload {
	// Maximum number of bytes operated on by a file operation
	int maxOperationSize;

	// The number of simultaneous outstanding operations on a file
	int numSimultaneousOperations;

	// The futures for asynchronous IO operations
	std::vector<Future<OperationInfo>> operations;

	// Our in memory representation of what the file should be
	Reference<AsyncFileBuffer> memoryFile;

	// A vector holding a lock for each byte in the file. 0xFFFFFFFF means that the byte is being written, any other
	// number means that it is being read that many times
	std::vector<uint32_t> fileLock;

	// A mask designating whether each byte in the file has been explicitly written (bytes which weren't explicitly
	// written have no guarantees about content)
	std::vector<unsigned char> fileValidityMask;

	// Whether or not the correctness test succeeds
	bool success;

	// The targetted size of the file (the actual file can be anywhere in size from 1 byte to 2 * targetFileSize)
	int64_t targetFileSize;

	double averageCpuUtilization;
	PerfIntCounter numOperations;

	AsyncFileCorrectnessWorkload(WorkloadContext const& wcx)
	  : AsyncFileWorkload(wcx), memoryFile(nullptr), success(true), numOperations("Num Operations") {
		maxOperationSize = getOption(options, "maxOperationSize"_sr, 4096);
		numSimultaneousOperations = getOption(options, "numSimultaneousOperations"_sr, 10);
		targetFileSize = getOption(options, "targetFileSize"_sr, (uint64_t)163840);

		if (unbufferedIO)
			maxOperationSize = std::max(_PAGE_SIZE, maxOperationSize);

		if (maxOperationSize * numSimultaneousOperations > targetFileSize * 0.25) {
			targetFileSize *= (int)ceil((maxOperationSize * numSimultaneousOperations * 4.0) / targetFileSize);
			fmt::print(
			    "Target file size is insufficient to support {0} simultaneous operations of size {1}; changing to "
			    "{2}\n",
			    numSimultaneousOperations,
			    maxOperationSize,
			    targetFileSize);
		}
	}

	~AsyncFileCorrectnessWorkload() override {}

	std::string description() const override { return "AsyncFileCorrectness"; }

	Future<Void> setup(Database const& cx) override {
		if (enabled)
			return _setup(this);

		return Void();
	}

	ACTOR Future<Void> _setup(AsyncFileCorrectnessWorkload* self) {
		// Create the memory version of the file, the file locks, and the valid mask
		self->memoryFile = self->allocateBuffer(self->targetFileSize);
		self->fileLock.resize(self->targetFileSize, 0);
		self->fileValidityMask.resize(self->targetFileSize, 0);
		self->fileSize = 0;

		// Create or open the file being used for testing
		wait(self->openFile(self, IAsyncFile::OPEN_READWRITE | IAsyncFile::OPEN_CREATE, 0666, self->fileSize, true));

		return Void();
	}

	// Updates the memory buffer, locks, and validity mask to a new file size
	void updateMemoryBuffer(int64_t newFileSize) {
		int64_t oldBufferSize = std::max(fileSize, targetFileSize);
		int64_t newBufferSize = std::max(newFileSize, targetFileSize);

		if (oldBufferSize != newBufferSize) {
			Reference<AsyncFileBuffer> newFile = allocateBuffer(newBufferSize);
			memcpy(newFile->buffer, memoryFile->buffer, std::min(newBufferSize, oldBufferSize));

			if (newBufferSize > oldBufferSize)
				memset(&newFile->buffer[oldBufferSize], 0, newBufferSize - oldBufferSize);

			memoryFile = newFile;

			fileLock.resize(newBufferSize, 0);
			fileValidityMask.resize(newBufferSize, 0xFF);
		}

		fileSize = newFileSize;
	}

	Future<Void> start(Database const& cx) override {
		if (enabled)
			return _start(this);

		return Void();
	}

	ACTOR Future<Void> _start(AsyncFileCorrectnessWorkload* self) {
		state StatisticsState statState;
		customSystemMonitor("AsyncFile Metrics", &statState);

		wait(timeout(self->runCorrectnessTest(self), self->testDuration, Void()));

		SystemStatistics stats = customSystemMonitor("AsyncFile Metrics", &statState);
		self->averageCpuUtilization = stats.processCPUSeconds / stats.elapsed;

		// Try to let the IO operations finish so we can clean up after them
		wait(timeout(waitForAll(self->operations), 10, Void()));

		return Void();
	}

	ACTOR Future<Void> runCorrectnessTest(AsyncFileCorrectnessWorkload* self) {
		state std::vector<OperationInfo> postponedOperations;
		state int validOperations = 0;

		loop {
			wait(delay(0));

			// Fill the operations buffer with random operations
			while (self->operations.size() < self->numSimultaneousOperations && postponedOperations.size() == 0) {
				self->operations.push_back(
				    self->processOperation(self, self->generateOperation(self->operations.size(), false)));
				validOperations++;
			}

			// Get the first operation that finishes
			OperationInfo info = wait(waitForFirst(self->operations));

			// If it is a read, check that it matches what our memory representation has
			if (info.operation == READ) {
				int start = 0;
				bool isValid = true;
				int length = std::min(info.length, self->fileLock.size() - info.offset);

				// Scan the entire read range for sections that we know (fileValidityMask > 0) and those that we don't
				for (int i = 0; i < length; i++) {
					bool currentValid = self->fileValidityMask[i] > 0;
					if (start == 0)
						isValid = currentValid;
					else if (isValid != currentValid || i == length - 1) {
						// If we know what data should be in a particular range, then compare the result with what we
						// know
						if (isValid && memcmp(&self->fileValidityMask[info.offset + start],
						                      &info.data->buffer[start],
						                      i - start)) {
							printf("Read returned incorrect results at %" PRIu64 " of length %" PRIu64 "\n",
							       info.offset,
							       info.length);

							self->success = false;
							return Void();
						}
						// Otherwise, skip the comparison and just update what we know
						else if (!isValid) {
							memcpy(
							    &self->memoryFile->buffer[info.offset + start], &info.data->buffer[start], i - start);
							memset(&self->fileValidityMask[info.offset + start], 0xFF, i - start);
						}

						start = i;
					}

					isValid = currentValid;
				}

				// Decrement the read count for each byte that was read
				int lockEnd = std::min(info.offset + info.length, (uint64_t)self->fileLock.size());
				if (lockEnd > self->fileSize)
					lockEnd = self->fileLock.size();

				for (int i = info.offset; i < lockEnd; i++)
					self->fileLock[i]--;
			}

			// If it is a write, clear the write locks
			else if (info.operation == WRITE)
				memset(&self->fileLock[info.offset], 0, info.length * sizeof(uint32_t));

			// Only generate new operations if we don't have a postponed operation in queue
			if (postponedOperations.size() == 0) {
				// Insert a new operation into the operations buffer
				OperationInfo newOperation = self->generateOperation(info.index);

				// If we need to flush existing operations, postpone this operation
				if (newOperation.flushOperations)
					postponedOperations.push_back(newOperation);
				// Otherwise, add it to our operations queue
				else
					self->operations[info.index] = self->processOperation(self, newOperation);
			}

			// If there is a postponed operation, clear the queue so that we can run it
			if (postponedOperations.size() > 0) {
				self->operations[info.index] = Never();
				validOperations--;
			}

			// If there are no operations being processed and postponed operations are waiting, run them now
			while (validOperations == 0 && postponedOperations.size() > 0) {
				self->operations.clear();
				self->operations.push_back(self->processOperation(self, postponedOperations.front()));
				OperationInfo info = wait(self->operations.front());
				postponedOperations.erase(postponedOperations.begin());
				self->operations.clear();
			}
		}
	}

	// Generates a random operation
	OperationInfo generateOperation(int index, bool allowFlushingOperations = true) {
		OperationInfo info;

		do {
			info.flushOperations = false;

			// Cumulative density function for the different operations
			int cdfArray[] = { 0, 1000, 2000, 2100, 2101, 2102 };
			std::vector<int> cdf = std::vector<int>(cdfArray, cdfArray + 6);

			// Choose a random operation type (READ, WRITE, SYNC, REOPEN, TRUNCATE).
			int random = deterministicRandom()->randomInt(0, cdf.back());
			for (int i = 0; i < cdf.size() - 1; i++) {
				if (cdf[i] <= random && random < cdf[i + 1]) {
					info.operation = (OperationType)i;
					break;
				}
			}

			if (info.operation == READ || info.operation == WRITE) {
				int64_t maxOffset;

				// Reads should not exceed the extent of written data
				if (info.operation == READ) {
					maxOffset = fileSize - 1;
					if (maxOffset < 0)
						info.operation = WRITE;
					// Only allow reads once the file has gotten large enough (to prevent blocking on locks)
					if (maxOffset < targetFileSize / 2)
						info.operation = WRITE;
				}

				// Writes can be up to the target file size or the current file size (the current file size could be
				// larger than the target as a result of a truncate)
				if (info.operation == WRITE)
					maxOffset = std::max(fileSize, targetFileSize) - 1;

				// Choose a random offset and length, retrying if that section is already locked
				do {
					// Generate random length and offset
					if (unbufferedIO) {
						info.length =
						    deterministicRandom()->randomInt(1, maxOperationSize / _PAGE_SIZE + 1) * _PAGE_SIZE;
						info.offset =
						    (int64_t)(deterministicRandom()->random01() * maxOffset / _PAGE_SIZE) * _PAGE_SIZE;
					} else {
						info.length = deterministicRandom()->randomInt(1, maxOperationSize);
						info.offset = (int64_t)(deterministicRandom()->random01() * maxOffset);
					}

				} while (checkFileLocked(info.operation, info.offset, info.length));

				// If the operation is a read, increment the read count for each byte
				if (info.operation == READ) {
					// If the read extends past the end of the file, then we have to lock all bytes beyond the end of
					// the file This is so that we can accurately determine if the read count is correct
					int lockEnd = std::min(info.offset + info.length, (uint64_t)fileLock.size());
					if (lockEnd > fileSize)
						lockEnd = fileLock.size();

					for (int i = info.offset; i < lockEnd; i++)
						fileLock[i]++;
				}

				// If the operation is a write, set the write lock for each byte
				else if (info.operation == WRITE) {
					// Don't write past the end of the file
					info.length = std::min(info.length, std::max(targetFileSize, fileSize) - info.offset);
					memset(&fileLock[info.offset], 0xFF, info.length * sizeof(uint32_t));
				}
			} else if (info.operation == REOPEN)
				info.flushOperations = true;
			else if (info.operation == TRUNCATE) {
				info.flushOperations = true;

				// Choose a random length to truncate to
				if (unbufferedIO)
					info.offset =
					    (int64_t)(deterministicRandom()->random01() * (2 * targetFileSize) / _PAGE_SIZE) * _PAGE_SIZE;
				else
					info.offset = (int64_t)(deterministicRandom()->random01() * (2 * targetFileSize));
			}

		} while (!allowFlushingOperations && info.flushOperations);

		info.index = index;
		return info;
	}

	// Checks if a file is already locked for a given set of bytes.  The file is locked if it is being written
	// (fileLock[i] = 0xFFFFFFFF) or if we are trying to perform a write and the read count is nonzero (fileLock[i] !=
	// 0)
	bool checkFileLocked(int operation, int offset, int length) const {
		for (int i = offset; i < offset + length && i < fileLock.size(); i++)
			if (fileLock[i] == 0xFFFFFFFF || (fileLock[i] != 0 && operation == WRITE))
				return true;

		return false;
	}

	// Performs an operation on a file and the memory representation of that file
	ACTOR Future<OperationInfo> processOperation(AsyncFileCorrectnessWorkload* self, OperationInfo info) {
		if (info.operation == READ) {
			info.data = self->allocateBuffer(info.length);

			// Perform the read.  Don't allow it to be cancelled (because the underlying IO may not be cancellable) and
			// don't allow objects that the read uses to be deleted
			int numRead = wait(uncancellable(
			    holdWhile(self->fileHandle,
			              holdWhile(info, self->fileHandle->file->read(info.data->buffer, info.length, info.offset)))));

			if (numRead != std::min(info.length, self->fileSize - info.offset)) {
				printf("Read reported incorrect number of bytes at %" PRIu64 " of length %" PRIu64 "\n",
				       info.offset,
				       info.length);
				self->success = false;
			}
		} else if (info.operation == WRITE) {
			info.data = self->allocateBuffer(info.length);
			deterministicRandom()->randomBytes(reinterpret_cast<uint8_t*>(info.data->buffer), info.length);
			memcpy(&self->memoryFile->buffer[info.offset], info.data->buffer, info.length);
			memset(&self->fileValidityMask[info.offset], 0xFF, info.length);

			// Perform the write.  Don't allow it to be cancelled (because the underlying IO may not be cancellable) and
			// don't allow objects that the write uses to be deleted
			wait(uncancellable(holdWhile(
			    self->fileHandle,
			    holdWhile(info, self->fileHandle->file->write(info.data->buffer, info.length, info.offset)))));

			// If we wrote past the end of the file, update the size of the file
			self->fileSize = std::max((int64_t)(info.offset + info.length), self->fileSize);
		} else if (info.operation == SYNC) {
			info.data = Reference<AsyncFileBuffer>(nullptr);
			wait(self->fileHandle->file->sync());
		} else if (info.operation == REOPEN) {
			// Will fail if the file does not exist
			wait(self->openFile(self, IAsyncFile::OPEN_READWRITE, 0666, 0, false));
			int64_t fileSize = wait(self->fileHandle->file->size());
			int64_t fileSizeChange = fileSize - self->fileSize;
			if (fileSizeChange >= _PAGE_SIZE) {
				fmt::print("Reopened file increased in size by {0} bytes (at most {1} allowed)\n",
				           fileSizeChange,
				           _PAGE_SIZE - 1);
				self->success = false;
			} else if (fileSizeChange < 0) {
				fmt::print("Reopened file decreased in size by {} bytes\n", -fileSizeChange);
				self->success = false;
			}

			self->updateMemoryBuffer(fileSize);
		} else if (info.operation == TRUNCATE) {
			// Perform the truncate.  Don't allow it to be cancelled (because the underlying IO may not be cancellable)
			// and don't allow file handle to be deleted
			wait(uncancellable(holdWhile(self->fileHandle, self->fileHandle->file->truncate(info.offset))));

			int64_t fileSize = wait(self->fileHandle->file->size());
			if (fileSize != info.offset) {
				printf("Incorrect file size reported after truncate\n");
				self->success = false;
			}

			self->updateMemoryBuffer(fileSize);
		}

		++self->numOperations;
		return info;
	}

	Future<bool> check(Database const& cx) override { return success; }

	void getMetrics(std::vector<PerfMetric>& m) override {
		if (enabled) {
			m.emplace_back("Number of Operations Performed", numOperations.getValue(), Averaged::False);
			m.emplace_back("Average CPU Utilization (Percentage)", averageCpuUtilization * 100, Averaged::False);
		}
	}
};

WorkloadFactory<AsyncFileCorrectnessWorkload> AsyncFileCorrectnessWorkloadFactory("AsyncFileCorrectness");