Method create

cachelib/interface/components/RAMCacheComponent.cpp:190–228

static */

}

/* static */ Result<RAMCacheComponent> RAMCacheComponent::create(
    LruAllocatorConfig&& allocConfig,
    PoolConfig&& poolConfig,
    PersistenceConfig persistenceConfig,
    const LatencySamplingConfig& latencySamplingConfig) noexcept {
  if (allocConfig.nvmConfig) {
    return makeError(Error::Code::INVALID_CONFIG,
                     "RAMCacheComponent does not support NVM cache");
  } else if (allocConfig.poolRebalancingEnabled()) {
    return makeError(Error::Code::INVALID_CONFIG,
                     "RAMCacheComponent does not support pool rebalancing");
  } else if (persistenceConfig.persist() || persistenceConfig.recover()) {
    if (persistenceConfig.cacheDir().empty()) {
      return makeError(Error::Code::INVALID_CONFIG,
                       "cacheDir must be set for persistence/recovery");
    }
    allocConfig.enableCachePersistence(std::move(persistenceConfig.cacheDir()),
                                       persistenceConfig.baseAddr());
  }
  try {
    auto cache = RAMCacheComponent(std::move(allocConfig), persistenceConfig,
                                   latencySamplingConfig);
    auto ids = cache.cache_->getPoolIds();
    if (!ids.empty()) {
      // Pool was restored from shared memory, just look up its ID
      XCHECK_EQ(ids.size(), 1UL);
      cache.defaultPool_ = *ids.begin();
    } else {
      // Add a default pool that will be used for all allocations
      cache.defaultPool_ = cache.cache_->addPool(
          poolConfig.name_, poolConfig.size_, poolConfig.allocSizes_,
          poolConfig.mmConfig_, poolConfig.rebalanceStrategy_,
          poolConfig.resizeStrategy_, poolConfig.ensureProvisionable_);
    }
    return cache;
  } catch (const std::exception& e) {
    return makeError(Error::Code::INVALID_CONFIG, e.what());
  }
}

LruAllocator& RAMCacheComponent::get() const noexcept { return *cache_; }