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

1 files changed, 150 insertions, 3 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",