Class RAMCacheComponent

cachelib/interface/components/RAMCacheComponent.h:45–155

* A CacheComponent that uses Cachelib's LruAllocator RAM cache without the * flash/NVM cache. * * Although all APIs use coroutines (according to the CacheComponent interface), * they are synchronous under the hood. */

 * they are synchronous under the hood.
 */
class RAMCacheComponent : public CacheComponentWithStats {
 public:
  using LatencySamplingConfig =
      CacheComponentStatsCollector::LatencySamplingConfig;

  /**
   * Configuration for cache persistence. If provided, the cache will use shared
   * memory so that state can be persisted across shutdown/recovery cycles.
   */
  class PersistenceConfig : public utils::PersistenceConfigBase {
   public:
    static PersistenceConfig noPersistenceOrRecovery();
    static PersistenceConfig persistenceAndRecovery(std::string cacheDir,
                                                    void* baseAddr = nullptr);
    static PersistenceConfig persistenceButNoRecovery(std::string cacheDir,
                                                      void* baseAddr = nullptr);

    // Note: make return val non-const so we can move cacheDir out
    FOLLY_ALWAYS_INLINE std::string& cacheDir() const noexcept {
      return cacheDir_;
    }
    FOLLY_ALWAYS_INLINE void* baseAddr() const noexcept { return baseAddr_; }

   private:
    mutable std::string cacheDir_;
    void* baseAddr_;

    PersistenceConfig(bool persist,
                      bool recover,
                      std::string&& cacheDir,
                      void* baseAddr)
        : PersistenceConfigBase(persist, recover),
          cacheDir_(std::move(cacheDir)),
          baseAddr_(baseAddr) {}
  };

  /**
   * Pool configuration. RAMCacheComponent includes only 1 pool - to add more
   * pools, create more RAMCacheComponents.
   */
  struct PoolConfig {
    folly::StringPiece name_{"default"};
    size_t size_;
    const std::set<uint32_t> allocSizes_;
    MMLru::Config mmConfig_;
    std::shared_ptr<RebalanceStrategy> rebalanceStrategy_{nullptr};
    std::shared_ptr<RebalanceStrategy> resizeStrategy_{nullptr};
    bool ensureProvisionable_{false};
  };

  /**
   * Factory method to create a new RAMCacheComponent. Validates the config
   * before actually creating the cache. Also creates a default pool used for
   * all caching in this component.
   *
   * Note: NVM caching or pool rebalancing *must not* be enabled in the config.
   * Returns an error if either are enabled in the config.
   *