Method addRootPool

bolt/common/memory/Memory.cpp:346–388

}

std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
    const std::string& name,
    int64_t maxCapacity,
    std::unique_ptr<MemoryReclaimer> reclaimer,
    const std::optional<MemoryPool::DebugOptions>& poolDebugOpts) {
  std::string poolName = name;
  if (poolName.empty()) {
    static std::atomic<int64_t> poolId{0};
    poolName = fmt::format("default_root_{}", poolId++);
  }

  MemoryPool::Options options;
  options.alignment = alignment_;
  options.maxCapacity = maxCapacity;
  options.trackUsage = true;
  options.coreOnAllocationFailureEnabled = coreOnAllocationFailureEnabled_;
  options.getPreferredSize = getPreferredSize_;
  options.debugOptions = poolDebugOpts;

  options.poolRegex = poolRegex_;
  options.singleAllocationThreshold = singleAllocationThreshold_;
  options.accumulativeAllocationThreshold = accumulativeAllocationThreshold_;
  options.enableDynamicMemoryQuotaManager = enableDynamicMemoryQuotaManager_;

  auto pool = createRootPool(poolName, reclaimer, options);
  if (!disableMemoryPoolTracking_) {
    try {
      std::unique_lock guard{mutex_};
      if (pools_.find(poolName) != pools_.end()) {
        BOLT_FAIL("Duplicate root pool name found: {}", poolName);
      }
      pools_.emplace(poolName, pool);
    } catch (const BoltRuntimeError&) {
      arbitrator_->removePool(pool.get());
      throw;
    }
  }
  // NOTE: we need to set destruction callback at the end to avoid potential
  // deadlock or failure because of duplicate memory pool name or unexpected
  // failure to add memory pool to the arbitrator.
  pool->setDestructionCallback(poolDestructionCb_);
  return pool;
}

std::shared_ptr<MemoryPool> MemoryManager::addLeafPool(
    const std::string& name,