mm_tests.h

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include <serene/rt/mm/interface.h>
 
#include "base.h"
#include "serene/utils.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)
 
#if defined(MM_DEBUG)
#  define MM_TEST_LOG(...) DBG("MM_TEST", __VA_ARGS__)
#else
#  define MM_TEST_LOG(...)
#endif
 
typedef struct mm_dummy {
  char foo[200];
  char bar[200];
} mm_dummy;
 
typedef struct mm_64k {
  char foo[0xffff];
} mm_64k;
 
static inline size_t padding(size_t size, size_t align) {
  return (align - (size & (align - 1U))) & (align - 1);
}
 
static void test_mm_allocation() {
  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);
}
 
static void test_mm_allocation_in_block() {
  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);
}
 
static void test_mm_allocation_multiblock() {
  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);
}
 
static void test_mm_block_bitmap(void) {
  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);
}
 
static void test_mm_block_size_properties(void) {
  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);
}
 
static void test_mm_aligned_block_allocation(void) {
  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);
}
 
static void test_mm_immortal_multiblock(void) {
  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);
}
 
static void test_mm_get_block_out_of_range(void) {
  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);
}