memory_test.cpp File Reference

#include <cpu_io.h>
#include <cstddef>
#include <cstdint>
#include "arch.h"
#include "basic_info.hpp"
#include "kernel.h"
#include "kstd_cstring"
#include "kstd_libcxx.h"
#include "sk_stdlib.h"
#include "system_test.h"

Include dependency graph for memory_test.cpp:

Go to the source code of this file.

Functions
void *	malloc (size_t size)
void	free (void *ptr)
void *	aligned_alloc (size_t alignment, size_t size)
auto	memory_test () -> bool

Function Documentation

aligned_alloc()

void * aligned_alloc	(	size_t	alignment,
		size_t	size
	)

Definition at line 58 of file memory.cpp.

                                                                      {
  if (allocator) {
    return allocator->aligned_alloc(alignment, size);
  }
  return nullptr;
}

Here is the caller graph for this function:

free()

void free

(

void *

ptr

)

Definition at line 38 of file memory.cpp.

                                        {
  if (allocator) {
    allocator->free(ptr);
  }
}

Here is the caller graph for this function:

malloc()

void * malloc

(

size_t

size

)

Copyright

Copyright The SimpleKernel Contributors

Definition at line 31 of file memory.cpp.

                                             {
  if (allocator) {
    return allocator->malloc(size);
  }
  return nullptr;
}

Here is the caller graph for this function:

memory_test()

auto memory_test

(

)

-> bool

Definition at line 24 of file memory_test.cpp.

                           {
  klog::Info("memory_test: start");
 
  // Test 1: malloc & free
  size_t size = 1024;
  void* ptr = malloc(size);
  EXPECT_TRUE(ptr != nullptr, "memory_test: malloc failed");
 
  // Write and read verification
  auto* byte_ptr = static_cast<uint8_t*>(ptr);
  for (size_t i = 0; i < size; ++i) {
    byte_ptr[i] = static_cast<uint8_t>(i & 0xFF);
  }
 
  for (size_t i = 0; i < size; ++i) {
    EXPECT_EQ(byte_ptr[i], static_cast<uint8_t>(i & 0xFF),
              "memory_test: verify failed");
  }
 
  free(ptr);
  klog::Info("memory_test: malloc/free passed");
 
  // Test 2: aligned_alloc
  size_t alignment = 256;
  size_t aligned_size = 512;
  void* aligned_ptr = aligned_alloc(alignment, aligned_size);
  EXPECT_TRUE(aligned_ptr != nullptr, "memory_test: aligned_alloc failed");
 
  EXPECT_EQ(reinterpret_cast<uintptr_t>(aligned_ptr) & (alignment - 1), 0,
            "memory_test: aligned_alloc alignment failed");
 
  free(aligned_ptr);
  klog::Info("memory_test: aligned_alloc passed");
 
  // Test 3: Multiple small allocations
  const int count = 10;
  void* ptrs[count];
 
  for (int i = 0; i < count; ++i) {
    ptrs[i] = malloc(128);
    EXPECT_TRUE(ptrs[i] != nullptr, "memory_test: multi alloc failed");
    // Fill
    kstd::memset(ptrs[i], i, 128);
  }
 
  for (int i = 0; i < count; ++i) {
    auto* p = static_cast<uint8_t*>(ptrs[i]);
    for (int j = 0; j < 128; ++j) {
      EXPECT_EQ(p[j], i, "memory_test: multi alloc verify failed");
    }
    free(ptrs[i]);
  }
  klog::Info("memory_test: multi alloc passed");
 
  return true;
}

Here is the call graph for this function: