Method Reallocate

be/src/runtime/free-pool.h:125–170

Returns an allocation that is at least 'size'. If the current allocation backing 'ptr' is big enough, 'ptr' is returned. Otherwise a new one is made and the contents of ptr are copied into it. nullptr will be returned on allocation failure. It's the caller's responsibility to free the memory buffer pointed to by "ptr" in this case.

  /// nullptr will be returned on allocation failure. It's the caller's responsibility to
  /// free the memory buffer pointed to by "ptr" in this case.
  uint8_t* Reallocate(uint8_t* ptr, int64_t size) {
    if (UNLIKELY(ptr == nullptr || ptr == mem_pool_->EmptyAllocPtr())) return Allocate(size);
    FreeListNode* node = reinterpret_cast<FreeListNode*>(ptr - sizeof(FreeListNode));
    FreeListNode* list = node->list;
#ifndef NDEBUG
    CheckValidAllocation(list, ptr);
#endif
    int bucket_idx = (list - &lists_[0]);
    DCHECK_LT(bucket_idx, NUM_LISTS);
    // This is the actual size of ptr.
    int64_t allocation_size = 1LL << bucket_idx;

    // If it's already big enough, just return the ptr.
    if (allocation_size >= size) {
      // Ensure that only first size bytes are unpoisoned. Need to poison whole region
      // first in case size is smaller than original allocation's size.
#ifdef ADDRESS_SANITIZER
      DCHECK(alloc_to_size_.find(ptr) != alloc_to_size_.end());
      int64_t prev_allocation_size = alloc_to_size_[ptr];
      if (prev_allocation_size > size) {
        // Allocation is shrinking: poison the 'freed' bytes.
        ASAN_POISON_MEMORY_REGION(ptr + size, prev_allocation_size - size);
      } else {
        // Allocation is growing: unpoison the newly allocated bytes.
        ASAN_UNPOISON_MEMORY_REGION(
            ptr + prev_allocation_size, size - prev_allocation_size);
      }
      alloc_to_size_[ptr] = size;
#endif
      return ptr;
    }

    // Make a new one. Since Allocate() already rounds up to powers of 2, this effectively
    // doubles for the caller.
    uint8_t* new_ptr = Allocate(size);
    if (LIKELY(new_ptr != nullptr)) {
#ifdef ADDRESS_SANITIZER
      DCHECK(alloc_to_size_.find(ptr) != alloc_to_size_.end());
      // Unpoison the region so that we can copy the old allocation to the new one.
      ASAN_UNPOISON_MEMORY_REGION(ptr, allocation_size);
#endif
      memcpy(new_ptr, ptr, allocation_size);
      Free(ptr);
    }
    return new_ptr;
  }

  MemTracker* mem_tracker() { return mem_pool_->mem_tracker(); }
  int64_t net_allocations() const { return net_allocations_; }