BLI_allocator.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include <algorithm>
#include <cstdlib>
 
#include "MEM_guardedalloc.h"
 
#include "BLI_utildefines.h"
 
namespace blender {
 
class GuardedAllocator {
 public:
  void *allocate(size_t size, size_t alignment, const char *name)
  {
    /* Should we use MEM_mallocN, when alignment is small? If yes, how small must alignment be? */
    return MEM_mallocN_aligned(size, alignment, name);
  }
 
  void deallocate(void *ptr)
  {
    MEM_freeN(ptr);
  }
};
 
template<size_t Alignment = 64ul> class GuardedAlignedAllocator {
 public:
  static constexpr size_t min_alignment = Alignment;
 
  void *allocate(size_t size, size_t alignment, const char *name)
  {
    return MEM_mallocN_aligned(size, std::max(alignment, min_alignment), name);
  }
 
  void deallocate(void *ptr)
  {
    MEM_freeN(ptr);
  }
};
 
class RawAllocator {
 private:
  struct MemHead {
    int offset;
  };
 
 public:
  void *allocate(size_t size, size_t alignment, const char * /*name*/)
  {
    BLI_assert(is_power_of_2(int(alignment)));
    void *ptr = malloc(size + alignment + sizeof(MemHead));
    void *used_ptr = reinterpret_cast<void *>(
        uintptr_t(POINTER_OFFSET(ptr, alignment + sizeof(MemHead))) & ~(uintptr_t(alignment) - 1));
    int offset = int(intptr_t(used_ptr) - intptr_t(ptr));
    BLI_assert(offset >= int(sizeof(MemHead)));
    (static_cast<MemHead *>(used_ptr) - 1)->offset = offset;
    return used_ptr;
  }
 
  void deallocate(void *ptr)
  {
    MemHead *head = static_cast<MemHead *>(ptr) - 1;
    int offset = -head->offset;
    void *actual_pointer = POINTER_OFFSET(ptr, offset);
    free(actual_pointer);
  }
};
 
}  // namespace blender