add gc single threaded option (#104)

* add option to force gcv2 to run single threaded

8 files changed, 38 insertions, 6 deletions

diff --git a/src/zen/cmds/admin_cmd.cpp b/src/zen/cmds/admin_cmd.cpp
index 15a729c78..f5bd15ea2 100644
--- a/src/zen/cmds/admin_cmd.cpp
+++ b/src/zen/cmds/admin_cmd.cpp
@@ -113,6 +113,12 @@ GcCommand::GcCommand()
 						 "<compactblockthreshold>");
 	m_Options
 		.add_option("", "", "verbose", "Enable verbose logging for GC", cxxopts::value(m_Verbose)->default_value("false"), "<verbose>");
+	m_Options.add_option("",
+						 "",
+						 "single-threaded",
+						 "Force GC to run single threaded",
+						 cxxopts::value(m_SingleThreaded)->default_value("false"),
+						 "<single-threaded>");
 }
 
 GcCommand::~GcCommand()
@@ -165,6 +171,7 @@ GcCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		Params.Add({"compactblockthreshold", fmt::format("{}", m_CompactBlockThreshold)});
 	}
 	Params.Add({"verbose", m_Verbose ? "true" : "false"});
+	Params.Add({"singlethreaded", m_SingleThreaded ? "true" : "false"});
 
 	cpr::Session Session;
 	Session.SetHeader(cpr::Header{{"Accept", "application/json"}});
diff --git a/src/zen/cmds/admin_cmd.h b/src/zen/cmds/admin_cmd.h
index 5fdd8672a..e26e7f4e7 100644
--- a/src/zen/cmds/admin_cmd.h
+++ b/src/zen/cmds/admin_cmd.h
@@ -50,6 +50,7 @@ private:
 	bool			 m_ForceUseGCV2{false};
 	uint32_t		 m_CompactBlockThreshold = 90;
 	bool			 m_Verbose{false};
+	bool			 m_SingleThreaded{false};
 };
 
 class GcStatusCommand : public StorageCommand
diff --git a/src/zenserver/admin/admin.cpp b/src/zenserver/admin/admin.cpp
index 75ff03912..1eeb5637a 100644
--- a/src/zenserver/admin/admin.cpp
+++ b/src/zenserver/admin/admin.cpp
@@ -290,6 +290,7 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 				Response << "UseGCVersion" << ((State.Config.UseGCVersion == GcVersion::kV1) ? "1" : "2");
 				Response << "CompactBlockUsageThresholdPercent" << State.Config.CompactBlockUsageThresholdPercent;
 				Response << "Verbose" << State.Config.Verbose;
+				Response << "SingleThreaded" << State.Config.SingleThreaded;
 			}
 			Response.EndObject();
 			Response << "AreDiskWritesBlocked" << State.AreDiskWritesBlocked;
@@ -410,6 +411,11 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 				GcParams.Verbose = Param == "true"sv;
 			}
 
+			if (auto Param = Params.GetValue("singlethreaded"); Param.empty() == false)
+			{
+				GcParams.SingleThreaded = Param == "true"sv;
+			}
+
 			const bool Started = m_GcScheduler.TriggerGc(GcParams);
 
 			CbObjectWriter Response;
diff --git a/src/zenserver/config.cpp b/src/zenserver/config.cpp
index 56d14b4a9..55c90cbe1 100644
--- a/src/zenserver/config.cpp
+++ b/src/zenserver/config.cpp
@@ -517,6 +517,7 @@ ParseConfigFile(const std::filesystem::path& Path,
 						 ServerOptions.GcConfig.CompactBlockUsageThresholdPercent,
 						 "gc-compactblock-threshold"sv);
 	LuaOptions.AddOption("gc.verbose"sv, ServerOptions.GcConfig.Verbose, "gc-verbose"sv);
+	LuaOptions.AddOption("gc.single-threaded"sv, ServerOptions.GcConfig.SingleThreaded, "gc-single-threaded"sv);
 
 	////// gc
 	LuaOptions.AddOption("gc.cache.maxdurationseconds"sv, ServerOptions.GcConfig.Cache.MaxDurationSeconds, "gc-cache-duration-seconds"sv);
@@ -982,6 +983,13 @@ ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
 					   cxxopts::value<bool>(ServerOptions.GcConfig.Verbose)->default_value("false"),
 					   "");
 
+	options.add_option("gc",
+					   "",
+					   "gc-single-threaded",
+					   "Force GC to run single threaded.",
+					   cxxopts::value<bool>(ServerOptions.GcConfig.SingleThreaded)->default_value("false"),
+					   "");
+
 	options.add_option("objectstore",
 					   "",
 					   "objectstore-enabled",
diff --git a/src/zenserver/config.h b/src/zenserver/config.h
index fec871a0e..41e05c7ea 100644
--- a/src/zenserver/config.h
+++ b/src/zenserver/config.h
@@ -75,6 +75,7 @@ struct ZenGcConfig
 	bool						  UseGCV2							= false;
 	uint32_t					  CompactBlockUsageThresholdPercent = 90;
 	bool						  Verbose							= false;
+	bool						  SingleThreaded					= false;
 };
 
 struct ZenOpenIdProviderConfig
diff --git a/src/zenserver/zenserver.cpp b/src/zenserver/zenserver.cpp
index 48ea89204..62c9227fe 100644
--- a/src/zenserver/zenserver.cpp
+++ b/src/zenserver/zenserver.cpp
@@ -312,7 +312,8 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 							   .LightweightInterval				  = std::chrono::seconds(ServerOptions.GcConfig.LightweightIntervalSeconds),
 							   .UseGCVersion					  = ServerOptions.GcConfig.UseGCV2 ? GcVersion::kV2 : GcVersion::kV1,
 							   .CompactBlockUsageThresholdPercent = ServerOptions.GcConfig.CompactBlockUsageThresholdPercent,
-							   .Verbose							  = ServerOptions.GcConfig.Verbose};
+							   .Verbose							  = ServerOptions.GcConfig.Verbose,
+							   .SingleThreaded					  = ServerOptions.GcConfig.SingleThreaded};
 	m_GcScheduler.Initialize(GcConfig);
 
 	// Create and register admin interface last to make sure all is properly initialized
diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index 8db34b9c5..dc75a29f2 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -1767,6 +1767,7 @@ GcScheduler::SchedulerThread()
 			GcVersion			 UseGCVersion					   = m_Config.UseGCVersion;
 			uint32_t			 CompactBlockUsageThresholdPercent = m_Config.CompactBlockUsageThresholdPercent;
 			bool				 Verbose						   = m_Config.Verbose;
+			bool				 SingleThreaded					   = m_Config.SingleThreaded;
 
 			bool DiskSpaceGCTriggered = false;
 			bool TimeBasedGCTriggered = false;
@@ -1803,8 +1804,9 @@ GcScheduler::SchedulerThread()
 				UseGCVersion = TriggerParams.ForceGCVersion.value_or(UseGCVersion);
 				CompactBlockUsageThresholdPercent =
 					TriggerParams.CompactBlockUsageThresholdPercent.value_or(CompactBlockUsageThresholdPercent);
-				Verbose = TriggerParams.Verbose.value_or(Verbose);
-				DoGc	= true;
+				Verbose		   = TriggerParams.Verbose.value_or(Verbose);
+				SingleThreaded = TriggerParams.SingleThreaded.value_or(SingleThreaded);
+				DoGc		   = true;
 			}
 
 			if (m_TriggerScrubParams)
@@ -2021,7 +2023,8 @@ GcScheduler::SchedulerThread()
 						   SkipCid,
 						   UseGCVersion,
 						   CompactBlockUsageThresholdPercent,
-						   Verbose);
+						   Verbose,
+						   SingleThreaded);
 
 			m_GcManager.SetCancelGC(false);
 
@@ -2108,7 +2111,8 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 							bool					  SkipCid,
 							GcVersion				  UseGCVersion,
 							uint32_t				  CompactBlockUsageThresholdPercent,
-							bool					  Verbose)
+							bool					  Verbose,
+							bool					  SingleThreaded)
 {
 	ZEN_TRACE_CPU("GcScheduler::CollectGarbage");
 
@@ -2177,6 +2181,7 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 													  .IsDeleteMode						 = Delete,
 													  .SkipCidDelete					 = SkipCid,
 													  .Verbose							 = Verbose,
+													  .SingleThread						 = SingleThreaded,
 													  .CompactBlockUsageThresholdPercent = CompactBlockUsageThresholdPercent,
 													  .DiskReservePath					 = m_Config.RootDirectory / "reserve.gc"};
 					GcClock::TimePoint GcStartTime = GcClock::Now();
diff --git a/src/zenstore/include/zenstore/gc.h b/src/zenstore/include/zenstore/gc.h
index c3a71baa6..2edb5e0a5 100644
--- a/src/zenstore/include/zenstore/gc.h
+++ b/src/zenstore/include/zenstore/gc.h
@@ -444,6 +444,7 @@ struct GcSchedulerConfig
 	GcVersion			  UseGCVersion						= GcVersion::kV1;
 	uint32_t			  CompactBlockUsageThresholdPercent = 90;
 	bool				  Verbose							= false;
+	bool				  SingleThreaded					= false;
 };
 
 struct GcSchedulerState
@@ -517,6 +518,7 @@ public:
 		std::optional<GcVersion> ForceGCVersion;
 		std::optional<uint32_t>	 CompactBlockUsageThresholdPercent;
 		std::optional<bool>		 Verbose;
+		std::optional<bool>		 SingleThreaded;
 	};
 
 	bool TriggerGc(const TriggerGcParams& Params);
@@ -542,7 +544,8 @@ private:
 								bool					  SkipCid,
 								GcVersion				  UseGCVersion,
 								uint32_t				  CompactBlockUsageThresholdPercent,
-								bool					  Verbose);
+								bool					  Verbose,
+								bool					  SingleThreaded);
 	void		 ScrubStorage(bool DoDelete, bool SkipCid, std::chrono::seconds TimeSlice);
 	LoggerRef	 Log() { return m_Log; }
 	virtual bool AreDiskWritesAllowed() const override { return !m_AreDiskWritesBlocked.load(); }