interface.h File Reference

Notes: More...

#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include "serene/utils.h"

Include dependency graph for interface.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	srn_memory_provider_t
	This interface is here to abstract over the allocator. More...
struct	srn_block_t
struct	srn_mm_t
	Main memory manager structure that will own all the allocated blocks and data. More...

Macros
#define	FALLBACK_PAGE_SIZE   4096U
#define	MAX_NUMBER_OF_BLOCKS   256U
	TODO(lxsameer): Since we want to move fast, at this stage a static array of blocks is enough for us, we can tweak the size as we see fit.
#define	DEFAULT_BLOCK_ALIGNMENT   16U
	We strictly use 16 bytes alignment for blocks.
#define	DESIRED_BLOCK_SIZE   131072
	This is the value that we want for our blocks but we want it to be a multiple of the page size on the platform as well.
#define	SRN_BLOCK_NO_ID   SIZE_MAX
#define	srn_mm_allocate_in_block(mm, id, T)
#define	srn_mm_immortal_allocate(mm, T)

Typedefs
typedef struct srn_memory_provider_t	srn_memory_provider_t
	This interface is here to abstract over the allocator.
typedef struct srn_block_t	srn_block_t
typedef struct srn_mm_t	srn_mm_t
	Main memory manager structure that will own all the allocated blocks and data.

Functions
size_t	srn_mm_get_os_page_size (void)
	Retutrns the OS page size.
size_t	srn_mm_get_block_size (void)
	Calculates and return the block size based on our desired size and the OS page size.
srn_block_id_t	srn_mm_allocate_block (srn_mm_t *mm)
	Allocate a new block in the memory manager and return its ID.
void	srn_mm_release_block (srn_mm_t *mm, srn_block_id_t id)
	Release the given block id and free the memory for later allocations.
srn_block_t *	srn_mm_get_block (srn_mm_t *mm, srn_block_id_t block_id)
	Return the block object associated by the given block_id
void *	srn_mm_allocate_in_block_aligned (srn_mm_t *mm, srn_block_id_t block_id, size_t size, size_t alignment)
	Allocate memory on a block with the given block_id.
void *	srn_mm_immortal_allocate_aligned (srn_mm_t *mm, size_t size, size_t alignment)
	Allocate memory on the importal block which will never gets freed.
srn_mm_t *	srn_mm_init (void)
	Initialize the memory manager, this function will panic on error.
void	srn_mm_shutdown (srn_mm_t *mm)
	Shut down the memory manager and release the resources.
void	srn_unlock_memory_manager (srn_mm_t *mm)
	Unocks the memory manager.
void	srn_lock_memory_manager (srn_mm_t *mm)
	Locks the memory manager.
void *	srn_mm_allocate (srn_mm_t *mm, size_t size)
	Generic allocations that do not participate in the block based pools.
void *	srn_mm_reallocate (srn_mm_t *mm, void *ptr, size_t new_size)
void	srn_mm_free (srn_mm_t *mm, void *ptr)
	Release a pointer previously returned by srn_mm_allocate or srn_mm_reallocate.

Detailed Description

Notes:

• Never give out any pointer to intermediate blocks in a block chain to user.
• Always lock the memory manager when operating only on srn_mm_t.
• Always lock the block when operating on it
• Never lock the memory manager to operate on a block in it.
• To the user a chain of blocks are just one block, so deallocation happens on the chain level not per block
• It's users responsibility to copy the data between different chains.

Definition in file interface.h.

Macro Definition Documentation

DEFAULT_BLOCK_ALIGNMENT

#define DEFAULT_BLOCK_ALIGNMENT   16U

We strictly use 16 bytes alignment for blocks.

Definition at line 47 of file interface.h.

DESIRED_BLOCK_SIZE

#define DESIRED_BLOCK_SIZE   131072

This is the value that we want for our blocks but we want it to be a multiple of the page size on the platform as well.

So there is no guarantee that we get exactly this number. 128Kib

Definition at line 53 of file interface.h.

FALLBACK_PAGE_SIZE

#define FALLBACK_PAGE_SIZE   4096U

Definition at line 36 of file interface.h.

MAX_NUMBER_OF_BLOCKS

#define MAX_NUMBER_OF_BLOCKS   256U

TODO(lxsameer): Since we want to move fast, at this stage a static array of blocks is enough for us, we can tweak the size as we see fit.

But we need to change this for the final stage. We should be able to dynamically expand the array of blocks. Notes: Due to my laziness, if you ever change this value, you need to change the popcount functions for the block bitmap as well.

Definition at line 44 of file interface.h.

SRN_BLOCK_NO_ID

#define SRN_BLOCK_NO_ID   SIZE_MAX

Definition at line 63 of file interface.h.

srn_mm_allocate_in_block

#define srn_mm_allocate_in_block	(		mm,
			id,
			T )

Value:

  (T *)srn_mm_allocate_in_block_aligned(mm, id, sizeof(T), alignof(T))

Definition at line 166 of file interface.h.

#define srn_mm_allocate_in_block(mm, id, T) \
  (T *)srn_mm_allocate_in_block_aligned(mm, id, sizeof(T), alignof(T))

srn_mm_immortal_allocate

#define srn_mm_immortal_allocate	(		mm,
			T )

Value:

  (T *)srn_mm_immortal_allocate_aligned(mm, sizeof(T), alignof(T))

Definition at line 169 of file interface.h.

#define srn_mm_immortal_allocate(mm, T) \
  (T *)srn_mm_immortal_allocate_aligned(mm, sizeof(T), alignof(T))

Typedef Documentation

srn_block_t

typedef struct srn_block_t srn_block_t

srn_memory_provider_t

typedef struct srn_memory_provider_t srn_memory_provider_t

This interface is here to abstract over the allocator.

For instance, malloc/free can be a page provider. This will let us switch to other implementation later on. Eventually we might end up coming up with our own version of malloc/free.

srn_mm_t

typedef struct srn_mm_t srn_mm_t

Main memory manager structure that will own all the allocated blocks and data.

In every instance of the compiler there should be only one instance of this. It should be created via srn_mm_init and destroyed via srn_shutdown_memory_manager.

Function Documentation

srn_lock_memory_manager()

void srn_lock_memory_manager

(

srn_mm_t *

mm

)

Locks the memory manager.

We have to lock the memory manager when allocating blocks. TODO(lxsameer): Do we need to support thread local blocks?

Definition at line 362 of file default.c.

{ srn_spinlock_lock(&mm->lock); }

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_allocate()

void * srn_mm_allocate ( srn_mm_t * mm, size_t size )

nodiscard

Generic allocations that do not participate in the block based pools.

Equivalent to malloc/realloc/free. Routed through the memory manager so the backend can later be swapped without touching callers. mm is reserved for future per manager routing and is currently unused inside the implementation.

Definition at line 141 of file default.c.

                                                 {
  UNUSED(mm);
  return malloc(size);
}

Here is the caller graph for this function:

srn_mm_allocate_block()

srn_block_id_t srn_mm_allocate_block ( srn_mm_t * mm )

nodiscard

Allocate a new block in the memory manager and return its ID.

The client code can use the ID to allocate memory on the block and when it's done, just use the same ID to release the block

Definition at line 364 of file default.c.

                                                   {
  PANIC_IF(mm->block_count >= MAX_NUMBER_OF_BLOCKS - 1, "Out of memory");
 
  srn_lock_memory_manager(mm);
  srn_block_t *block = alloc_block_internal(mm);
  int index = find_a_free_block_id(mm);
  PANIC_IF(index == -1, "Couldn't allocate a block id. This is a bug!");
 
  init_block(mm, block);
  mm->block_count++;
  PANIC_IF(!is_block_id_free(mm, (uint16_t)index),
           "Miscalculated the block id. It is not free. This is a bug!");
  allocated_block_id(mm, (uint16_t)index);
  mm->blocks[(srn_block_id_t)index] = block;
 
  srn_unlock_memory_manager(mm);
 
#if SERENE_DEBUG
  mm->stats.total_blocks++;
  mm->stats.total_os_allocations++;
#endif
  return (srn_block_id_t)index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_allocate_in_block_aligned()

void * srn_mm_allocate_in_block_aligned ( srn_mm_t * mm, srn_block_id_t block_id, size_t size, size_t alignment )

nodiscard

Allocate memory on a block with the given block_id.

Definition at line 347 of file default.c.

                                                         {
  MM_LOG("Allocating %ld bytes with 16 bytes alignment in block: %zu", size, block_id);
  srn_block_t *block = get_block(mm, block_id);
  PANIC_IF_NULL(block);
 
  return alloc_in_block(mm, block, size, alignment);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_free()

void srn_mm_free	(	srn_mm_t *	mm,
		void *	ptr )

Release a pointer previously returned by srn_mm_allocate or srn_mm_reallocate.

ptr may be nullptr, in which case the call is a no-op.

Definition at line 151 of file default.c.

                                          {
  UNUSED(mm);
  free(ptr);
}

Here is the caller graph for this function:

srn_mm_get_block()

srn_block_t * srn_mm_get_block	(	srn_mm_t *	mm,
		srn_block_id_t	block_id )

Return the block object associated by the given block_id

Definition at line 290 of file default.c.

                                                                     {
  return get_block(mm, block_id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_get_block_size()

size_t srn_mm_get_block_size

(

void

)

Calculates and return the block size based on our desired size and the OS page size.

Basically the ruturn value will be a number multiple of the OS page size and close or equal to our desired size

Definition at line 285 of file default.c.

                                   {
  const size_t ps = srn_mm_get_os_page_size();
  return closest_multiple(DESIRED_BLOCK_SIZE, ps);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_get_os_page_size()

size_t srn_mm_get_os_page_size

(

void

)

Retutrns the OS page size.

Definition at line 270 of file default.c.

                                     {
#if defined(_WIN32)
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return (size_t)si.dwPageSize;
#elif defined(__unix__) || defined(__APPLE__)
  long sz = sysconf(_SC_PAGESIZE);
  return (sz > 0) ? (size_t)sz : FALLBACK_PAGE_SIZE;
#elif defined(__wasm__)
  return WASM_PAGE_SIZE;
#else
  return FALLBACK_PAGE_SIZE;
#endif
}

Here is the caller graph for this function:

srn_mm_immortal_allocate_aligned()

void * srn_mm_immortal_allocate_aligned ( srn_mm_t * mm, size_t size, size_t alignment )

nodiscard

Allocate memory on the importal block which will never gets freed.

Definition at line 356 of file default.c.

                                                                                    {
  return alloc_in_block(mm, mm->immortal_block, size, alignment);
}

Here is the call graph for this function:

srn_mm_init()

srn_mm_t * srn_mm_init

(

void

)

Initialize the memory manager, this function will panic on error.

Definition at line 294 of file default.c.

                        {
  srn_mm_t *mm = malloc(sizeof(srn_mm_t));
  PANIC_IF_NULL(mm);
 
  mm->provider = &stdlib_provider;
  memset(mm->block_bitmap, 0, sizeof(mm->block_bitmap));
 
  mm->block_count = 0;
  mm->block_size = srn_mm_get_block_size();
  memset((void *)mm->blocks, 0, sizeof(mm->blocks));
 
  PANIC_IF(mm->block_size <= sizeof(srn_block_t),
           "Wrong block size. Modify DESIRED_BLOCK_SIZE to a larger number");
 
  srn_spinlock_init(&mm->lock);
 
  srn_block_t *immortal =
      (srn_block_t *)mm->provider->allocate(mm->block_size, DEFAULT_BLOCK_ALIGNMENT);
  PANIC_IF_NULL(immortal);
  init_block(mm, immortal);
  mm->immortal_block = immortal;
 
#if SERENE_DEBUG
  mm->stats.allocated_pages = 0;
  mm->stats.total_allocations = 0;
  mm->stats.total_os_allocations = 0;
  mm->stats.total_blocks = 0;
#endif
  return mm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_reallocate()

void * srn_mm_reallocate ( srn_mm_t * mm, void * ptr, size_t new_size )

nodiscard

Definition at line 146 of file default.c.

                                                                  {
  UNUSED(mm);
  return realloc(ptr, new_size);
}

srn_mm_release_block()

void srn_mm_release_block	(	srn_mm_t *	mm,
		srn_block_id_t	id )

Release the given block id and free the memory for later allocations.

Definition at line 388 of file default.c.

                                                           {
  PANIC_IF_NULL(mm);
  destroy_chain(mm, id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_mm_shutdown()

void srn_mm_shutdown

(

srn_mm_t *

mm

)

Shut down the memory manager and release the resources.

Will panic on error. Technically it should be the final piece of clean up that we call. Note: Shutdown is not thread safe at has to execute on the main thread.

Definition at line 325 of file default.c.

                                   {
  PANIC_IF_NULL(mm);
  assert(mm->provider != nullptr);
 
  for (size_t i = 0; i < mm->block_count; i++) {
    if (mm->blocks[i] != nullptr) {
      destroy_chain(mm, i);
    }
  }
 
  srn_block_t *block = mm->immortal_block;
 
  while (block != nullptr) {
    srn_block_t *tmp = block;
    block = tmp->next;
 
    mm->provider->release(tmp);
  }
 
  mm->provider->release(mm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_unlock_memory_manager()

void srn_unlock_memory_manager

(

srn_mm_t *

mm

)

Unocks the memory manager.

Definition at line 360 of file default.c.

{ srn_spinlock_unlock(&mm->lock); }

Here is the call graph for this function:

Here is the caller graph for this function: