mm_tests.h File Reference

#include <serene/rt/mm/interface.h>
#include "base.h"
#include "serene/utils.h"

Include dependency graph for mm_tests.h:

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

Go to the source code of this file.

Data Structures
struct	mm_dummy
struct	mm_64k

Macros
#define	MM_TESTS(X)
#define	MM_TEST_LOG(...)

Typedefs
typedef struct mm_dummy	mm_dummy
typedef struct mm_64k	mm_64k

Functions
static size_t	padding (size_t size, size_t align)
static void	test_mm_allocation ()
static void	test_mm_allocation_in_block ()
static void	test_mm_allocation_multiblock ()
static void	test_mm_block_bitmap (void)
static void	test_mm_block_size_properties (void)
static void	test_mm_aligned_block_allocation (void)
static void	test_mm_immortal_multiblock (void)
static void	test_mm_get_block_out_of_range (void)

Macro Definition Documentation

MM_TEST_LOG

#define MM_TEST_LOG

(

...

)

Definition at line 38 of file mm_tests.h.

MM_TESTS

#define MM_TESTS

(

X

)

Value:

  X("mm::allocation", test_mm_allocation),                                 \
      X("mm::block_allocation", test_mm_allocation_in_block),              \
      X("mm::multiblock_allocation", test_mm_allocation_multiblock),       \
      X("mm::block_bitmap", test_mm_block_bitmap),                         \
      X("mm::block_size_properties", test_mm_block_size_properties),       \
      X("mm::aligned_block_allocation", test_mm_aligned_block_allocation), \
      X("mm::immortal_multiblock", test_mm_immortal_multiblock),           \
      X("mm::get_block_out_of_range", test_mm_get_block_out_of_range)

Definition at line 25 of file mm_tests.h.

#define MM_TESTS(X)                                                        \
  X("mm::allocation", test_mm_allocation),                                 \
      X("mm::block_allocation", test_mm_allocation_in_block),              \
      X("mm::multiblock_allocation", test_mm_allocation_multiblock),       \
      X("mm::block_bitmap", test_mm_block_bitmap),                         \
      X("mm::block_size_properties", test_mm_block_size_properties),       \
      X("mm::aligned_block_allocation", test_mm_aligned_block_allocation), \
      X("mm::immortal_multiblock", test_mm_immortal_multiblock),           \
      X("mm::get_block_out_of_range", test_mm_get_block_out_of_range)

Typedef Documentation

mm_64k

typedef struct mm_64k mm_64k

mm_dummy

typedef struct mm_dummy mm_dummy

Function Documentation

padding()

static size_t padding ( size_t size, size_t align )

inlinestatic

Definition at line 50 of file mm_tests.h.

                                                        {
  return (align - (size & (align - 1U))) & (align - 1);
}

Here is the caller graph for this function:

test_mm_aligned_block_allocation()

static void test_mm_aligned_block_allocation ( void )

static

Definition at line 186 of file mm_tests.h.

                                                   {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  srn_block_id_t b = srn_mm_allocate_block(mm);
  MM_TEST_LOG("Allocated block id for aligned test: %zu", (size_t)b);
 
  size_t alignment = 32;
  size_t size      = 13;
 
  void *p1 = srn_mm_allocate_in_block_aligned(mm, b, size, alignment);
  void *p2 = srn_mm_allocate_in_block_aligned(mm, b, size, alignment);
 
  MM_TEST_LOG("Aligned allocations: p1=%p, p2=%p", p1, p2);
 
  TEST_CHECK(p1 != NULL);
  TEST_CHECK(p2 != NULL);
  // Basically we should ignore the provided alignment and just use
  // DEFAULT_BLOCK_ALIGNMENT
  TEST_CHECK(((uintptr_t)p1 % DEFAULT_BLOCK_ALIGNMENT) == 0);
  TEST_CHECK(((uintptr_t)p2 % DEFAULT_BLOCK_ALIGNMENT) == 0);
 
  // Quick sanity: both allocations must belong to the same root block
  srn_block_t *block = srn_mm_get_block(mm, b);
  TEST_CHECK(block != nullptr);
 
  uintptr_t base = (uintptr_t)&block->base;
  uintptr_t end  = base + (block->size - offsetof(srn_block_t, base));
 
  TEST_CHECK((uintptr_t)p1 >= base && (uintptr_t)p1 + size <= end);
  TEST_CHECK((uintptr_t)p2 >= base && (uintptr_t)p2 + size <= end);
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function:

test_mm_allocation()

static void test_mm_allocation ( )

static

Definition at line 54 of file mm_tests.h.

                                 {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  mm_dummy *d = srn_mm_immortal_allocate(mm, mm_dummy);
 
  for (int i = 0; i < 200; i++) {
    d->foo[i] = 'A';
    d->bar[i] = 'B';
  }
 
  // DBG_HEX(mm->immortal_block, 600);
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function:

test_mm_allocation_in_block()

static void test_mm_allocation_in_block ( )

static

Definition at line 70 of file mm_tests.h.

                                          {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  srn_block_id_t b = srn_mm_allocate_block(mm);
  mm_dummy *d      = srn_mm_allocate_in_block(mm, b, mm_dummy);
 
  for (int i = 0; i < 200; i++) {
    d->foo[i] = 'A';
    d->bar[i] = 'B';
  }
 
  srn_block_t *block = srn_mm_get_block(mm, b);
 
  TEST_CHECK(block != nullptr);
  // DBG_HEX(block, 600);
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function:

test_mm_allocation_multiblock()

static void test_mm_allocation_multiblock ( )

static

Definition at line 90 of file mm_tests.h.

                                            {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  srn_block_id_t b = srn_mm_allocate_block(mm);
  MM_TEST_LOG("Allocated block 'b' with id %zu", b);
  MM_TEST_LOG("Allocating 'd1'");
  mm_64k *d1 = srn_mm_allocate_in_block(mm, b, mm_64k);
 
  for (int i = 0; i < 0xffff; i++) {
    d1->foo[i] = 'A';
  }
  MM_TEST_LOG("Allocating 'd2'");
  mm_64k *d2 = srn_mm_allocate_in_block(mm, b, mm_64k);
  for (int i = 0; i < 0xffff; i++) {
    d2->foo[i] = 'B';
  }
 
  MM_TEST_LOG("Allocating 'd3'");
  // this should end up on the root block
  mm_dummy *d3 = srn_mm_allocate_in_block(mm, b, mm_dummy);
  for (int i = 0; i < 200; i++) {
    d3->foo[i] = 'C';
    d3->bar[i] = 'D';
  }
 
  srn_block_t *block = srn_mm_get_block(mm, b);
 
  TEST_CHECK(block != nullptr);
  TEST_CHECK(block->next != nullptr);
  TEST_CHECK(block->next->next == nullptr);
  TEST_CHECK((uintptr_t)&block->next->base == (uintptr_t)d2);
 
  TEST_CHECK((uintptr_t)&block->base + 0xffff +
                 padding(sizeof(mm_64k), alignof(mm_64k)) ==
             (uintptr_t)d3);
 
  /* DBG_HEX(block, 600); */
  /* DBG_HEX(((char *)(uintptr_t)&block->base + (uintptr_t)0xfff0), 600); */
 
  /* DBG_HEX(block->next, 600); */
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function:

test_mm_block_bitmap()

static void test_mm_block_bitmap ( void )

static

Definition at line 135 of file mm_tests.h.

                                       {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  // Initially all bits must be 0 (no user blocks allocated)
  for (int i = 0; i < 4; i++) {
    TEST_CHECK(mm->block_bitmap[i] == 0);
  }
 
  srn_block_id_t b0 = srn_mm_allocate_block(mm);
  srn_block_id_t b1 = srn_mm_allocate_block(mm);
  srn_block_id_t b2 = srn_mm_allocate_block(mm);
 
  MM_TEST_LOG("Allocated block ids: %zu, %zu, %zu", (size_t)b0, (size_t)b1,
              (size_t)b2);
 
  TEST_CHECK(b0 == 0);
  TEST_CHECK(b1 == 1);
  TEST_CHECK(b2 == 2);
 
  uint64_t word0 = mm->block_bitmap[0];
 
  // Bits 0,1,2 must be set
  TEST_CHECK((word0 & 0x7ULL) == 0x7ULL);
  // Other bits in the first word are untouched
  // and other words should still be zero
  TEST_CHECK(mm->block_bitmap[1] == 0);
  TEST_CHECK(mm->block_bitmap[2] == 0);
  TEST_CHECK(mm->block_bitmap[3] == 0);
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function:

test_mm_block_size_properties()

static void test_mm_block_size_properties ( void )

static

Definition at line 168 of file mm_tests.h.

                                                {
  size_t page_size  = srn_mm_get_os_page_size();
  size_t block_size = srn_mm_get_block_size();
 
  MM_TEST_LOG("OS page size: %zu, block size: %zu", page_size, block_size);
 
  TEST_CHECK(page_size > 0);
  // block size must be a multiple of the OS page size
  TEST_CHECK(block_size % page_size == 0);
 
  // Block size must not be smaller than the desired size
  TEST_CHECK(block_size >= DESIRED_BLOCK_SIZE);
 
  // And it should be at most one page larger than DESIRED_BLOCK_SIZE
  // Note: checkout closest_multiple() implementation.
  TEST_CHECK(block_size < DESIRED_BLOCK_SIZE + page_size);
}

Here is the call graph for this function:

test_mm_get_block_out_of_range()

static void test_mm_get_block_out_of_range ( void )

static

Definition at line 252 of file mm_tests.h.

                                                 {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  srn_block_id_t b = srn_mm_allocate_block(mm);
  MM_TEST_LOG("Allocated block id: %zu", (size_t)b);
 
  srn_block_t *block = srn_mm_get_block(mm, b);
  TEST_CHECK(block != nullptr);
 
  // This ID is guaranteed to be out of range
  srn_block_id_t invalid  = b + 100;
  srn_block_t *null_block = srn_mm_get_block(mm, invalid);
  TEST_CHECK(null_block == nullptr);
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function:

test_mm_immortal_multiblock()

static void test_mm_immortal_multiblock ( void )

static

Definition at line 221 of file mm_tests.h.

                                              {
  srn_mm_t *mm = srn_mm_init();
  ASSERT_NOT_NULL(mm);
 
  // Same trick as test_mm_allocation_multiblock but on immortal_block
  MM_TEST_LOG("Allocating mm_64k instances in immortal block");
 
  mm_64k *i1 = srn_mm_immortal_allocate(mm, mm_64k);
  mm_64k *i2 = srn_mm_immortal_allocate(mm, mm_64k);
  mm_64k *i3 = srn_mm_immortal_allocate(mm, mm_64k);
 
  ASSERT_NOT_NULL(i1);
  ASSERT_NOT_NULL(i2);
  ASSERT_NOT_NULL(i3);
 
  for (int i = 0; i < 0xffff; i++) {
    i1->foo[i] = 'X';
    i2->foo[i] = 'Y';
    i3->foo[i] = 'Z';
  }
 
  srn_block_t *root = mm->immortal_block;
  TEST_CHECK(root != nullptr);
  TEST_CHECK(root->next != nullptr);
 
  MM_TEST_LOG("immortal root = %p, next = %p", (void *)root,
              (void *)root->next);
 
  srn_mm_shutdown(mm);
}

Here is the call graph for this function: