memory_management.h

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Distributed under BSD 3-Clause license.                                   *
 * Copyright by The HDF Group.                                               *
 * Copyright by the Illinois Institute of Technology.                        *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of Hermes. The full Hermes copyright notice, including  *
 * terms governing use, modification, and redistribution, is contained in    *
 * the COPYING file, which can be found at the top directory. If you do not  *
 * have access to the file, you may request a copy from help@hdfgroup.org.   *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef HERMES_MEMORY_MANAGEMENT_H_
#define HERMES_MEMORY_MANAGEMENT_H_
 
#include <assert.h>
 
#include <atomic>
 
#include "hermes_types.h"
 
namespace hermes {
 
typedef void(ArenaErrorFunc)(); 
struct TicketMutex {
  std::atomic<u32> ticket;  
  std::atomic<u32> serving; 
};
 
struct Ticket {
  u32 ticket;                               
  bool acquired;                            
  Ticket() : ticket(-1), acquired(false) {} 
};
 
struct RwLock {
  TicketMutex mutex;                
  std::atomic<u32> readers;         
  std::atomic<bool> writer_waiting; 
};
 
struct ArenaInfo {
  size_t sizes[kArenaType_Count]; 
  size_t total;                   
};
 
struct Arena {
  u8 *base;
  size_t used;
  size_t capacity;
  ArenaErrorFunc *error_handler;
  i32 temp_count;
};
 
struct Heap {
  ArenaErrorFunc *error_handler;
  TicketMutex mutex;
  u32 base_offset;
  u32 free_list_offset;
  u32 extent;
  u16 alignment;
  bool grows_up;
};
 
struct FreeBlockHeader {
  size_t size; 
};
 
struct FreeBlock {
  u32 next_offset;
  u32 size;
};
 
struct TemporaryMemory {
  Arena *arena; 
  size_t used;  
};
 
struct ScopedTemporaryMemory {
  Arena *arena;
  size_t used;
 
  ScopedTemporaryMemory() = delete;
  ScopedTemporaryMemory(const ScopedTemporaryMemory &) = delete;
  ScopedTemporaryMemory &operator=(const ScopedTemporaryMemory &) = delete;
 
  explicit ScopedTemporaryMemory(Arena *backing_arena)
      : arena(backing_arena), used(backing_arena->used) {
    // TODO(chogan): Currently not threadsafe unless each thread has a different
    // `backing_arena`
    if (++backing_arena->temp_count > 1) {
      HERMES_NOT_IMPLEMENTED_YET;
    }
  }
 
  ~ScopedTemporaryMemory() {
    assert(arena->used >= used);
    arena->used = used;
    assert(arena->temp_count > 0);
    arena->temp_count--;
  }
 
  operator Arena *() { return arena; }
};
 
TemporaryMemory BeginTemporaryMemory(Arena *arena);
 
void EndTemporaryMemory(TemporaryMemory *temp_memory);
 
void InitArena(Arena *arena, size_t bytes, u8 *base);
 
Arena InitArenaAndAllocate(size_t bytes);
 
void DestroyArena(Arena *arena);
 
size_t GetRemainingCapacity(Arena *arena);
 
void GrowArena(Arena *arena, size_t new_size);
 
u8 *PushSize(Arena *arena, size_t size, size_t alignment = 8);
 
u8 *PushSizeAndClear(Arena *arena, size_t size, size_t alignment = 8);
 
template <typename T>
inline T *PushStruct(Arena *arena, size_t alignment = 8) {
  T *result = reinterpret_cast<T *>(PushSize(arena, sizeof(T), alignment));
 
  return result;
}
 
template <typename T>
inline T *PushClearedStruct(Arena *arena, size_t alignment = 8) {
  T *result =
      reinterpret_cast<T *>(PushSizeAndClear(arena, sizeof(T), alignment));
 
  return result;
}
 
template <typename T>
inline T *PushArray(Arena *arena, int count, size_t alignment = 8) {
  T *result =
      reinterpret_cast<T *>(PushSize(arena, sizeof(T) * count, alignment));
 
  return result;
}
 
template <typename T>
inline T *PushClearedArray(Arena *arena, int count, size_t alignment = 8) {
  T *result = reinterpret_cast<T *>(
      PushSizeAndClear(arena, sizeof(T) * count, alignment));
 
  return result;
}
u8 *HeapPushSize(Heap *heap, u32 size); 
template <typename T>
inline T *HeapPushStruct(Heap *heap) {
  T *result = reinterpret_cast<T *>(HeapPushSize(heap, sizeof(T)));
 
  return result;
}
 
template <typename T>
inline T *HeapPushArray(Heap *heap, u32 count) {
  T *result = reinterpret_cast<T *>(HeapPushSize(heap, count * sizeof(T)));
 
  return result;
}
 
Heap *InitHeapInArena(Arena *arena, bool grows_up = true, u16 alignment = 8);
void HeapFree(Heap *heap, void *ptr);
void *HeapRealloc(Heap *heap, void *ptr, size_t size);
u32 GetHeapOffset(Heap *heap, u8 *ptr);
FreeBlock *NextFreeBlock(Heap *heap, FreeBlock *block);
FreeBlock *GetHeapFreeList(Heap *heap);
u8 *HeapOffsetToPtr(Heap *heap, u32 offset);
u8 *HeapExtentToPtr(Heap *heap);
 
void BeginTicketMutex(TicketMutex *mutex);
void EndTicketMutex(TicketMutex *mutex);
 
bool BeginReaderLock(RwLock *lock);
void EndReaderLock(RwLock *lock);
void BeginWriterLock(RwLock *lock);
void EndWriterLock(RwLock *lock);
 
}  // namespace hermes
 
#endif  // HERMES_MEMORY_MANAGEMENT_H_