Make gc reserve a global resource

1 files changed, 163 insertions, 14 deletions

diff --git a/zenstore/gc.cpp b/zenstore/gc.cpp
index dee8c209f..ab7eece20 100644
--- a/zenstore/gc.cpp
+++ b/zenstore/gc.cpp
@@ -5,6 +5,7 @@
 #include <zencore/compactbinary.h>
 #include <zencore/compactbinarybuilder.h>
 #include <zencore/compactbinaryvalidation.h>
+#include <zencore/except.h>
 #include <zencore/filesystem.h>
 #include <zencore/fmtutils.h>
 #include <zencore/logging.h>
@@ -19,6 +20,15 @@
 #include <fmt/format.h>
 #include <filesystem>
 
+#if ZEN_PLATFORM_WINDOWS
+#	include <zencore/windows.h>
+#else
+#	include <fcntl.h>
+#	include <sys/file.h>
+#	include <sys/stat.h>
+#	include <unistd.h>
+#endif
+
 #if ZEN_WITH_TESTS
 #	include <zencore/compress.h>
 #	include <algorithm>
@@ -32,6 +42,102 @@ namespace fs = std::filesystem;
 
 //////////////////////////////////////////////////////////////////////////
 
+namespace {
+	std::error_code CreateGCReserve(const std::filesystem::path& Path, uint64_t Size)
+	{
+		if (Size == 0)
+		{
+			std::filesystem::remove(Path);
+			return std::error_code{};
+		}
+		CreateDirectories(Path.parent_path());
+		if (std::filesystem::is_regular_file(Path) && std::filesystem::file_size(Path) == Size)
+		{
+			return std::error_code();
+		}
+#if ZEN_PLATFORM_WINDOWS
+		DWORD dwCreationDisposition = CREATE_ALWAYS;
+		DWORD dwDesiredAccess		= GENERIC_READ | GENERIC_WRITE;
+
+		const DWORD dwShareMode			 = 0;
+		const DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
+		HANDLE		hTemplateFile		 = nullptr;
+
+		HANDLE FileHandle = CreateFile(Path.c_str(),
+									   dwDesiredAccess,
+									   dwShareMode,
+									   /* lpSecurityAttributes */ nullptr,
+									   dwCreationDisposition,
+									   dwFlagsAndAttributes,
+									   hTemplateFile);
+
+		if (FileHandle == INVALID_HANDLE_VALUE)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+		bool		  Keep = true;
+		auto		  _	   = MakeGuard([FileHandle, &Keep, Path]() {
+			::CloseHandle(FileHandle);
+			if (!Keep)
+			{
+				::DeleteFile(Path.c_str());
+			}
+		});
+		LARGE_INTEGER liFileSize;
+		liFileSize.QuadPart = Size;
+		BOOL OK				= ::SetFilePointerEx(FileHandle, liFileSize, 0, FILE_BEGIN);
+		if (!OK)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+		OK = ::SetEndOfFile(FileHandle);
+		if (!OK)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+		Keep = true;
+#else
+		int OpenFlags = O_CLOEXEC | O_RDWR | O_CREAT;
+		int Fd		  = open(Path.c_str(), OpenFlags, 0666);
+		if (Fd < 0)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+
+		bool Keep = true;
+		auto _	  = MakeGuard([Fd, &Keep, Path]() {
+			   close(Fd);
+			   if (!Keep)
+			   {
+				   unlink(Path.c_str());
+			   }
+		   });
+
+		if (fchmod(Fd, 0666) < 0)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+
+#	if ZEN_PLATFORM_MAC
+		if (ftruncate(Fd, (off_t)FileSize) < 0)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+#	else
+		if (ftruncate64(Fd, (off64_t)FileSize) < 0)
+		{
+			return zen::MakeErrorCodeFromLastError();
+		}
+#	endif
+		Keep = true;
+#endif
+		return std::error_code{};
+	}
+
+}  // namespace
+
+//////////////////////////////////////////////////////////////////////////
+
 CbObject
 LoadCompactBinaryObject(const fs::path& Path)
 {
@@ -75,6 +181,8 @@ struct GcContext::GcState
 	GcClock::Duration  m_MaxCacheDuration	 = std::chrono::hours(24);
 	bool			   m_DeletionMode		 = true;
 	bool			   m_CollectSmallObjects = false;
+
+	std::filesystem::path DiskReservePath;
 };
 
 GcContext::GcContext(GcClock::TimePoint Time) : m_State(std::make_unique<GcState>())
@@ -195,6 +303,27 @@ GcContext::MaxCacheDuration(GcClock::Duration Duration)
 	m_State->m_MaxCacheDuration = Duration;
 }
 
+void
+GcContext::DiskReservePath(const std::filesystem::path& Path)
+{
+	m_State->DiskReservePath = Path;
+}
+
+uint64_t
+GcContext::ClaimGCReserve()
+{
+	if (!std::filesystem::is_regular_file(m_State->DiskReservePath))
+	{
+		return 0;
+	}
+	uint64_t ReclaimedSize = std::filesystem::file_size(m_State->DiskReservePath);
+	if (std::filesystem::remove(m_State->DiskReservePath))
+	{
+		return ReclaimedSize;
+	}
+	return 0;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 GcContributor::GcContributor(CasGc& Gc) : m_Gc(Gc)
@@ -390,6 +519,15 @@ GcScheduler::Initialize(const GcSchedulerConfig& Config)
 
 	std::filesystem::create_directories(Config.RootDirectory);
 
+	std::error_code Ec = CreateGCReserve(m_Config.RootDirectory / "reserve.gc", m_Config.DiskReserveSize);
+	if (Ec)
+	{
+		ZEN_WARN("unable to create GC reserve at '{}' with size {}, reason '{}'",
+				 m_Config.RootDirectory / "reserve.gc",
+				 NiceBytes(m_Config.DiskReserveSize),
+				 Ec.message());
+	}
+
 	m_LastGcTime = GcClock::Now();
 
 	if (CbObject SchedulerState = LoadCompactBinaryObject(Config.RootDirectory / "gc_state"))
@@ -517,6 +655,7 @@ GcScheduler::SchedulerThread()
 		GcCtx.SetDeletionMode(true);
 		GcCtx.CollectSmallObjects(m_Config.CollectSmallObjects);
 		GcCtx.MaxCacheDuration(m_Config.MaxCacheDuration);
+		GcCtx.DiskReservePath(m_Config.RootDirectory / "reserve.gc");
 
 		if (m_TriggerParams)
 		{
@@ -530,27 +669,37 @@ GcScheduler::SchedulerThread()
 			}
 		}
 
-		Stopwatch Timer;
-
 		ZEN_INFO("garbage collection STARTING, small objects gc {}, max cache duration {}",
 				 GcCtx.CollectSmallObjects() ? "ENABLED"sv : "DISABLED"sv,
 				 NiceTimeSpanMs(uint64_t(std::chrono::duration_cast<std::chrono::milliseconds>(GcCtx.MaxCacheDuration()).count())));
+		{
+			Stopwatch  Timer;
+			const auto __ =
+				MakeGuard([this, &Timer] { ZEN_INFO("garbage collection DONE after {}", NiceTimeSpanMs(Timer.GetElapsedTimeMs())); });
 
-		m_CasGc.CollectGarbage(GcCtx);
+			m_CasGc.CollectGarbage(GcCtx);
 
-		m_LastGcTime = GcClock::Now();
-		m_NextGcTime = NextGcTime(m_LastGcTime);
-		WaitTime	 = m_Config.MonitorInterval;
+			m_LastGcTime = GcClock::Now();
+			m_NextGcTime = NextGcTime(m_LastGcTime);
+			WaitTime	 = m_Config.MonitorInterval;
 
-		{
-			const fs::path Path = m_Config.RootDirectory / "gc_state";
-			ZEN_DEBUG("saving scheduler state to '{}'", Path);
-			CbObjectWriter SchedulderState;
-			SchedulderState << "LastGcTime"sv << static_cast<int64_t>(m_LastGcTime.time_since_epoch().count());
-			SaveCompactBinaryObject(Path, SchedulderState.Save());
-		}
+			{
+				const fs::path Path = m_Config.RootDirectory / "gc_state";
+				ZEN_DEBUG("saving scheduler state to '{}'", Path);
+				CbObjectWriter SchedulderState;
+				SchedulderState << "LastGcTime"sv << static_cast<int64_t>(m_LastGcTime.time_since_epoch().count());
+				SaveCompactBinaryObject(Path, SchedulderState.Save());
+			}
 
-		ZEN_INFO("garbage collection DONE after {}", NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
+			std::error_code Ec = CreateGCReserve(m_Config.RootDirectory / "reserve.gc", m_Config.DiskReserveSize);
+			if (Ec)
+			{
+				ZEN_WARN("unable to create GC reserve at '{}' with size {}, reason '{}'",
+						 m_Config.RootDirectory / "reserve.gc",
+						 NiceBytes(m_Config.DiskReserveSize),
+						 Ec.message());
+			}
+		}
 
 		uint32_t RunningState = static_cast<uint32_t>(GcSchedulerStatus::kRunning);
 		if (!m_Status.compare_exchange_strong(RunningState, static_cast<uint32_t>(GcSchedulerStatus::kIdle)))