[CAS] Fix Windows build for CAS unittest

Fix the CAS unit-test build for windows which doesn't have the same
setenv function and constructor attributes. Implement the default ondisk
cas differently so it can be overwritten from environmental variable,
or overwrite the value in process directly.

Fix: #7883

Author: cachemeifyoucan

llvm/lib/CAS/OnDiskCommon.cpp

@@ -9,18 +9,40 @@
 #include "OnDiskCommon.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/Process.h"
+#include <mutex>
+#include <optional>
 
 using namespace llvm;
 
+static uint64_t OnDiskCASMaxMappingSize = 0;
+
 Expected<std::optional<uint64_t>> cas::ondisk::getOverriddenMaxMappingSize() {
-  constexpr const char *EnvVar = "LLVM_CAS_MAX_MAPPING_SIZE";
-  const char *Value = getenv(EnvVar);
-  if (!Value)
+  static std::once_flag Flag;
+  Error Err = Error::success();
+  std::call_once(Flag, [&Err] {
+    ErrorAsOutParameter EAO(&Err);
+    constexpr const char *EnvVar = "LLVM_CAS_MAX_MAPPING_SIZE";
+    auto Value = sys::Process::GetEnv(EnvVar);
+    if (!Value)
+      return;
+
+    uint64_t Size;
+    if (StringRef(*Value).getAsInteger(/*auto*/ 0, Size))
+      Err = createStringError(inconvertibleErrorCode(),
+                              "invalid value for %s: expected integer", EnvVar);
+    OnDiskCASMaxMappingSize = Size;
+  });
+
+  if (Err)
+    return std::move(Err);
+
+  if (OnDiskCASMaxMappingSize == 0)
     return std::nullopt;
 
-  uint64_t Size;
-  if (StringRef(Value).getAsInteger(/*auto*/ 0, Size))
-    return createStringError(inconvertibleErrorCode(),
-                             "invalid value for %s: expected integer", EnvVar);
-  return Size;
+  return OnDiskCASMaxMappingSize;
+}
+
+void cas::ondisk::setMaxMappingSize(uint64_t Size) {
+  OnDiskCASMaxMappingSize = Size;
 }

llvm/lib/CAS/OnDiskCommon.h

@@ -14,11 +14,17 @@
 
 namespace llvm::cas::ondisk {
 
-/// Retrieves an overridden maximum mapping size for CAS files, if any, by
-/// checking LLVM_CAS_MAX_MAPPING_SIZE in the environment. If the value is
-/// unreadable, returns an error.
+/// Retrieves an overridden maximum mapping size for CAS files, if any,
+/// speicified by LLVM_CAS_MAX_MAPPING_SIZE in the environment or set by
+/// `setMaxMappingSize()`. If the value from environment is unreadable, returns
+/// an error.
 Expected<std::optional<uint64_t>> getOverriddenMaxMappingSize();
 
+/// Set MaxMappingSize for ondisk CAS. This function is not thread-safe and
+/// should be set before creaing any ondisk CAS and does not affect CAS already
+/// created. Set value 0 to use default size.
+void setMaxMappingSize(uint64_t Size);
+
 } // namespace llvm::cas::ondisk
 
 #endif // LLVM_LIB_CAS_ONDISKCOMMON_H

llvm/unittests/CAS/CASTestConfig.cpp

@@ -10,6 +10,7 @@
 #include "llvm/CAS/ActionCache.h"
 #include "llvm/CAS/ObjectStore.h"
 #include "llvm/RemoteCachingService/RemoteCachingService.h"
+#include "llvm/Support/CommandLine.h"
 #include "gtest/gtest.h"
 #include <mutex>
 
@@ -27,23 +28,20 @@ TestingAndDir createInMemory(int I) {
   return TestingAndDir{std::move(CAS), std::move(Cache), nullptr, std::nullopt};
 }
 
-__attribute__((constructor)) static void configureCASTestEnv() {
-  // Restrict the size of the on-disk CAS for tests. This allows testing in
-  // constrained environments (e.g. small TMPDIR). It also prevents leaving
-  // behind large files on file systems that do not support sparse files if a
-  // test  crashes before resizing the file.
-  static std::once_flag Flag;
-  std::call_once(Flag, [] {
-    size_t Limit = 100 * 1024 * 1024;
-    std::string LimitStr = std::to_string(Limit);
-    setenv("LLVM_CAS_MAX_MAPPING_SIZE", LimitStr.c_str(), /*overwrite=*/false);
-  });
-}
-
 INSTANTIATE_TEST_SUITE_P(InMemoryCAS, CASTest,
                          ::testing::Values(createInMemory));
 
 #if LLVM_ENABLE_ONDISK_CAS
+namespace llvm::cas::ondisk {
+void setMaxMappingSize(uint64_t Size);
+} // namespace llvm::cas::ondisk
+
+void setMaxOnDiskCASMappingSize() {
+  static std::once_flag Flag;
+  std::call_once(
+      Flag, [] { llvm::cas::ondisk::setMaxMappingSize(100 * 1024 * 1024); });
+}
+
 TestingAndDir createOnDisk(int I) {
   unittest::TempDir Temp("on-disk-cas", /*Unique=*/true);
   std::unique_ptr<ObjectStore> CAS;
@@ -55,6 +53,8 @@ TestingAndDir createOnDisk(int I) {
                        std::move(Temp)};
 }
 INSTANTIATE_TEST_SUITE_P(OnDiskCAS, CASTest, ::testing::Values(createOnDisk));
+#else
+void setMaxOnDiskCASMappingSize() {}
 #endif /* LLVM_ENABLE_ONDISK_CAS */
 
 #if LLVM_CAS_ENABLE_REMOTE_CACHE

llvm/unittests/CAS/CASTestConfig.h

@@ -33,6 +33,8 @@ struct TestingAndDir {
   std::optional<llvm::unittest::TempDir> Temp;
 };
 
+void setMaxOnDiskCASMappingSize();
+
 class CASTest
     : public testing::TestWithParam<std::function<TestingAndDir(int)>> {
 protected:
@@ -58,7 +60,10 @@ class CASTest
       Envs.emplace_back(std::move(TD.Env));
     return std::move(TD.Cache);
   }
-  void SetUp() { NextCASIndex = 0; }
+  void SetUp() {
+    NextCASIndex = 0;
+    setMaxOnDiskCASMappingSize();
+  }
   void TearDown() {
     NextCASIndex = std::nullopt;
     Dirs.clear();

llvm/unittests/CAS/ObjectStoreTest.cpp

@@ -416,6 +416,7 @@ TEST(OnDiskCASTest, BlobsBigParallelMultiCAS) {
 
 #ifndef _WIN32 // FIXME: resize support on Windows.
 TEST(OnDiskCASTest, DiskSize) {
+  setMaxOnDiskCASMappingSize();
   unittest::TempDir Temp("on-disk-cas", /*Unique=*/true);
   std::unique_ptr<ObjectStore> CAS;
   ASSERT_THAT_ERROR(createOnDiskCAS(Temp.path()).moveInto(CAS), Succeeded());