[lldb] Allow DataFileCache to be constructed with a different policy

[clayborg]

Is this new constructor going to be used elsewhere? It would be great to get more description on why this is desired/needed?

[JDevlieghere]

lldb/source/Core/DataFileCache.cpp

22–49

Would it make sense to extract this into a static function say DefaultCachePruningPolicy and then have one constructor with an optional policy argument? Something like this:

DataFileCache(llvm::StringRef path, llvm::CachePruningPolicy policy = DataFileCache::DefaultCachePruningPolicy);

In addition to having only one constructor, the new function also provides a natural place to document the policy.

50

Is it intentional that we now call this twice?

[augusto2112]

In D131531#3711618, @clayborg wrote:

Is this new constructor going to be used elsewhere? It would be great to get more description on why this is desired/needed?

I'm implementing a cache for swift type metadata for downstream lldb. I thought it made sense to separate its configuration from this index cache one, since we might want to enable either of them independently of the other, set different sizes, expiration dates, etc.

lldb/source/Core/DataFileCache.cpp

22–49

Sounds like a good idea!

50

No! Thanks.

[augusto2112]

Added a static 'GetLLDBIndexCachePolicy' function, removed the constructor without any policies

[JDevlieghere]

lldb/include/lldb/Core/DataFileCache.h

86

It's a little weird that GetLLDBIndexCachePolicy would be private, if only from a documentation point of view so that you can refer to it in the constructor.

87

Comment is incomplete

[augusto2112]

Made GetLLDBIndexCachePolicy public

[JDevlieghere]

LGTM

lldb/source/Core/DataFileCache.cpp

23–50

I was worried that by caching the policy here, changing the lldb-index-cache- settings after the first DataFileCache has been created won't have any effect. But it looks like the DataFileCache is already a static/global used by the Modules, so that's already the case in practice. Maybe a follow-up patch could make that explicit in the help enable-lldb-index-cache help description.

lldb/include/lldb/Core/DataFileCache.h

 //===-- DataFileCache.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_DATAFILECACHE_H
 #define LLDB_CORE_DATAFILECACHE_H
 
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-forward.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Caching.h"
 #include <mutex>
 
 namespace lldb_private {
 
 /// This class enables data to be cached into a directory using the llvm
 /// caching code. Data can be stored and accessed using a unique string key.
 /// The data will be stored in the directory that is specified in the

 ///     printf("cached data:\n%s", mem_buffer_up->getBufferStart());
 ///   } else {
 ///     std::vector<uint8_t> data = { 'h', 'e', 'l', 'l', 'o', '\n' };
 ///     cache.SetCachedData(key, data);
 ///   }
 
 class DataFileCache {
 public:
-  /// Create a data file cache in the directory path that is specified.
+  /// Create a data file cache in the directory path that is specified, using
+  /// the specified policy.
   ///
   /// Data will be cached in files created in this directory when clients call
   /// DataFileCache::SetCacheData.
-  DataFileCache(llvm::StringRef path);
+  DataFileCache(llvm::StringRef path,
+                llvm::CachePruningPolicy policy =
+                    DataFileCache::GetLLDBIndexCachePolicy());
+
+  /// Gets the default LLDB index cache policy, which is controlled by the
+  /// "LLDBIndexCache" family of settings.
+  static llvm::CachePruningPolicy GetLLDBIndexCachePolicy();
 
   /// Get cached data from the cache directory for the specified key.
   ///
   /// Keys must be unique for any given data. This function attempts to see if
   /// the data is available for the specified key and will return a valid memory
   /// buffer is data is available.
   ///
   /// \param key
public:
   ///
   /// \return
   ///   True if the data was successfully cached, false otherwise.
   bool SetCachedData(llvm::StringRef key, llvm::ArrayRef<uint8_t> data);
 
   /// Remove the cache file associated with the key.
   Status RemoveCacheFile(llvm::StringRef key);
 
 private:
   /// Return the cache file that is associated with the key.
   FileSpec GetCacheFilePath(llvm::StringRef key);
 
   llvm::FileCache m_cache_callback;
   FileSpec m_cache_dir;
   std::mutex m_mutex;
   std::unique_ptr<llvm::MemoryBuffer> m_mem_buff_up;
   bool m_take_ownership = false;
 };

lldb/source/Core/DataFileCache.cpp

 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace lldb_private;
 
-DataFileCache::DataFileCache(llvm::StringRef path) {
-  m_cache_dir.SetPath(path);
 
-  // Prune the cache based off of the LLDB settings each time we create a cache
-  // object.
+llvm::CachePruningPolicy DataFileCache::GetLLDBIndexCachePolicy() {
+  static llvm::CachePruningPolicy policy;
+  static llvm::once_flag once_flag;
+
+  llvm::call_once(once_flag, []() {
+    // Prune the cache based off of the LLDB settings each time we create a
+    // cache object.
     ModuleListProperties &properties =
         ModuleList::GetGlobalModuleListProperties();
-  llvm::CachePruningPolicy policy;
     // Only scan once an hour. If we have lots of debug sessions we don't want
     // to scan this directory too often. A timestamp file is written to the
-  // directory to ensure different processes don't scan the directory too often.
-  // This setting doesn't mean that a thread will continually scan the cache
-  // directory within this process.
+    // directory to ensure different processes don't scan the directory too
+    // often. This setting doesn't mean that a thread will continually scan the
+    // cache directory within this process.
     policy.Interval = std::chrono::hours(1);
     // Get the user settings for pruning.
     policy.MaxSizeBytes = properties.GetLLDBIndexCacheMaxByteSize();
     policy.MaxSizePercentageOfAvailableSpace =
         properties.GetLLDBIndexCacheMaxPercent();
     policy.Expiration =
         std::chrono::hours(properties.GetLLDBIndexCacheExpirationDays() * 24);
+  });
+  return policy;
+}
+
+DataFileCache::DataFileCache(llvm::StringRef path, llvm::CachePruningPolicy policy) {
+  m_cache_dir.SetPath(path);
   pruneCache(path, policy);
 
   // This lambda will get called when the data is gotten from the cache and
   // also after the data was set for a given key. We only need to take
   // ownership of the data if we are geting the data, so we use the
   // m_take_ownership member variable to indicate if we need to take
   // ownership.
 
   auto add_buffer = [this](unsigned task, std::unique_ptr<llvm::MemoryBuffer> m) {
bool StringTableReader::Decode(const lldb_private::DataExtractor &data,
   return true;
 }
 
 llvm::StringRef StringTableReader::Get(uint32_t offset) const {
   if (offset >= m_data.size())
     return llvm::StringRef();
   return llvm::StringRef(m_data.data() + offset);
 }
+