memory_bridge.c

浏览该文件的文档.

#include "memory_bridge.h"
#include "internal.h"
 
#include <stdint.h>
#include <stdlib.h>
 
#if defined(LMMC_BUILD_TESTS) || defined(LMMC_DEBUG_LEAKS)
#include <stdatomic.h>
#endif
 
#ifdef LMMC_DEBUG_LEAKS
static void lmmc_debug_leaks_alloc(void);
static void lmmc_debug_leaks_free(void);
#endif
 
#ifdef LMMC_BUILD_TESTS
static _Atomic size_t lmmc_memory_fail_after = SIZE_MAX;
 
void lmmc_memory_fail_after_for_test(size_t successful_allocations) {
    atomic_store_explicit(
        &lmmc_memory_fail_after, successful_allocations, memory_order_relaxed);
}
 
static int lmmc_memory_should_fail(void) {
    size_t remaining = atomic_load_explicit(
        &lmmc_memory_fail_after, memory_order_relaxed);
    while (remaining != SIZE_MAX) {
        if (remaining == 0) {
            if (atomic_compare_exchange_weak_explicit(
                    &lmmc_memory_fail_after, &remaining, SIZE_MAX,
                    memory_order_relaxed, memory_order_relaxed)) {
                return 1;
            }
        } else if (atomic_compare_exchange_weak_explicit(
                       &lmmc_memory_fail_after, &remaining, remaining - 1,
                       memory_order_relaxed, memory_order_relaxed)) {
            return 0;
        }
    }
    return 0;
}
#else
static int lmmc_memory_should_fail(void) { return 0; }
#endif
 
void* lmmc_memory_alloc(size_t size) {
    if (lmmc_memory_should_fail()) return NULL;
    void* pointer = malloc(size);
#ifdef LMMC_DEBUG_LEAKS
    if (pointer != NULL) lmmc_debug_leaks_alloc();
#endif
    return pointer;
}
 
void* lmmc_memory_alloc_array(size_t count, size_t element_size) {
    size_t bytes = 0;
    if (!lmmc_safe_mul_size(count, element_size, &bytes)) return NULL;
    return lmmc_memory_alloc(bytes);
}
 
void* lmmc_memory_alloc_array_plus(
    size_t count, size_t extra, size_t element_size) {
    size_t total = 0;
    if (!lmmc_safe_add_size(count, extra, &total)) return NULL;
    return lmmc_memory_alloc_array(total, element_size);
}
 
void* lmmc_memory_alloc_array_2d(
    size_t rows, size_t cols, size_t element_size) {
    size_t count = 0;
    if (!lmmc_safe_mul_size(rows, cols, &count)) return NULL;
    return lmmc_memory_alloc_array(count, element_size);
}
 
void lmmc_memory_free(void* pointer) {
#ifdef LMMC_DEBUG_LEAKS
    if (pointer != NULL) lmmc_debug_leaks_free();
#endif
    free(pointer);
}
 
void* lmmc_memory_realloc(void* pointer, size_t size) {
    if (pointer == NULL) return lmmc_memory_alloc(size);
    if (size == 0) {
#ifdef LMMC_DEBUG_LEAKS
        lmmc_debug_leaks_free();
#endif
        free(pointer);
        return NULL;
    }
    if (lmmc_memory_should_fail()) return NULL;
    return realloc(pointer, size);
}
 
#ifdef LMMC_DEBUG_LEAKS
static _Atomic size_t lmmc_debug_allocation_count = 0;
 
static void lmmc_debug_leaks_alloc(void) {
    atomic_fetch_add_explicit(
        &lmmc_debug_allocation_count, 1, memory_order_relaxed);
}
 
static void lmmc_debug_leaks_free(void) {
    size_t count = atomic_load_explicit(
        &lmmc_debug_allocation_count, memory_order_relaxed);
    while (count != 0 && !atomic_compare_exchange_weak_explicit(
               &lmmc_debug_allocation_count, &count, count - 1,
               memory_order_relaxed, memory_order_relaxed)) {}
}
 
long long lmmc_debug_leaks_get_count(void) {
    const size_t count = atomic_load_explicit(
        &lmmc_debug_allocation_count, memory_order_relaxed);
    return count > (size_t)INT64_MAX ? INT64_MAX : count;
}
#endif