this time

Author: dreamer-coding

code/logic/fossil/sys/memory.h

@@ -154,28 +154,6 @@ fossil_sys_memory_t fossil_sys_memory_resize(fossil_sys_memory_t ptr, size_t old
  */
 bool fossil_sys_memory_is_valid(const fossil_sys_memory_t ptr);
 
-/**
- * @brief Align memory to a specific boundary.
- *
- * Allocates memory aligned to the specified alignment boundary.
- * Alignment must be a power of two (e.g., 8, 16, 32).
- *
- * @param size The size of the memory to allocate.
- * @param alignment The alignment boundary.
- * @return A pointer to the aligned memory.
- * @throws Error message and exits if allocation fails or alignment is invalid.
- */
-fossil_sys_memory_t fossil_sys_memory_aligned_alloc(size_t size, size_t alignment);
-
-/**
- * @brief Free aligned memory.
- *
- * Frees memory that was allocated with fossil_sys_memory_aligned_alloc.
- *
- * @param ptr A pointer to the aligned memory to free.
- */
-void fossil_sys_memory_aligned_free(fossil_sys_memory_t ptr);
-
 /**
  * @brief Fill memory with a repeating pattern.
  *
@@ -412,26 +390,6 @@ namespace fossil {
                 return fossil_sys_memory_is_valid(ptr);
             }
 
-            /**
-             * Allocate memory aligned to a specific boundary.
-             *
-             * @param size The size of the memory to allocate.
-             * @param alignment The alignment boundary.
-             * @return A pointer to the aligned memory.
-             */
-            static fossil_sys_memory_t aligned_alloc(size_t size, size_t alignment) {
-                return fossil_sys_memory_aligned_alloc(size, alignment);
-            }
-
-            /**
-             * Free aligned memory.
-             *
-             * @param ptr A pointer to the aligned memory to free.
-             */
-            static void aligned_free(fossil_sys_memory_t ptr) {
-                fossil_sys_memory_aligned_free(ptr);
-            }
-
             /**
              * Fill memory with a repeating pattern.
              *

code/logic/memory.c

@@ -192,44 +192,6 @@ bool fossil_sys_memory_is_valid(const fossil_sys_memory_t ptr) {
     return true;
 }
 
-// ----------------------- Aligned Memory -----------------------
-
-fossil_sys_memory_t fossil_sys_memory_aligned_alloc(size_t size, size_t alignment) {
-    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
-        fprintf(stderr, "Error: fossil_sys_memory_aligned_alloc() - Alignment must be a power of two.\n");
-        return NULL;
-    }
-
-    void *ptr = NULL;
-#if defined(_MSC_VER)
-    ptr = _aligned_malloc(size, alignment);
-    if (!ptr) {
-        fprintf(stderr, "Error: fossil_sys_memory_aligned_alloc() - Aligned allocation failed.\n");
-        return NULL;
-    }
-#else
-    if (posix_memalign(&ptr, alignment, size) != 0) {
-        fprintf(stderr, "Error: fossil_sys_memory_aligned_alloc() - Aligned allocation failed.\n");
-        return NULL;
-    }
-#endif
-
-    g_alloc_count++;
-    g_alloc_bytes += size;
-    return ptr;
-}
-
-void fossil_sys_memory_aligned_free(fossil_sys_memory_t ptr) {
-    if (!ptr) return;
-
-#if defined(_MSC_VER)
-    _aligned_free(ptr);
-#else
-    free(ptr);
-#endif
-    // Note: g_alloc_count and g_alloc_bytes tracking could be refined with actual size bookkeeping
-}
-
 // ----------------------- Memory Fill -----------------------
 
 fossil_sys_memory_t fossil_sys_memory_fill(fossil_sys_memory_t ptr,

code/tests/cases/test_memory.c

@@ -168,23 +168,6 @@ FOSSIL_TEST(c_test_memory_init) {
     fossil_sys_memory_free(ptr); // Cleanup
 }
 
-FOSSIL_TEST(c_test_memory_aligned_alloc_and_free) {
-    size_t size = 64;
-    size_t alignment = 16;
-    fossil_sys_memory_t ptr = fossil_sys_memory_aligned_alloc(size, alignment);
-    ASSUME_NOT_CNULL(ptr);
-    // Check alignment
-    ASSUME_ITS_TRUE(((uintptr_t)ptr % alignment) == 0);
-    fossil_sys_memory_aligned_free(ptr);
-}
-
-FOSSIL_TEST(c_test_memory_aligned_alloc_invalid_alignment) {
-    size_t size = 32;
-    size_t alignment = 20; // Not a power of two
-    fossil_sys_memory_t ptr = fossil_sys_memory_aligned_alloc(size, alignment);
-    ASSUME_ITS_TRUE(ptr == NULL);
-}
-
 FOSSIL_TEST(c_test_memory_fill_pattern) {
     size_t size = 16;
     uint8_t pattern[2] = {0xAB, 0xCD};
@@ -236,13 +219,6 @@ FOSSIL_TEST(c_test_memory_strdup) {
     fossil_sys_memory_free(dup);
 }
 
-FOSSIL_TEST(c_test_memory_stats) {
-    size_t allocs = 0, bytes = 0;
-    fossil_sys_memory_stats(&allocs, &bytes);
-    // Just check that the function runs and returns something
-    ASSUME_ITS_TRUE(allocs != 0 || bytes != 0);
-}
-
 // * * * * * * * * * * * * * * * * * * * * * * * *
 // * Fossil Logic Test Pool
 // * * * * * * * * * * * * * * * * * * * * * * * *
@@ -258,14 +234,11 @@ FOSSIL_TEST_GROUP(c_memory_tests) {
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_is_valid);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_calloc);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_init);
-    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_aligned_alloc_and_free);
-    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_aligned_alloc_invalid_alignment);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_fill_pattern);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_secure_zero);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_swap);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_find);
     FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_strdup);
-    FOSSIL_TEST_ADD(c_memory_suite, c_test_memory_stats);
 
     FOSSIL_TEST_REGISTER(c_memory_suite);
 }

code/tests/cases/test_memory.cpp

@@ -323,15 +323,6 @@ FOSSIL_TEST(cpp_test_memory_class_is_valid) {
     fossil::sys::Memory::free(ptr); // Cleanup
 }
 
-FOSSIL_TEST(cpp_test_memory_class_aligned_alloc_free) {
-    size_t size = 64;
-    size_t alignment = 32;
-    fossil_sys_memory_t ptr = fossil::sys::Memory::aligned_alloc(size, alignment);
-    ASSUME_NOT_CNULL(ptr);
-    ASSUME_ITS_TRUE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0); // Check alignment
-    fossil::sys::Memory::aligned_free(ptr); // Cleanup
-}
-
 FOSSIL_TEST(cpp_test_memory_class_fill) {
     size_t size = 16;
     uint8_t pattern[2] = {0xAB, 0xCD};
@@ -406,14 +397,6 @@ FOSSIL_TEST(cpp_test_memory_class_strdup) {
     fossil::sys::Memory::free(dup); // Cleanup
 }
 
-FOSSIL_TEST(cpp_test_memory_class_stats) {
-    size_t allocs = 0, bytes = 0;
-    fossil::sys::Memory::stats(&allocs, &bytes);
-    // Just check that stats call does not crash and returns something
-    ASSUME_ITS_TRUE(&allocs != nullptr);
-    ASSUME_ITS_TRUE(&bytes != nullptr);
-}
-
 // * * * * * * * * * * * * * * * * * * * * * * * *
 // * Fossil Logic Test Pool
 // * * * * * * * * * * * * * * * * * * * * * * * *
@@ -441,13 +424,11 @@ FOSSIL_TEST_GROUP(cpp_memory_tests) {
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_move);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_resize);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_is_valid);
-    FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_aligned_alloc_free);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_fill);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_secure_zero);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_swap);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_find);
     FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_strdup);
-    FOSSIL_TEST_ADD(cpp_memory_suite, cpp_test_memory_class_stats);
 
     FOSSIL_TEST_REGISTER(cpp_memory_suite);
 }