foundationdb/fdbserver/workloads/AsyncFileCorrectness.actor.cpp

440 lines
16 KiB
C++

/*
* 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");