[CAS] OnDisk update/cleanup. NFCI.

Cleanup for code upstreaming. Noticeable changes:
* Hide some forward declared typesA.
* Rename all the database files and use a unified version across index
  and dabasefile. This allows reset the version while not introduce
  downstream incompatibility.
* Change unit-test to properly set a smaller file size and just not
  building OnDiskCAS test.

Author: cachemeifyoucan

clang/test/CAS/daemon-cas-recovery.c

@@ -4,7 +4,7 @@
 
 /// Construct a malformed CAS to recovery from.
 // RUN: echo "abc" | llvm-cas --cas %t/cas --make-blob --data -
-// RUN: rm %t/cas/v1.1/v11.data
+// RUN: rm %t/cas/v1.1/data.v1
 // RUN: not llvm-cas --cas %t/cas --validate --check-hash
 
 // RUN: env LLVM_CACHE_CAS_PATH=%t/cas LLVM_CAS_FORCE_VALIDATION=1 %clang-cache \

clang/test/CAS/depscan-cas-log.c

@@ -10,11 +10,11 @@
 // RUN:   -cc1-args -cc1 -triple x86_64-apple-macosx11.0.0 -emit-obj %s -o %t/t.o -fcas-path %t/cas
 // RUN: FileCheck %s --input-file %t/cas/v1.log
 
-// CHECK: [[PID1:[0-9]*]] {{[0-9]*}}: mmap '{{.*}}v{{[0-9]+}}.index'
+// CHECK: [[PID1:[0-9]*]] {{[0-9]*}}: mmap '{{.*}}index.v{{[0-9]+}}'
 // CHECK: [[PID1]] {{[0-9]*}}: create subtrie
 
 // Even a minimal compilation involves at least 9 records for the cache key.
 // CHECK-COUNT-9: [[PID1]] {{[0-9]*}}: create record
 
-// CHECK: [[PID2:[0-9]*]] {{[0-9]*}}: mmap '{{.*}}v{{[0-9]+}}.index'
-// CHECK: [[PID2]] {{[0-9]*}}: close mmap '{{.*}}v{{[0-9]+}}.index'
+// CHECK: [[PID2:[0-9]*]] {{[0-9]*}}: mmap '{{.*}}index.v{{[0-9]+}}'
+// CHECK: [[PID2]] {{[0-9]*}}: close mmap '{{.*}}index.v{{[0-9]+}}'

clang/test/CAS/validate-once.c

@@ -1,7 +1,7 @@
 // RUN: rm -rf %t
 
 // RUN: llvm-cas --cas %t/cas --ingest %s
-// RUN: mv %t/cas/v1.1/v11.data %t/cas/v1.1/v11.data.bak
+// RUN: mv %t/cas/v1.1/data.v1 %t/cas/v1.1/data.v1.bak
 
 // RUN: %clang -cc1depscand -execute %{clang-daemon-dir}/%basename_t -cas-args -fcas-path %t/cas -- \
 // RUN:   %clang -target x86_64-apple-macos11 -I %S/Inputs \

llvm/include/llvm/CAS/OnDiskDataAllocator.h

@@ -31,8 +31,7 @@ class OnDiskDataAllocator {
 public:
   using ValueProxy = MutableArrayRef<char>;
 
-  /// An iterator-like return value for data insertion. Maybe it should be
-  /// called \c iterator, but it has no increment.
+  /// A pointer to data stored on disk.
   class OnDiskPtr {
   public:
     FileOffset getOffset() const { return Offset; }
@@ -56,15 +55,17 @@ class OnDiskDataAllocator {
     ValueProxy Value;
   };
 
-  /// Look up the data stored at the given offset.
+  /// Get the data of \p Size stored at the given \p Offset. Note the allocator
+  /// doesn't keep track of the allocation size, thus \p Size doesn't need to
+  /// match the size of allocation but needs to be smaller.
   Expected<ArrayRef<char>> get(FileOffset Offset, size_t Size) const;
 
   /// Allocate at least \p Size with 8-byte alignment.
   Expected<OnDiskPtr> allocate(size_t Size);
 
   /// \returns the buffer that was allocated at \p create time, with size
   /// \p UserHeaderSize.
-  MutableArrayRef<uint8_t> getUserHeader();
+  MutableArrayRef<uint8_t> getUserHeader() const;
 
   size_t size() const;
   size_t capacity() const;

llvm/include/llvm/CAS/OnDiskGraphDB.h

@@ -1,10 +1,17 @@
-//===- OnDiskGraphDB.h ------------------------------------------*- C++ -*-===//
+//===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+/// \file
+/// This declares OnDiskGraphDB, an ondisk CAS database with a fixed length
+/// hash. This is the class that implements the database storage scheme without
+/// exposing the hashing algorithm.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CAS_ONDISKGRAPHDB_H
 #define LLVM_CAS_ONDISKGRAPHDB_H
@@ -16,16 +23,13 @@
 
 namespace llvm::cas::ondisk {
 
-/// 8B reference.
+/// Standard 8 byte reference inside OnDiskGraphDB.
 class InternalRef {
 public:
-  FileOffset getFileOffset() const { return FileOffset(getRawOffset()); }
-
+  FileOffset getFileOffset() const { return FileOffset(Data); }
   uint64_t getRawData() const { return Data; }
-  uint64_t getRawOffset() const { return Data; }
 
   static InternalRef getFromRawData(uint64_t Data) { return InternalRef(Data); }
-
   static InternalRef getFromOffset(FileOffset Offset) {
     return InternalRef(Offset.get());
   }
@@ -40,19 +44,17 @@ class InternalRef {
   uint64_t Data;
 };
 
-/// 4B reference.
+/// Compact 4 byte reference inside OnDiskGraphDB for smaller references.
 class InternalRef4B {
 public:
   FileOffset getFileOffset() const { return FileOffset(Data); }
-
   uint32_t getRawData() const { return Data; }
 
   /// Shrink to 4B reference.
   static std::optional<InternalRef4B> tryToShrink(InternalRef Ref) {
-    uint64_t Offset = Ref.getRawOffset();
+    uint64_t Offset = Ref.getRawData();
     if (Offset > UINT32_MAX)
       return std::nullopt;
-
     return InternalRef4B(Offset);
   }
 
@@ -148,10 +150,9 @@ class InternalRefArrayRef {
     if (is4B()) {
       auto *B = cast<const InternalRef4B *>(Begin);
       return ArrayRef((const uint8_t *)B, sizeof(InternalRef4B) * Size);
-    } else {
-      auto *B = cast<const InternalRef *>(Begin);
-      return ArrayRef((const uint8_t *)B, sizeof(InternalRef) * Size);
     }
+    auto *B = cast<const InternalRef *>(Begin);
+    return ArrayRef((const uint8_t *)B, sizeof(InternalRef) * Size);
   }
 
   InternalRefArrayRef(std::nullopt_t = std::nullopt) {
@@ -172,8 +173,6 @@ class InternalRefArrayRef {
   size_t Size = 0;
 };
 
-struct OnDiskContent;
-
 /// Reference to a node. The node's data may not be stored in the database.
 /// An \p ObjectID instance can only be used with the \p OnDiskGraphDB instance
 /// it came from. \p ObjectIDs from different \p OnDiskGraphDB instances are not
@@ -199,11 +198,11 @@ class ObjectID {
 /// Handle for a loaded node object.
 class ObjectHandle {
 public:
+  explicit ObjectHandle(uint64_t Opaque) : Opaque(Opaque) {}
   uint64_t getOpaqueData() const { return Opaque; }
 
-  static ObjectHandle fromOpaqueData(uint64_t Opaque) {
-    return ObjectHandle(Opaque);
-  }
+  static ObjectHandle fromFileOffset(FileOffset Offset);
+  static ObjectHandle fromMemory(uintptr_t Ptr);
 
   friend bool operator==(const ObjectHandle &LHS, const ObjectHandle &RHS) {
     return LHS.Opaque == RHS.Opaque;
@@ -213,10 +212,10 @@ class ObjectHandle {
   }
 
 private:
-  explicit ObjectHandle(uint64_t Opaque) : Opaque(Opaque) {}
   uint64_t Opaque;
 };
 
+/// Iterator for ObjectID.
 class object_refs_iterator
     : public iterator_facade_base<object_refs_iterator,
                                   std::random_access_iterator_tag, ObjectID> {
@@ -294,6 +293,7 @@ class OnDiskGraphDB {
   /// \returns the data part of the provided object handle.
   ArrayRef<char> getObjectData(ObjectHandle Node) const;
 
+  /// \returns the object referenced by the provided object handle.
   object_refs_range getObjectRefs(ObjectHandle Node) const {
     InternalRefArrayRef Refs = getInternalRefs(Node);
     return make_range(Refs.begin(), Refs.end());
@@ -315,6 +315,13 @@ class OnDiskGraphDB {
   /// Hashing function type for validation.
   using HashingFuncT = function_ref<void(
       ArrayRef<ArrayRef<uint8_t>>, ArrayRef<char>, SmallVectorImpl<uint8_t> &)>;
+
+  /// Validate the OnDiskGraphDB.
+  ///
+  /// \param Deep if true, rehash all the objects to ensure no data
+  /// corruption in stored objects, otherwise just validate the structure of
+  /// CAS database.
+  /// \param Hasher is the hashing function used for objects inside CAS.
   Error validate(bool Deep, HashingFuncT Hasher) const;
 
   /// How to fault-in nodes if an upstream database is used.
@@ -347,19 +354,20 @@ class OnDiskGraphDB {
   ~OnDiskGraphDB();
 
 private:
+  /// Forward declaration for a proxy for an ondisk index record.
   struct IndexProxy;
-  class TempFile;
-  class MappedTempFile;
 
   enum class ObjectPresence {
     Missing,
     InPrimaryDB,
     OnlyInUpstreamDB,
   };
 
+  /// Check if object exists and if it is on upstream only.
   Expected<ObjectPresence> getObjectPresence(ObjectID Ref,
                                              bool CheckUpstream) const;
 
+  /// \returns true if object can be found in database.
   bool containsObject(ObjectID Ref, bool CheckUpstream) const {
     auto Presence = getObjectPresence(Ref, CheckUpstream);
     if (!Presence) {
@@ -379,46 +387,57 @@ class OnDiskGraphDB {
   /// When \p load is called for a node that doesn't exist, this function tries
   /// to load it from the upstream store and copy it to the primary one.
   Expected<std::optional<ObjectHandle>> faultInFromUpstream(ObjectID PrimaryID);
+
+  /// Import the entire tree from upstream with \p UpstreamNode as root.
   Error importFullTree(ObjectID PrimaryID, ObjectHandle UpstreamNode);
+  /// Import only the \param UpstreamNode.
   Error importSingleNode(ObjectID PrimaryID, ObjectHandle UpstreamNode);
 
+  /// Found the IndexProxy for the hash.
   Expected<IndexProxy> indexHash(ArrayRef<uint8_t> Hash);
 
+  /// Get path for creating standalone data file.
+  void getStandalonePath(StringRef FileSuffix, const IndexProxy &I,
+                         SmallVectorImpl<char> &Path) const;
+  /// Create a standalone leaf file.
   Error createStandaloneLeaf(IndexProxy &I, ArrayRef<char> Data);
 
-  Expected<MappedTempFile> createTempFile(StringRef FinalPath, uint64_t Size);
-
-  OnDiskContent getContentFromHandle(ObjectHandle H) const;
-
+  /// \name Helper functions for internal data structures.
+  /// \{
   static InternalRef getInternalRef(ObjectID Ref) {
     return InternalRef::getFromRawData(Ref.getOpaqueData());
   }
+
   static ObjectID getExternalReference(InternalRef Ref) {
     return ObjectID::fromOpaqueData(Ref.getRawData());
   }
 
   static ObjectID getExternalReference(const IndexProxy &I);
 
-  void getStandalonePath(StringRef FileSuffix, const IndexProxy &I,
-                         SmallVectorImpl<char> &Path) const;
+  static InternalRef makeInternalRef(FileOffset IndexOffset);
 
   Expected<ArrayRef<uint8_t>> getDigest(InternalRef Ref) const;
+
   ArrayRef<uint8_t> getDigest(const IndexProxy &I) const;
 
   Expected<IndexProxy> getIndexProxyFromRef(InternalRef Ref) const;
 
-  static InternalRef makeInternalRef(FileOffset IndexOffset);
-
   IndexProxy
   getIndexProxyFromPointer(OnDiskTrieRawHashMap::ConstOnDiskPtr P) const;
 
   InternalRefArrayRef getInternalRefs(ObjectHandle Node) const;
+  /// \}
 
-  void recordStandaloneSizeIncrease(size_t SizeIncrease);
+  /// Get the atomic variable that keeps track of the standalone data storage
+  /// size.
+  std::atomic<uint64_t> &standaloneStorageSize() const;
 
-  std::atomic<uint64_t> &getStandaloneStorageSize();
+  /// Increase the standalone data size.
+  void recordStandaloneSizeIncrease(size_t SizeIncrease);
+  /// Get the standalone data size.
   uint64_t getStandaloneStorageSize() const;
 
+  // Private constructor.
   OnDiskGraphDB(StringRef RootPath, OnDiskTrieRawHashMap Index,
                 OnDiskDataAllocator DataPool,
                 std::unique_ptr<OnDiskGraphDB> UpstreamDB, FaultInPolicy Policy,
@@ -434,14 +453,19 @@ class OnDiskGraphDB {
   /// Data type is DataRecordHandle.
   OnDiskDataAllocator DataPool;
 
-  void *StandaloneData; // a StandaloneDataMap.
+  /// A StandaloneDataMap.
+  void *StandaloneData = nullptr;
 
+  /// Path to the root directory.
   std::string RootPath;
 
   /// Optional on-disk store to be used for faulting-in nodes.
   std::unique_ptr<OnDiskGraphDB> UpstreamDB;
+
+  /// The policy used to fault in data from upstream.
   FaultInPolicy FIPolicy;
 
+  /// Debug Logger.
   std::shared_ptr<OnDiskCASLogger> Logger;
 };
 

llvm/include/llvm/CAS/OnDiskKeyValueDB.h

@@ -1,10 +1,16 @@
-//===- OnDiskKeyValueDB.h ---------------------------------------*- C++ -*-===//
+//===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+//
+/// \file
+/// This declares OnDiskKeyValueDB, a key value storage database of fixed size
+/// key and value.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CAS_ONDISKKEYVALUEDB_H
 #define LLVM_CAS_ONDISKKEYVALUEDB_H
@@ -35,9 +41,7 @@ class OnDiskKeyValueDB {
   Expected<std::optional<ArrayRef<char>>> get(ArrayRef<uint8_t> Key);
 
   /// \returns Total size of stored data.
-  size_t getStorageSize() const {
-    return Cache.size();
-  }
+  size_t getStorageSize() const { return Cache.size(); }
 
   /// \returns The precentage of space utilization of hard space limits.
   ///
@@ -60,7 +64,10 @@ class OnDiskKeyValueDB {
        StringRef ValueName, size_t ValueSize,
        std::shared_ptr<OnDiskCASLogger> Logger = nullptr);
 
-  using CheckValueT = function_ref<Error(FileOffset Offset, ArrayRef<char>)>;
+  using CheckValueT =
+      function_ref<Error(FileOffset Offset, ArrayRef<char> Data)>;
+  /// Validate the storage with a callback \p CheckValue to check the stored
+  /// value.
   Error validate(CheckValueT CheckValue) const;
 
 private:

llvm/include/llvm/Config/llvm-config.h.cmake

@@ -146,4 +146,7 @@
    coverage bugs, and to 0 otherwise. */
 #cmakedefine01 LLVM_ENABLE_DEBUGLOC_TRACKING_ORIGIN
 
+/* Define to 1 to enable LLVM OnDisk Content Addressable Storage */
+#cmakedefine01 LLVM_ENABLE_ONDISK_CAS
+
 #endif

llvm/lib/CAS/CMakeLists.txt

@@ -1,7 +1,3 @@
-if (LLVM_ENABLE_ONDISK_CAS)
-  add_definitions(-DLLVM_ENABLE_ONDISK_CAS=1)
-endif()
-
 add_llvm_component_library(LLVMCAS
   ActionCache.cpp
   ActionCaches.cpp

llvm/lib/CAS/OnDiskCAS.cpp

@@ -52,7 +52,7 @@ class OnDiskCAS : public BuiltinCAS {
   }
 
   ondisk::ObjectHandle convertHandle(ObjectHandle Node) const {
-    return ondisk::ObjectHandle::fromOpaqueData(Node.getInternalRef(*this));
+    return ondisk::ObjectHandle(Node.getInternalRef(*this));
   }
 
   ObjectRef convertRef(ondisk::ObjectID Ref) const {