Force name and description of workloads to be the same

zjial · Oct 14, 2022 · 49f0cf5 · 49f0cf5
1 parent df5825f
commit 49f0cf5
Show file tree

Hide file tree

Showing 142 changed files with 406 additions and 470 deletions.
diff --git a/fdbserver/include/fdbserver/workloads/workloads.actor.h b/fdbserver/include/fdbserver/workloads/workloads.actor.h
@@ -64,6 +64,8 @@ struct WorkloadContext {
 };
 
 struct TestWorkload : NonCopyable, WorkloadContext, ReferenceCounted<TestWorkload> {
+	// Implementations of TestWorkload need to provide their name by defining a static member variable called name:
+	// static constexpr const char* name = "WorkloadName";
 	int phases;
 
 	// Subclasses are expected to also have a constructor with this signature (to work with WorkloadFactory<>):
@@ -75,6 +77,8 @@ struct TestWorkload : NonCopyable, WorkloadContext, ReferenceCounted<TestWorkloa
 	}
 	virtual ~TestWorkload(){};
 	virtual Future<Void> initialized() { return Void(); }
+	// WARNING: this method must not be implemented by a workload directly. Instead, this will be implemented by
+	// the workload factory. Instead, provide a static member variable called name.
 	virtual std::string description() const = 0;
 	virtual void disableFailureInjectionWorkloads(std::set<std::string>& out) const;
 	virtual Future<Void> setup(Database const& cx) { return Void(); }
@@ -94,11 +98,26 @@ struct TestWorkload : NonCopyable, WorkloadContext, ReferenceCounted<TestWorkloa
 	virtual void getMetrics(std::vector<PerfMetric>& m) = 0;
 };
 
+struct NoOptions {};
+
+template <class Workload, bool isFailureInjectionWorkload = false>
+struct TestWorkloadImpl : Workload {
+	static_assert(std::is_convertible_v<Workload&, TestWorkload&>);
+	static_assert(std::is_convertible_v<decltype(Workload::NAME), std::string>,
+	              "Workload must have a static member `name` which is convertible to string");
+	static_assert(std::is_same_v<decltype(&TestWorkload::description), decltype(&Workload::description)>,
+	              "Workload must not override TestWorkload::description");
+
+	TestWorkloadImpl(WorkloadContext const& wcx) : Workload(wcx) {}
+	template <bool E = isFailureInjectionWorkload>
+	TestWorkloadImpl(WorkloadContext const& wcx, std::enable_if_t<E, NoOptions> o) : Workload(wcx, o) {}
+
+	std::string description() const override { return Workload::NAME; }
+};
+
 struct CompoundWorkload;
 class DeterministicRandom;
 
-struct NoOptions {};
-
 struct FailureInjectionWorkload : TestWorkload {
 	FailureInjectionWorkload(WorkloadContext const&);
 	virtual ~FailureInjectionWorkload() {}
@@ -126,12 +145,11 @@ struct FailureInjectorFactory : IFailureInjectorFactory {
 		IFailureInjectorFactory::factories().push_back(Reference<IFailureInjectorFactory>::addRef(this));
 	}
 	Reference<FailureInjectionWorkload> create(WorkloadContext const& wcx) override {
-		return makeReference<W>(wcx, NoOptions());
+		return makeReference<TestWorkloadImpl<W, true>>(wcx, NoOptions());
 	}
 };
 
 struct CompoundWorkload : TestWorkload {
-	bool runFailureWorkloads = true;
 	std::vector<Reference<TestWorkload>> workloads;
 	std::vector<Reference<FailureInjectionWorkload>> failureInjection;
 
@@ -213,22 +231,25 @@ struct IWorkloadFactory : ReferenceCounted<IWorkloadFactory> {
 	virtual Reference<TestWorkload> create(WorkloadContext const& wcx) = 0;
 };
 
-template <class WorkloadType>
+template <class Workload>
 struct WorkloadFactory : IWorkloadFactory {
-	bool asClient;
-	WorkloadFactory(const char* name, bool asClient = false) : asClient(asClient) {
-		factories()[name] = Reference<IWorkloadFactory>::addRef(this);
+	static_assert(std::is_convertible_v<decltype(Workload::NAME), std::string>,
+	              "Each workload must have a Workload::NAME member");
+	using WorkloadType = TestWorkloadImpl<Workload>;
+	bool runInUntrustedClient;
+	WorkloadFactory(bool runInUntrustedClient = false) : runInUntrustedClient(runInUntrustedClient) {
+		factories()[WorkloadType::NAME] = Reference<IWorkloadFactory>::addRef(this);
 	}
 	Reference<TestWorkload> create(WorkloadContext const& wcx) override {
-		if (g_network->isSimulated() && asClient) {
+		if (g_network->isSimulated() && runInUntrustedClient) {
 			return makeReference<ClientWorkload>(
 			    [](WorkloadContext const& wcx) { return makeReference<WorkloadType>(wcx); }, wcx);
 		}
 		return makeReference<WorkloadType>(wcx);
 	}
 };
 
-#define REGISTER_WORKLOAD(classname) WorkloadFactory<classname> classname##WorkloadFactory(#classname)
+#define REGISTER_WORKLOAD(classname) WorkloadFactory<classname> classname##WorkloadFactory
 
 struct DistributedTestResults {
 	std::vector<PerfMetric> metrics;

diff --git a/fdbserver/workloads/ApiCorrectness.actor.cpp b/fdbserver/workloads/ApiCorrectness.actor.cpp
@@ -31,6 +31,7 @@ enum OperationType { SET, GET, GET_RANGE, GET_RANGE_SELECTOR, GET_KEY, CLEAR, CL
 
 // A workload that executes the NativeAPIs functions and verifies that their outcomes are correct
 struct ApiCorrectnessWorkload : ApiWorkload {
+	static constexpr auto NAME = "ApiCorrectness";
 
 private:
 // Enable to track the activity on a particular key
@@ -136,9 +137,7 @@ struct ApiCorrectnessWorkload : ApiWorkload {
 	}
 
 	~ApiCorrectnessWorkload() override {}
-
-	std::string description() const override { return "ApiCorrectness"; }
-
+
 	void getMetrics(std::vector<PerfMetric>& m) override {
 		m.emplace_back("Number of Random Operations Performed", numRandomOperations.getValue(), Averaged::False);
 	}
@@ -765,4 +764,4 @@ struct ApiCorrectnessWorkload : ApiWorkload {
 	}
 };
 
-WorkloadFactory<ApiCorrectnessWorkload> ApiCorrectnessWorkloadFactory("ApiCorrectness");
+WorkloadFactory<ApiCorrectnessWorkload> ApiCorrectnessWorkloadFactory;
diff --git a/fdbserver/workloads/AsyncFileCorrectness.actor.cpp b/fdbserver/workloads/AsyncFileCorrectness.actor.cpp
@@ -44,6 +44,7 @@ struct OperationInfo {
 };
 
 struct AsyncFileCorrectnessWorkload : public AsyncFileWorkload {
+	static constexpr auto NAME = "AsyncFileCorrectness";
 	// Maximum number of bytes operated on by a file operation
 	int maxOperationSize;
 
@@ -94,9 +95,7 @@ struct AsyncFileCorrectnessWorkload : public AsyncFileWorkload {
 	}
 
 	~AsyncFileCorrectnessWorkload() override {}
-
-	std::string description() const override { return "AsyncFileCorrectness"; }
-
+
 	Future<Void> setup(Database const& cx) override {
 		if (enabled)
 			return _setup(this);
@@ -436,4 +435,4 @@ struct AsyncFileCorrectnessWorkload : public AsyncFileWorkload {
 	}
 };
 
-WorkloadFactory<AsyncFileCorrectnessWorkload> AsyncFileCorrectnessWorkloadFactory("AsyncFileCorrectness");
+WorkloadFactory<AsyncFileCorrectnessWorkload> AsyncFileCorrectnessWorkloadFactory;
diff --git a/fdbserver/workloads/AsyncFileRead.actor.cpp b/fdbserver/workloads/AsyncFileRead.actor.cpp
@@ -144,6 +144,7 @@ struct IOLog {
 };
 
 struct AsyncFileReadWorkload : public AsyncFileWorkload {
+	constexpr static auto NAME = "AsyncFileRead";
 	// Buffers used to store what is being read or written
 	std::vector<Reference<AsyncFileBuffer>> readBuffers;
 
@@ -185,8 +186,6 @@ struct AsyncFileReadWorkload : public AsyncFileWorkload {
 
 	~AsyncFileReadWorkload() override {}
 
-	std::string description() const override { return "AsyncFileRead"; }
-
 	Future<Void> setup(Database const& cx) override {
 		if (enabled)
 			return _setup(this);
@@ -329,4 +328,4 @@ struct AsyncFileReadWorkload : public AsyncFileWorkload {
 	}
 };
 
-WorkloadFactory<AsyncFileReadWorkload> AsyncFileReadWorkloadFactory("AsyncFileRead");
+WorkloadFactory<AsyncFileReadWorkload> AsyncFileReadWorkloadFactory;
diff --git a/fdbserver/workloads/AsyncFileWrite.actor.cpp b/fdbserver/workloads/AsyncFileWrite.actor.cpp
@@ -26,6 +26,7 @@
 #include "flow/actorcompiler.h" // This must be the last #include.
 
 struct AsyncFileWriteWorkload : public AsyncFileWorkload {
+	static constexpr auto NAME = "AsyncFileWrite";
 	// Buffer used to store what is being written
 	Reference<AsyncFileBuffer> writeBuffer;
 
@@ -52,9 +53,7 @@ struct AsyncFileWriteWorkload : public AsyncFileWorkload {
 		fileSize = getOption(options, "fileSize"_sr, 10002432);
 		sequential = getOption(options, "sequential"_sr, true);
 	}
-
-	std::string description() const override { return "AsyncFileWrite"; }
-
+
 	Future<Void> setup(Database const& cx) override {
 		if (enabled)
 			return _setup(this);
@@ -153,4 +152,4 @@ struct AsyncFileWriteWorkload : public AsyncFileWorkload {
 	}
 };
 
-WorkloadFactory<AsyncFileWriteWorkload> AsyncFileWriteWorkloadFactory("AsyncFileWrite");
+WorkloadFactory<AsyncFileWriteWorkload> AsyncFileWriteWorkloadFactory;
diff --git a/fdbserver/workloads/AtomicOps.actor.cpp b/fdbserver/workloads/AtomicOps.actor.cpp
@@ -26,10 +26,11 @@
 #include "fdbserver/workloads/workloads.actor.h"
 #include "flow/actorcompiler.h" // This must be the last #include.
 
-//#define SevAtomicOpDebug SevInfo
+// #define SevAtomicOpDebug SevInfo
 #define SevAtomicOpDebug SevVerbose
 
 struct AtomicOpsWorkload : TestWorkload {
+	static constexpr auto NAME = "AtomicOps";
 	int opNum, actorCount, nodeCount;
 	uint32_t opType;
 	bool apiVersion500 = false;
@@ -106,9 +107,7 @@ struct AtomicOpsWorkload : TestWorkload {
 		}
 		TraceEvent("AtomicWorkload").detail("OpType", opType);
 	}
-
-	std::string description() const override { return "AtomicOps"; }
-
+
 	Future<Void> setup(Database const& cx) override {
 		if (apiVersion500)
 			cx->apiVersion = ApiVersion(500);
@@ -438,4 +437,4 @@ struct AtomicOpsWorkload : TestWorkload {
 	}
 };
 
-WorkloadFactory<AtomicOpsWorkload> AtomicOpsWorkloadFactory("AtomicOps");
+WorkloadFactory<AtomicOpsWorkload> AtomicOpsWorkloadFactory;
diff --git a/fdbserver/workloads/AtomicOpsApiCorrectness.actor.cpp b/fdbserver/workloads/AtomicOpsApiCorrectness.actor.cpp
@@ -25,6 +25,7 @@
 #include "flow/actorcompiler.h" // This must be the last #include.
 
 struct AtomicOpsApiCorrectnessWorkload : TestWorkload {
+	static constexpr auto NAME = "AtomicOpsApiCorrectness";
 	bool testFailed = false;
 	uint32_t opType;
 
@@ -42,9 +43,7 @@ struct AtomicOpsApiCorrectnessWorkload : TestWorkload {
 	AtomicOpsApiCorrectnessWorkload(WorkloadContext const& wcx) : TestWorkload(wcx) {
 		opType = getOption(options, "opType"_sr, -1);
 	}
-
-	std::string description() const override { return "AtomicOpsApiCorrectness"; }
-
+
 	Future<Void> setup(Database const& cx) override { return Void(); }
 
 	Future<Void> start(Database const& cx) override {
@@ -640,4 +639,4 @@ struct AtomicOpsApiCorrectnessWorkload : TestWorkload {
 	}
 };
 
-WorkloadFactory<AtomicOpsApiCorrectnessWorkload> AtomicOpsApiCorrectnessWorkloadFactory("AtomicOpsApiCorrectness");
+WorkloadFactory<AtomicOpsApiCorrectnessWorkload> AtomicOpsApiCorrectnessWorkloadFactory;
diff --git a/fdbserver/workloads/AtomicRestore.actor.cpp b/fdbserver/workloads/AtomicRestore.actor.cpp
@@ -29,6 +29,7 @@
 
 // A workload which test the correctness of backup and restore process
 struct AtomicRestoreWorkload : TestWorkload {
+	static constexpr auto NAME = "AtomicRestore";
 	double startAfter, restoreAfter;
 	bool fastRestore; // true: use fast restore, false: use old style restore
 	Standalone<VectorRef<KeyRangeRef>> backupRanges;
@@ -73,8 +74,6 @@ struct AtomicRestoreWorkload : TestWorkload {
 		ASSERT(removePrefix.size() == 0);
 	}
 
-	std::string description() const override { return "AtomicRestore"; }
-
 	Future<Void> setup(Database const& cx) override { return Void(); }
 
 	Future<Void> start(Database const& cx) override {
@@ -146,4 +145,4 @@ struct AtomicRestoreWorkload : TestWorkload {
 	}
 };
 
-WorkloadFactory<AtomicRestoreWorkload> AtomicRestoreWorkloadFactory("AtomicRestore");
+WorkloadFactory<AtomicRestoreWorkload> AtomicRestoreWorkloadFactory;
diff --git a/fdbserver/workloads/AtomicSwitchover.actor.cpp b/fdbserver/workloads/AtomicSwitchover.actor.cpp
@@ -27,6 +27,7 @@
 
 // A workload which test the correctness of backup and restore process
 struct AtomicSwitchoverWorkload : TestWorkload {
+	static constexpr auto NAME = "AtomicSwitchover";
 	double switch1delay, switch2delay, stopDelay;
 	Standalone<VectorRef<KeyRangeRef>> backupRanges;
 	Database extraDB;
@@ -43,8 +44,6 @@ struct AtomicSwitchoverWorkload : TestWorkload {
 		extraDB = Database::createSimulatedExtraDatabase(g_simulator->extraDatabases[0], wcx.defaultTenant);
 	}
 
-	std::string description() const override { return "AtomicSwitchover"; }
-
 	Future<Void> setup(Database const& cx) override {
 		if (clientId != 0)
 			return Void();
@@ -199,4 +198,4 @@ struct AtomicSwitchoverWorkload : TestWorkload {
 	}
 };
 
-WorkloadFactory<AtomicSwitchoverWorkload> AtomicSwitchoverWorkloadFactory("AtomicSwitchover");
+WorkloadFactory<AtomicSwitchoverWorkload> AtomicSwitchoverWorkloadFactory;
diff --git a/fdbserver/workloads/AutomaticIdempotencyWorkload.actor.cpp b/fdbserver/workloads/AutomaticIdempotencyWorkload.actor.cpp
@@ -29,6 +29,7 @@
 // If a transaction commits multiple times or doesn't commit, that probably indicates a problem with
 // `determineCommitStatus` in NativeAPI.
 struct AutomaticIdempotencyWorkload : TestWorkload {
+	static constexpr auto NAME = "AutomaticIdempotencyCorrectness";
 	int64_t numTransactions;
 	Key keyPrefix;
 
@@ -37,8 +38,6 @@ struct AutomaticIdempotencyWorkload : TestWorkload {
 		keyPrefix = KeyRef(getOption(options, "keyPrefix"_sr, "automaticIdempotencyKeyPrefix"_sr));
 	}
 
-	std::string description() const override { return "AutomaticIdempotency"; }
-
 	Future<Void> setup(Database const& cx) override { return Void(); }
 
 	Future<Void> start(Database const& cx) override { return _start(this, cx); }
@@ -92,4 +91,4 @@ struct AutomaticIdempotencyWorkload : TestWorkload {
 	void getMetrics(std::vector<PerfMetric>& m) override {}
 };
 
-WorkloadFactory<AutomaticIdempotencyWorkload> AutomaticIdempotencyWorkloadFactory("AutomaticIdempotencyCorrectness");
+WorkloadFactory<AutomaticIdempotencyWorkload> AutomaticIdempotencyWorkloadFactory;
diff --git a/fdbserver/workloads/BackgroundSelectors.actor.cpp b/fdbserver/workloads/BackgroundSelectors.actor.cpp
@@ -31,6 +31,7 @@ KeySelector randomizedSelector(const KeyRef& key, bool orEqual, int offset) {
 }
 
 struct BackgroundSelectorWorkload : TestWorkload {
+	static constexpr auto NAME = "BackgroundSelector";
 	int actorsPerClient, maxDiff, minDrift, maxDrift, resultLimit;
 	double testDuration, transactionsPerSecond;
 
@@ -47,9 +48,7 @@ struct BackgroundSelectorWorkload : TestWorkload {
 		transactionsPerSecond = getOption(options, "transactionsPerSecond"_sr, 10.0) / (clientCount * actorsPerClient);
 		resultLimit = 10 * maxDiff;
 	}
-
-	std::string description() const override { return "BackgroundSelector"; }
-
+
 	Future<Void> setup(Database const& cx) override { return Void(); }
 
 	Future<Void> start(Database const& cx) override { return _start(cx, this); }
@@ -218,4 +217,4 @@ struct BackgroundSelectorWorkload : TestWorkload {
 	}
 };
 
-WorkloadFactory<BackgroundSelectorWorkload> BackgroundSelectorWorkloadFactory("BackgroundSelector");
+WorkloadFactory<BackgroundSelectorWorkload> BackgroundSelectorWorkloadFactory;
diff --git a/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp b/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp
@@ -33,6 +33,7 @@
 
 // A workload which test the correctness of backup and restore process
 struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload {
+	static constexpr auto NAME = "BackupAndParallelRestoreCorrectness";
 	double backupAfter, restoreAfter, abortAndRestartAfter;
 	double backupStartAt, restoreStartAfterBackupFinished, stopDifferentialAfter;
 	Key backupTag;
@@ -136,8 +137,6 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload {
 		}
 	}
 
-	std::string description() const override { return "BackupAndParallelRestoreCorrectness"; }
-
 	Future<Void> setup(Database const& cx) override { return Void(); }
 
 	Future<Void> start(Database const& cx) override {
@@ -791,5 +790,4 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload {
 
 int BackupAndParallelRestoreCorrectnessWorkload::backupAgentRequests = 0;
 
-WorkloadFactory<BackupAndParallelRestoreCorrectnessWorkload> BackupAndParallelRestoreCorrectnessWorkloadFactory(
-    "BackupAndParallelRestoreCorrectness");
+WorkloadFactory<BackupAndParallelRestoreCorrectnessWorkload> BackupAndParallelRestoreCorrectnessWorkloadFactory;
diff --git a/fdbserver/workloads/BackupCorrectness.actor.cpp b/fdbserver/workloads/BackupCorrectness.actor.cpp
@@ -32,6 +32,7 @@
 
 // A workload which test the correctness of backup and restore process
 struct BackupAndRestoreCorrectnessWorkload : TestWorkload {
+	static constexpr auto NAME = "BackupAndRestoreCorrectness";
 	double backupAfter, restoreAfter, abortAndRestartAfter;
 	double minBackupAfter;
 	double backupStartAt, restoreStartAfterBackupFinished, stopDifferentialAfter;
@@ -168,8 +169,6 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload {
 		}
 	}
 
-	std::string description() const override { return "BackupAndRestoreCorrectness"; }
-
 	Future<Void> setup(Database const& cx) override {
 		if (clientId != 0) {
 			return Void();
@@ -947,5 +946,4 @@ std::string getTestEncryptionFileName() {
 	return "test_encryption_key_file";
 }
 
-WorkloadFactory<BackupAndRestoreCorrectnessWorkload> BackupAndRestoreCorrectnessWorkloadFactory(
-    "BackupAndRestoreCorrectness");
+WorkloadFactory<BackupAndRestoreCorrectnessWorkload> BackupAndRestoreCorrectnessWorkloadFactory;