Method Allocate

be/src/runtime/free-pool.h:59–96

Allocates a buffer of size between [0, 2^62 - 1 - sizeof(FreeListNode)] bytes.

  /// Allocates a buffer of size between [0, 2^62 - 1 - sizeof(FreeListNode)] bytes.
  uint8_t* Allocate(const int64_t requested_size) {
    DCHECK_GE(requested_size, 0);
    /// Return a non-nullptr dummy pointer. nullptr is reserved for failures.
    if (UNLIKELY(requested_size == 0)) return mem_pool_->EmptyAllocPtr();
    ++net_allocations_;
    /// MemPool allocations are 8-byte aligned, so making allocations < 8 bytes
    /// doesn't save memory and eliminates opportunities to recycle allocations.
    int64_t actual_size = std::max<int64_t>(8, requested_size);
    int free_list_idx = BitUtil::Log2Ceiling64(actual_size);
    DCHECK_LT(free_list_idx, NUM_LISTS);
    FreeListNode* allocation = lists_[free_list_idx].next;
    if (allocation == nullptr) {
      // There wasn't an existing allocation of the right size, allocate a new one.
      actual_size = 1LL << free_list_idx;
      allocation = reinterpret_cast<FreeListNode*>(
          mem_pool_->Allocate(actual_size + sizeof(FreeListNode)));
      if (UNLIKELY(allocation == nullptr)) {
        --net_allocations_;
        return nullptr;
      }
      // Memory will be returned unpoisoned from MemPool. Poison the whole range and then
      // deal with unpoisoning both allocation paths in one place below.
      ASAN_POISON_MEMORY_REGION(allocation, sizeof(FreeListNode) + actual_size);
    } else {
      // Remove this allocation from the list.
      lists_[free_list_idx].next = allocation->next;
    }
    DCHECK(allocation != nullptr);
#ifdef ADDRESS_SANITIZER
    uint8_t* ptr = reinterpret_cast<uint8_t*>(allocation);
    ASAN_UNPOISON_MEMORY_REGION(ptr, sizeof(FreeListNode) + requested_size);
    alloc_to_size_[ptr + sizeof(FreeListNode)] = requested_size;
#endif
    // Set the back node to point back to the list it came from so know where
    // to add it on Free().
    allocation->list = &lists_[free_list_idx];
    return reinterpret_cast<uint8_t*>(allocation) + sizeof(FreeListNode);
  }

  void Free(uint8_t* ptr) {
    if (UNLIKELY(ptr == nullptr || ptr == mem_pool_->EmptyAllocPtr())) return;