enable per bucket config (#388)

Feature: Add per bucket cache configuration (Lua options file only)
Improvement: --cache-memlayer-sizethreshold is now deprecated and has a new name: --cache-bucket-memlayer-sizethreshold to line up with per cache bucket configuration

5 files changed, 208 insertions, 16 deletions

diff --git a/src/zenserver/config.cpp b/src/zenserver/config.cpp
index 7b8e38e80..e097147fc 100644
--- a/src/zenserver/config.cpp
+++ b/src/zenserver/config.cpp
@@ -313,6 +313,97 @@ public:
 	ZenObjectStoreConfig& Value;
 };
 
+class ZenStructuredCacheBucketsConfigOption : public LuaConfig::OptionValue
+{
+public:
+	ZenStructuredCacheBucketsConfigOption(std::vector<std::pair<std::string, ZenStructuredCacheBucketConfig>>& Value) : Value(Value) {}
+	virtual void Print(std::string_view Indent, zen::StringBuilderBase& StringBuilder) override
+	{
+		if (Value.empty())
+		{
+			StringBuilder.Append("{}");
+			return;
+		}
+		LuaConfig::LuaContainerWriter Writer(StringBuilder, Indent);
+		for (const std::pair<std::string, ZenStructuredCacheBucketConfig>& Bucket : Value)
+		{
+			Writer.BeginContainer("");
+			{
+				Writer.WriteValue("name", Bucket.first);
+				const ZenStructuredCacheBucketConfig& BucketConfig = Bucket.second;
+
+				Writer.WriteValue("maxblocksize", fmt::format("{}", BucketConfig.MaxBlockSize));
+				Writer.BeginContainer("memlayer");
+				{
+					Writer.WriteValue("sizethreshold", fmt::format("{}", BucketConfig.MemCacheSizeThreshold));
+				}
+				Writer.EndContainer();
+
+				Writer.WriteValue("payloadalignment", fmt::format("{}", BucketConfig.PayloadAlignment));
+				Writer.WriteValue("largeobjectthreshold", fmt::format("{}", BucketConfig.PayloadAlignment));
+			}
+			Writer.EndContainer();
+		}
+	}
+	virtual void Parse(sol::object Object) override
+	{
+		if (sol::optional<sol::table> Buckets = Object.as<sol::table>())
+		{
+			for (const auto& Kv : Buckets.value())
+			{
+				if (sol::optional<sol::table> Bucket = Kv.second.as<sol::table>())
+				{
+					ZenStructuredCacheBucketConfig BucketConfig;
+					std::string					   Name = Kv.first.as<std::string>();
+					if (Name.empty())
+					{
+						throw zen::OptionParseException(fmt::format("cache bucket option must have a name."));
+					}
+
+					const uint64_t MaxBlockSize = Bucket.value().get_or("maxblocksize", BucketConfig.MaxBlockSize);
+					if (MaxBlockSize == 0)
+					{
+						throw zen::OptionParseException(
+							fmt::format("maxblocksize option for cache bucket '{}' is invalid. It must be non-zero.", Name));
+					}
+					BucketConfig.MaxBlockSize = MaxBlockSize;
+
+					if (sol::optional<sol::table> Memlayer = Bucket.value().get_or("memlayer", sol::table()))
+					{
+						const uint64_t MemCacheSizeThreshold = Bucket.value().get_or("sizethreshold", BucketConfig.MemCacheSizeThreshold);
+						if (MemCacheSizeThreshold == 0)
+						{
+							throw zen::OptionParseException(
+								fmt::format("memlayer.sizethreshold option for cache bucket '{}' is invalid. It must be non-zero.", Name));
+						}
+						BucketConfig.MemCacheSizeThreshold = Bucket.value().get_or("sizethreshold", BucketConfig.MemCacheSizeThreshold);
+					}
+
+					const uint32_t PayloadAlignment = Bucket.value().get_or("payloadalignment", BucketConfig.PayloadAlignment);
+					if (PayloadAlignment == 0 || !IsPow2(PayloadAlignment))
+					{
+						throw zen::OptionParseException(fmt::format(
+							"payloadalignment option for cache bucket '{}' is invalid. It needs to be non-zero and a power of two.",
+							Name));
+					}
+					BucketConfig.PayloadAlignment = PayloadAlignment;
+
+					const uint64_t LargeObjectThreshold = Bucket.value().get_or("largeobjectthreshold", BucketConfig.LargeObjectThreshold);
+					if (LargeObjectThreshold == 0)
+					{
+						throw zen::OptionParseException(
+							fmt::format("largeobjectthreshold option for cache bucket '{}' is invalid. It must be non-zero.", Name));
+					}
+					BucketConfig.LargeObjectThreshold = LargeObjectThreshold;
+
+					Value.push_back(std::make_pair(std::move(Name), BucketConfig));
+				}
+			}
+		}
+	}
+	std::vector<std::pair<std::string, ZenStructuredCacheBucketConfig>>& Value;
+};
+
 std::shared_ptr<LuaConfig::OptionValue>
 MakeOption(zen::UpstreamCachePolicy& Value)
 {
@@ -331,6 +422,12 @@ MakeOption(zen::ZenObjectStoreConfig& Value)
 	return std::make_shared<ZenObjectStoreConfigOption>(Value);
 };
 
+std::shared_ptr<LuaConfig::OptionValue>
+MakeOption(std::vector<std::pair<std::string, ZenStructuredCacheBucketConfig>>& Value)
+{
+	return std::make_shared<ZenStructuredCacheBucketsConfigOption>(Value);
+};
+
 void
 ParseConfigFile(const std::filesystem::path& Path,
 				ZenServerOptions&			 ServerOptions,
@@ -396,7 +493,7 @@ ParseConfigFile(const std::filesystem::path& Path,
 	LuaOptions.AddOption("cache.accesslog"sv, ServerOptions.StructuredCacheConfig.AccessLogEnabled, "cache-access-log"sv);
 
 	LuaOptions.AddOption("cache.memlayer.sizethreshold"sv,
-						 ServerOptions.StructuredCacheConfig.MemCacheSizeThreshold,
+						 ServerOptions.StructuredCacheConfig.BucketConfig.MemCacheSizeThreshold,
 						 "cache-memlayer-sizethreshold"sv);
 	LuaOptions.AddOption("cache.memlayer.targetfootprint"sv,
 						 ServerOptions.StructuredCacheConfig.MemTargetFootprintBytes,
@@ -406,6 +503,19 @@ ParseConfigFile(const std::filesystem::path& Path,
 						 "cache-memlayer-triminterval"sv);
 	LuaOptions.AddOption("cache.memlayer.maxage"sv, ServerOptions.StructuredCacheConfig.MemMaxAgeSeconds, "cache-memlayer-maxage"sv);
 
+	LuaOptions.AddOption("cache.bucket.maxblocksize"sv,
+						 ServerOptions.StructuredCacheConfig.BucketConfig.MaxBlockSize,
+						 "cache-bucket-maxblocksize"sv);
+	LuaOptions.AddOption("cache.bucket.memlayer.sizethreshold"sv,
+						 ServerOptions.StructuredCacheConfig.BucketConfig.MemCacheSizeThreshold,
+						 "cache-bucket-memlayer-sizethreshold"sv);
+	LuaOptions.AddOption("cache.bucket.payloadalignment"sv,
+						 ServerOptions.StructuredCacheConfig.BucketConfig.PayloadAlignment,
+						 "cache-bucket-payloadalignment"sv);
+	LuaOptions.AddOption("cache.bucket.largeobjectthreshold"sv,
+						 ServerOptions.StructuredCacheConfig.BucketConfig.LargeObjectThreshold,
+						 "cache-bucket-largeobjectthreshold"sv);
+
 	////// cache.upstream
 	LuaOptions.AddOption("cache.upstream.policy"sv, ServerOptions.UpstreamCacheConfig.CachePolicy, "upstream-cache-policy"sv);
 	LuaOptions.AddOption("cache.upstream.upstreamthreadcount"sv,
@@ -493,6 +603,8 @@ ParseConfigFile(const std::filesystem::path& Path,
 						 ServerOptions.WorksSpacesConfig.AllowConfigurationChanges,
 						 "workspaces-allow-changes"sv);
 
+	LuaOptions.AddOption("cache.buckets"sv, ServerOptions.StructuredCacheConfig.PerBucketConfigs, "cache.buckets"sv);
+
 	LuaOptions.Parse(Path, CmdLineResult);
 
 	// These have special command line processing so we make sure we export them if they were configured on command line
@@ -504,6 +616,10 @@ ParseConfigFile(const std::filesystem::path& Path,
 	{
 		LuaOptions.Touch("server.objectstore.buckets"sv);
 	}
+	if (!ServerOptions.StructuredCacheConfig.PerBucketConfigs.empty())
+	{
+		LuaOptions.Touch("cache.buckets"sv);
+	}
 
 	if (!OutputConfigFile.empty())
 	{
@@ -916,8 +1032,9 @@ ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
 		"cache",
 		"",
 		"cache-memlayer-sizethreshold",
-		"The largest size of a cache entry that may be cached in memory. Default set to 1024 (1 Kb). Set to 0 to disable memory caching.",
-		cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.MemCacheSizeThreshold)->default_value("1024"),
+		"The largest size of a cache entry that may be cached in memory. Default set to 1024 (1 Kb). Set to 0 to disable memory caching. "
+		"Obsolete, replaced by `--cache-bucket-memlayer-sizethreshold`",
+		cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.BucketConfig.MemCacheSizeThreshold)->default_value("1024"),
 		"");
 
 	options.add_option("cache",
@@ -941,6 +1058,36 @@ ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
 					   cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.MemMaxAgeSeconds)->default_value("86400"),
 					   "");
 
+	options.add_option("cache",
+					   "",
+					   "cache-bucket-maxblocksize",
+					   "Max size of cache bucket blocks. Default set to 1073741824 (1GB).",
+					   cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.BucketConfig.MaxBlockSize)->default_value("1073741824"),
+					   "");
+
+	options.add_option("cache",
+					   "",
+					   "cache-bucket-payloadalignment",
+					   "Payload alignement for cache bucket blocks. Default set to 16.",
+					   cxxopts::value<uint32_t>(ServerOptions.StructuredCacheConfig.BucketConfig.PayloadAlignment)->default_value("16"),
+					   "");
+
+	options.add_option(
+		"cache",
+		"",
+		"cache-bucket-largeobjectthreshold",
+		"Threshold for storing cache bucket values as loose files. Default set to 131072 (128 KB).",
+		cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.BucketConfig.LargeObjectThreshold)->default_value("131072"),
+		"");
+
+	options.add_option(
+		"cache",
+		"",
+		"cache-bucket-memlayer-sizethreshold",
+		"The largest size of a cache entry that may be cached in memory. Default set to 1024 (1 Kb). Set to 0 to disable memory caching.",
+		cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.BucketConfig.MemCacheSizeThreshold)->default_value("1024"),
+		"");
+
 	options.add_option("gc",
 					   "",
 					   "gc-cache-attachment-store",
diff --git a/src/zenserver/config.h b/src/zenserver/config.h
index bd277cd88..1d7d22ce9 100644
--- a/src/zenserver/config.h
+++ b/src/zenserver/config.h
@@ -119,15 +119,24 @@ struct ZenStatsConfig
 	int			StatsdPort = 8125;
 };
 
+struct ZenStructuredCacheBucketConfig
+{
+	uint64_t MaxBlockSize		   = 1ull << 30;
+	uint32_t PayloadAlignment	   = 1u << 4;
+	uint64_t MemCacheSizeThreshold = 1 * 1024;
+	uint64_t LargeObjectThreshold  = 128 * 1024;
+};
+
 struct ZenStructuredCacheConfig
 {
-	bool	 Enabled				 = true;
-	bool	 WriteLogEnabled		 = false;
-	bool	 AccessLogEnabled		 = false;
-	uint64_t MemCacheSizeThreshold	 = 1 * 1024;
-	uint64_t MemTargetFootprintBytes = 512 * 1024 * 1024;
-	uint64_t MemTrimIntervalSeconds	 = 60;
-	uint64_t MemMaxAgeSeconds		 = gsl::narrow<uint64_t>(std::chrono::seconds(std::chrono::days(1)).count());
+	bool																Enabled			 = true;
+	bool																WriteLogEnabled	 = false;
+	bool																AccessLogEnabled = false;
+	std::vector<std::pair<std::string, ZenStructuredCacheBucketConfig>> PerBucketConfigs;
+	ZenStructuredCacheBucketConfig										BucketConfig;
+	uint64_t															MemTargetFootprintBytes = 512 * 1024 * 1024;
+	uint64_t															MemTrimIntervalSeconds	= 60;
+	uint64_t MemMaxAgeSeconds = gsl::narrow<uint64_t>(std::chrono::seconds(std::chrono::days(1)).count());
 };
 
 struct ZenProjectStoreConfig
diff --git a/src/zenserver/zenserver.cpp b/src/zenserver/zenserver.cpp
index 366944ffc..1ad94ed63 100644
--- a/src/zenserver/zenserver.cpp
+++ b/src/zenserver/zenserver.cpp
@@ -547,10 +547,26 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 	Config.AllowAutomaticCreationOfNamespaces = true;
 	Config.Logging							  = {.EnableWriteLog  = ServerOptions.StructuredCacheConfig.WriteLogEnabled,
 												 .EnableAccessLog = ServerOptions.StructuredCacheConfig.AccessLogEnabled};
-	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.MemCacheSizeThreshold = ServerOptions.StructuredCacheConfig.MemCacheSizeThreshold,
-	Config.NamespaceConfig.DiskLayerConfig.MemCacheTargetFootprintBytes		  = ServerOptions.StructuredCacheConfig.MemTargetFootprintBytes;
-	Config.NamespaceConfig.DiskLayerConfig.MemCacheTrimIntervalSeconds		  = ServerOptions.StructuredCacheConfig.MemTrimIntervalSeconds;
-	Config.NamespaceConfig.DiskLayerConfig.MemCacheMaxAgeSeconds			  = ServerOptions.StructuredCacheConfig.MemMaxAgeSeconds;
+	for (const auto& It : ServerOptions.StructuredCacheConfig.PerBucketConfigs)
+	{
+		const std::string&					   BucketName	   = It.first;
+		const ZenStructuredCacheBucketConfig&  ZenBucketConfig = It.second;
+		ZenCacheDiskLayer::BucketConfiguration BucketConfig	   = {.MaxBlockSize			 = ZenBucketConfig.MaxBlockSize,
+																  .PayloadAlignment		 = ZenBucketConfig.PayloadAlignment,
+																  .MemCacheSizeThreshold = ZenBucketConfig.MemCacheSizeThreshold,
+																  .LargeObjectThreshold	 = ZenBucketConfig.LargeObjectThreshold};
+		Config.NamespaceConfig.DiskLayerConfig.BucketConfigMap.insert_or_assign(BucketName, BucketConfig);
+	}
+	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.MaxBlockSize = ServerOptions.StructuredCacheConfig.BucketConfig.MaxBlockSize,
+	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.PayloadAlignment =
+		ServerOptions.StructuredCacheConfig.BucketConfig.PayloadAlignment,
+	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.MemCacheSizeThreshold =
+		ServerOptions.StructuredCacheConfig.BucketConfig.MemCacheSizeThreshold,
+	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.LargeObjectThreshold =
+		ServerOptions.StructuredCacheConfig.BucketConfig.LargeObjectThreshold,
+	Config.NamespaceConfig.DiskLayerConfig.MemCacheTargetFootprintBytes = ServerOptions.StructuredCacheConfig.MemTargetFootprintBytes;
+	Config.NamespaceConfig.DiskLayerConfig.MemCacheTrimIntervalSeconds	= ServerOptions.StructuredCacheConfig.MemTrimIntervalSeconds;
+	Config.NamespaceConfig.DiskLayerConfig.MemCacheMaxAgeSeconds		= ServerOptions.StructuredCacheConfig.MemMaxAgeSeconds;
 
 	if (ServerOptions.IsDedicated)
 	{
diff --git a/src/zenstore/cache/cachedisklayer.cpp b/src/zenstore/cache/cachedisklayer.cpp
index 8b120fda5..e7b2e6bc6 100644
--- a/src/zenstore/cache/cachedisklayer.cpp
+++ b/src/zenstore/cache/cachedisklayer.cpp
@@ -3617,7 +3617,15 @@ ZenCacheDiskLayer::GetOrCreateBucket(std::string_view InBucket)
 
 	// We create the bucket without holding a lock since contructor calls GcManager::AddGcReferencer which takes an exclusive lock.
 	// This can cause a deadlock, if GC is running we would block while holding ZenCacheDiskLayer::m_Lock
-	std::unique_ptr<CacheBucket> Bucket(std::make_unique<CacheBucket>(m_Gc, m_TotalMemCachedSize, InBucket, m_Configuration.BucketConfig));
+	BucketConfiguration* BucketConfig = &m_Configuration.BucketConfig;
+	if (auto It = m_Configuration.BucketConfigMap.find_as(InBucket,
+														  std::hash<std::string_view>(),
+														  eastl::equal_to_2<std::string, std::string_view>());
+		It != m_Configuration.BucketConfigMap.end())
+	{
+		BucketConfig = &It->second;
+	}
+	std::unique_ptr<CacheBucket> Bucket(std::make_unique<CacheBucket>(m_Gc, m_TotalMemCachedSize, InBucket, *BucketConfig));
 
 	RwLock::ExclusiveLockScope Lock(m_Lock);
 	if (auto It = m_Buckets.find_as(InBucket, std::hash<std::string_view>(), eastl::equal_to_2<std::string, std::string_view>());
@@ -3944,8 +3952,17 @@ ZenCacheDiskLayer::DiscoverBuckets()
 			const std::string BucketName = PathToUtf8(BucketPath.stem());
 			try
 			{
+				BucketConfiguration* BucketConfig = &m_Configuration.BucketConfig;
+				if (auto It = m_Configuration.BucketConfigMap.find_as(std::string_view(BucketName),
+																	  std::hash<std::string_view>(),
+																	  eastl::equal_to_2<std::string, std::string_view>());
+					It != m_Configuration.BucketConfigMap.end())
+				{
+					BucketConfig = &It->second;
+				}
+
 				std::unique_ptr<CacheBucket> NewBucket =
-					std::make_unique<CacheBucket>(m_Gc, m_TotalMemCachedSize, BucketName, m_Configuration.BucketConfig);
+					std::make_unique<CacheBucket>(m_Gc, m_TotalMemCachedSize, BucketName, *BucketConfig);
 
 				CacheBucket* Bucket = nullptr;
 				{
diff --git a/src/zenstore/include/zenstore/cache/cachedisklayer.h b/src/zenstore/include/zenstore/cache/cachedisklayer.h
index 5a51718d3..f36e780b9 100644
--- a/src/zenstore/include/zenstore/cache/cachedisklayer.h
+++ b/src/zenstore/include/zenstore/cache/cachedisklayer.h
@@ -119,6 +119,9 @@ public:
 
 	struct Configuration
 	{
+		typedef eastl::unordered_map<std::string, BucketConfiguration, std::hash<std::string>, std::equal_to<std::string>>
+							BucketConfigMap_t;
+		BucketConfigMap_t	BucketConfigMap;
 		BucketConfiguration BucketConfig;
 		uint64_t			MemCacheTargetFootprintBytes = 512 * 1024 * 1024;
 		uint64_t			MemCacheTrimIntervalSeconds	 = 60;