memory.c 文件参考

#include "../../../include/lammp/impl/mparam.h"
#include "../../../include/lammp/impl/prime_table.h"
#include "../../../include/lammp/impl/tmp_alloc.h"
#include "../../../include/lammp/lmmpn.h"
#include "../../../include/lammp/impl/safe_memory.h"

memory.c 的引用(Include)关系图:

浏览源代码.

宏定义
#define	heap_alloc_func   global_heap.alloc
#define	heap_free_func   global_heap.free
#define	HSIZE   sizeof(void*)
	Copyright (C) 2026 HJimmyK(Jericho Knox)
#define	realloc_func   global_heap.realloc

函数
void *	lmmp_alloc (size_t size)
	内存分配函数（调用lmmp_heap_alloc_fn）
int	lmmp_alloc_count (int cnt)
	堆内存分配计数器（线程局部）
static void	lmmp_chech_memory (size_t size, const char *func, int line)
void	lmmp_free (void *ptr)
	内存释放函数（调用lmmp_heap_free_fn）
void	lmmp_global_deinit (void)
	（线程局部的）全局共享的动态分配的堆内存资源释放函数
void	lmmp_global_init (void)
	全局初始化函数（线程局部的）
void	lmmp_leak_tracker (const char *func, int line)
	内存泄漏检测器
void *	lmmp_realloc (void *oldptr, size_t new_size)
	内存重分配函数（调用lmmp_realloc_fn）
void	lmmp_set_heap_allocator (const lmmp_heap_allocator_t *heap)
	设置 LAMMP 全局堆内存分配函数
int	lmmp_stack_deinit (void)
	LAMMP 全局栈释放函数（通常不需要手动调用）
int	lmmp_stack_init (size_t size)
	LAMMP 全局栈初始化函数（通常不需要手动调用）

变量
_Thread_local lmmp_heap_allocator_t	global_heap
static _Thread_local int	heap_alloc_count = 0
_Thread_local lmmp_memory_ctx	lmmp_tmpmem_ctx

宏定义说明

heap_alloc_func

#define heap_alloc_func   global_heap.alloc

在文件 memory.c 第 35 行定义.

heap_free_func

#define heap_free_func   global_heap.free

在文件 memory.c 第 36 行定义.

HSIZE

#define HSIZE   sizeof(void*)

Copyright (C) 2026 HJimmyK(Jericho Knox)

This file is part of LAMMP.

LAMMP is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License (LGPL) as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This program is distributed WITHOUT ANY WARRANTY.

See https://www.gnu.org/licenses/.

在文件 memory.c 第 27 行定义.

realloc_func

#define realloc_func   global_heap.realloc

在文件 memory.c 第 37 行定义.

函数说明

lmmp_alloc()

void * lmmp_alloc

(

size_t

size

)

内存分配函数（调用lmmp_heap_alloc_fn）

参数

size

要分配的内存字节数

注解

调用堆内存分配器，分配失败将触发 lmmp_abort

返回

返回指向分配内存的指针（分配失败不会 return NULL，而是直接触发 lmmp_abort）

在文件 memory.c 第 164 行定义.

                              {
    if (size) {
        void* ret = heap_alloc_func(size);
        if (ret == NULL)
            lmmp_chech_memory(size, __func__, __LINE__);
#if LAMMP_DEBUG_MEMORY_LEAK == 1
        heap_alloc_count++;
#endif
        return ret;
    }
    return NULL;
}

引用了 heap_alloc_count, heap_alloc_func, lmmp_chech_memory() , 以及 n.

被这些函数引用 lmmp_fft_memstack_() , 以及 lmmp_strong_rng_init_().

函数调用图:

这是这个函数的调用关系图:

lmmp_alloc_count()

int lmmp_alloc_count

(

int

cnt

)

堆内存分配计数器（线程局部）

参数

cnt	若不为0，则将堆内存计数器置为cnt

返回

返回当前的heap分配计数（如果被设置，即返回旧的计数值），即目前未被释放的堆内存数量

在文件 memory.c 第 113 行定义.

                              {
    if (cnt != 0) {
        int new_cnt = cnt;
        cnt = heap_alloc_count;
        heap_alloc_count = new_cnt;
        return cnt;
    }
    return heap_alloc_count;
}

引用了 heap_alloc_count , 以及 n.

lmmp_chech_memory()

static void lmmp_chech_memory ( size_t  size, const char *  func, int  line  )

inlinestatic

在文件 memory.c 第 105 行定义.

                                                                              {
    char msg[64];
    snprintf(msg, sizeof(msg), "Memory allocation failed (size: %zu bytes)", size);
    lmmp_abort(LAMMP_ERROR_MEMORY_ALLOC_FAILURE, msg, func, line);
}

引用了 LAMMP_ERROR_MEMORY_ALLOC_FAILURE, lmmp_abort() , 以及 n.

被这些函数引用 lmmp_alloc() , 以及 lmmp_realloc().

函数调用图:

这是这个函数的调用关系图:

lmmp_free()

void lmmp_free

(

void *

ptr

)

内存释放函数（调用lmmp_heap_free_fn）

参数

ptr

要释放的内存指针

在文件 memory.c 第 202 行定义.

                          {
    if (ptr) {
        heap_free_func(ptr);
#if LAMMP_DEBUG_MEMORY_LEAK == 1
        heap_alloc_count--;
#endif
    }
}

引用了 heap_alloc_count , 以及 heap_free_func.

被这些函数引用 lmmp_fft_memstack_(), lmmp_huff_tree_free_(), lmmp_mul_fft_(), lmmp_mul_fft_cache_(), lmmp_mul_fft_unbalance_(), lmmp_mullo_fft_(), lmmp_prime_cache_free_(), lmmp_prime_int_table_free_(), lmmp_strong_rng_free_() , 以及 lmmp_trialdiv_short_().

这是这个函数的调用关系图:

lmmp_global_deinit()

void lmmp_global_deinit

(

void

)

（线程局部的）全局共享的动态分配的堆内存资源释放函数

注解

调用此函数将释放全局范围内的所有动态分配的堆内存资源。 此函数可重入，多次调用不会导致重复释放。如需要再次使用，请重新调用 lmmp_global_init 初始化。 部分惰性初始化的资源将在再次首次使用时再次初始化，调用此函数可能导致部分缓存失效，导致性能下降。

警告

我们建议在线程结束时或程序进程结束时调用此函数。多线程下，每个线程都会拥有独立的副本， 未调用此函数结束线程可能导致内存泄漏。

在文件 memory.c 第 216 行定义.

                              {
    lmmp_stack_deinit();
    lmmp_prime_int_table_free_();
}

引用了 lmmp_prime_int_table_free_() , 以及 lmmp_stack_deinit().

被这些函数引用 lmmp_set_heap_allocator().

函数调用图:

这是这个函数的调用关系图:

lmmp_global_init()

void lmmp_global_init

(

void

)

全局初始化函数（线程局部的）

注解

调用此函数将初始化全局范围内的所有线程局部资源，如栈式分配器等。 部分惰性初始化的资源将在首次使用时初始化。调用此函数不会进行初始化。 此函数可重入，多次调用不会导致重复初始化。

警告

我们建议在进程或线程启动时调用此函数，以保证线程安全。

在文件 memory.c 第 212 行定义.

                            {
    lmmp_stack_init(LAMMP_POOL_SIZE);
}

引用了 LAMMP_POOL_SIZE , 以及 lmmp_stack_init().

被这些函数引用 lmmp_set_heap_allocator().

函数调用图:

这是这个函数的调用关系图:

lmmp_leak_tracker()

void lmmp_leak_tracker	(	const char *	func,
		int	line
	)

内存泄漏检测器

参数

func	泄漏发生的函数名
line	泄漏发生的行号

警告

内存计数器均是线程局部的，仅会检测单线程的内存泄漏。

注解

将会同时检验堆内存和栈内存，若堆内存计数器不为0，或栈内存的栈顶不在栈底，都会触发lmmp_abort 两者同时发生则将输出两者的信息。

在文件 memory.c 第 123 行定义.

                                                   {
    char msg[360] = {0};
    int offset = 0;
    const int max_len = sizeof(msg) - 1;
    bool t = false;
    if (heap_alloc_count != 0) {
        offset +=
            snprintf(msg + offset, max_len - offset, "Heap allocations not freed: %d block(s);\n", heap_alloc_count);
        t = true;
    }
    if (lmmp_tmpmem_ctx.stack_top != lmmp_tmpmem_ctx.stack_begin) {
        offset += snprintf(msg + offset, max_len - offset,
                           "Default stack allocator is not empty. top: %p, begin: %p, end: %p;\n",
                           lmmp_tmpmem_ctx.stack_top, lmmp_tmpmem_ctx.stack_begin, lmmp_tmpmem_ctx.stack_end);
        t = true;
    }
    if (lmmp_tmpmem_ctx.pool_top != lmmp_tmpmem_ctx.pool_begin) {
        offset += snprintf(msg + offset, max_len - offset,
                           "Default pool allocator is not empty. top: %p, begin: %p; remain: %zu bytes, capacity: %zu "
                           "bytes;\n",
                           lmmp_tmpmem_ctx.pool_top, lmmp_tmpmem_ctx.pool_begin, lmmp_tmpmem_ctx.remain,
                           lmmp_tmpmem_ctx.capacity);
        t = true;
    }
    if (t) {
        lmmp_abort(LAMMP_ERROR_MEMORY_LEAK, msg, func, line);
    }
}

引用了 lmmp_memory_ctx::capacity, heap_alloc_count, LAMMP_ERROR_MEMORY_LEAK, lmmp_abort(), lmmp_tmpmem_ctx, n, lmmp_memory_ctx::pool_begin, lmmp_memory_ctx::pool_top, lmmp_memory_ctx::remain, lmmp_memory_ctx::stack_begin, lmmp_memory_ctx::stack_end, lmmp_memory_ctx::stack_top , 以及 t.

函数调用图:

lmmp_realloc()

void * lmmp_realloc	(	void *	ptr,
		size_t	size
	)

内存重分配函数（调用lmmp_realloc_fn）

参数

ptr	已分配的内存指针
size	新的内存大小（字节）

注解

调用堆内存重新分配器，分配失败将触发 lmmp_abort

返回

成功返回指向新内存区域的指针（分配失败不会 return NULL，而是直接触发 lmmp_abort）

在文件 memory.c 第 184 行定义.

                                                  {
    void* ret = realloc_func(oldptr, new_size);
    if (ret == NULL)
        lmmp_chech_memory(new_size, __func__, __LINE__);
    return ret;
}

引用了 lmmp_chech_memory(), n , 以及 realloc_func.

被这些函数引用 lmmp_strong_rng_extern_().

函数调用图:

这是这个函数的调用关系图:

lmmp_set_heap_allocator()

void lmmp_set_heap_allocator

(

const lmmp_heap_allocator_t *

heap

)

设置 LAMMP 全局堆内存分配函数

参数

heap	新的堆内存分配器，可以为NULL，此时会直接返回，而不进行任何操作。

警告

由于所有共享内存都采用堆内存分配。因此，传入新的堆分配器将会首先调用 lmmp_global_deinit 函数，释放所有共享内存，以保证老旧的堆资源被释放。 然后将会自动调用 lmmp_global_init 函数，重新分配所有线程局部内存。 同时，为保证内存不泄露，将会对堆计数器和栈顶以及缓冲池顶进行检查。 若此时堆栈分配计数器不为 0，或当前栈帧不在栈底，都会触发lmmp_abort函数， 并输出相应的错误信息。

注解

堆分配器是线程局部的，因此，创建新线程时，如有需要，请自行设置新的堆分配器。 同时也请自行保证分配器和释放器相匹配。

在文件 memory.c 第 94 行定义.

                                                                {
    if (heap == NULL)
        return;
    lmmp_global_deinit();
#if LAMMP_DEBUG_MEMORY_LEAK == 1
    lmmp_leak_tracker(__func__, __LINE__); // Check for memory leaks before setting new allocator
#endif
    global_heap = *heap;
    lmmp_global_init();
}

引用了 global_heap, lmmp_global_deinit(), lmmp_global_init(), lmmp_leak_tracker , 以及 n.

函数调用图:

lmmp_stack_deinit()

int lmmp_stack_deinit

(

void

)

LAMMP 全局栈释放函数（通常不需要手动调用）

警告

请注意调用此函数后，访问之前的分配的栈空间将会导致未定义行为。在定义了 LAMMP_DEBUG_MEMORY_LEAK 宏时，会检查默认栈是否为空， 则会触发lmmp_abort函数。

注解

如果此后再使用栈内存，请调用 lmmp_stack_init 函数，以重置栈空间。

返回

返回0表示成功释放，返回-1表示已经释放（并非错误）。

在文件 memory.c 第 51 行定义.

                            {
    if (lmmp_tmpmem_ctx.stack_begin != NULL) {
        heap_free_func(lmmp_tmpmem_ctx.stack_begin);
        if (lmmp_tmpmem_ctx.pool_begin != NULL)
            heap_free_func(lmmp_tmpmem_ctx.pool_begin);
        lmmp_tmpmem_ctx.stack_begin = NULL;
        lmmp_tmpmem_ctx.stack_end = NULL;
        lmmp_tmpmem_ctx.stack_top = NULL;
        lmmp_tmpmem_ctx.pool_begin = NULL;
        lmmp_tmpmem_ctx.pool_top = NULL;
        lmmp_tmpmem_ctx.remain = 0;   // Reset remain to 0
        lmmp_tmpmem_ctx.capacity = 0; // Reset capacity to 0
        return 0;
    } else {
        return -1;
    }
}

引用了 lmmp_memory_ctx::capacity, heap_free_func, lmmp_tmpmem_ctx, n, lmmp_memory_ctx::pool_begin, lmmp_memory_ctx::pool_top, lmmp_memory_ctx::remain, lmmp_memory_ctx::stack_begin, lmmp_memory_ctx::stack_end , 以及 lmmp_memory_ctx::stack_top.

被这些函数引用 lmmp_global_deinit().

这是这个函数的调用关系图:

lmmp_stack_init()

int lmmp_stack_init

(

size_t

size

)

LAMMP 全局栈初始化函数（通常不需要手动调用）

注解

初始化默认栈，并分配大小为size的额外内存池。如果已经初始化， 则会直接返回-1，表示已经初始化（并非错误），且不进行任何其他操作。 lmmp_global_init 函数会自动调用此函数，分配的额外缓冲池大小为 LAMMP_POOL_SIZE 的大小 （默认为512kb），无需手动调用。 如果你想手动设置缓冲池的大小，可以先调用 lmmp_stack_deinit 函数，再调用此函数，将 POOL_SIZE 设置为你想要的值。同时你也可以禁用缓冲池（即size为0），此时不会分配额外缓冲池。

返回

返回0表示成功初始化，返回-1表示已经初始化（并非错误）。

在文件 memory.c 第 69 行定义.

                                 {
    if (lmmp_tmpmem_ctx.stack_begin != NULL) {
        return -1;
    } else {
        lmmp_tmpmem_ctx.stack_begin = heap_alloc_func(LAMMP_DEFAULT_STACK_SIZE);
        if (lmmp_tmpmem_ctx.stack_begin == NULL) {
            lmmp_abort(LAMMP_ERROR_MEMORY_ALLOC_FAILURE, "Failed to allocate stack memory", __func__, __LINE__);
        }
        lmmp_tmpmem_ctx.stack_end = (mp_byte_t*)(lmmp_tmpmem_ctx.stack_begin) + LAMMP_DEFAULT_STACK_SIZE;
        lmmp_tmpmem_ctx.stack_top = lmmp_tmpmem_ctx.stack_begin;
        if (size > LAMMP_MAX_ALIGN) {
            // 只有当size大于最大对齐单位时，才分配缓冲池
            lmmp_tmpmem_ctx.pool_begin = heap_alloc_func(size);
            if (lmmp_tmpmem_ctx.pool_begin == NULL) {
                heap_free_func(lmmp_tmpmem_ctx.stack_begin);  // Free old stack memory
                lmmp_abort(LAMMP_ERROR_MEMORY_ALLOC_FAILURE, "Failed to allocate pool memory", __func__, __LINE__);
            }
            lmmp_tmpmem_ctx.pool_top = lmmp_tmpmem_ctx.pool_begin;
            lmmp_tmpmem_ctx.remain = size;
            lmmp_tmpmem_ctx.capacity = size;
        }
        return 0;
    }
}

引用了 lmmp_memory_ctx::capacity, heap_alloc_func, heap_free_func, LAMMP_DEFAULT_STACK_SIZE, LAMMP_ERROR_MEMORY_ALLOC_FAILURE, LAMMP_MAX_ALIGN, lmmp_abort(), lmmp_tmpmem_ctx, n, lmmp_memory_ctx::pool_begin, lmmp_memory_ctx::pool_top, lmmp_memory_ctx::remain, lmmp_memory_ctx::stack_begin, lmmp_memory_ctx::stack_end , 以及 lmmp_memory_ctx::stack_top.

被这些函数引用 lmmp_global_init().

函数调用图:

这是这个函数的调用关系图:

变量说明

global_heap

_Thread_local lmmp_heap_allocator_t global_heap

初始值:

= {
    .alloc   = (lmmp_heap_alloc_fn)malloc,
    .free    = (lmmp_heap_free_fn)free,
    .realloc = (lmmp_realloc_fn)realloc,
}

在文件 memory.c 第 29 行定义.

                                                       {
    .alloc   = (lmmp_heap_alloc_fn)malloc,
    .free    = (lmmp_heap_free_fn)free,
    .realloc = (lmmp_realloc_fn)realloc,
};

被这些函数引用 lmmp_set_heap_allocator(), lmmp_temp_heap_alloc_() , 以及 lmmp_temp_heap_free_().

heap_alloc_count

_Thread_local int heap_alloc_count = 0

static

在文件 memory.c 第 39 行定义.

被这些函数引用 lmmp_alloc(), lmmp_alloc_count(), lmmp_free() , 以及 lmmp_leak_tracker().

lmmp_tmpmem_ctx

_Thread_local lmmp_memory_ctx lmmp_tmpmem_ctx

初始值:

= {
    .stack_begin = NULL,
    .stack_end   = NULL,
    .stack_top   = NULL,
    .pool_begin  = NULL,
    .pool_top    = NULL,
    .remain      = 0,
    .capacity    = 0,
}

在文件 memory.c 第 41 行定义.

                                                     {
    .stack_begin = NULL,
    .stack_end   = NULL,
    .stack_top   = NULL,
    .pool_begin  = NULL,
    .pool_top    = NULL,
    .remain      = 0,
    .capacity    = 0,
};

被这些函数引用 lmmp_leak_tracker(), lmmp_stack_deinit(), lmmp_stack_init(), lmmp_temp_pool_alloc_(), lmmp_temp_pool_free_(), lmmp_temp_stack_alloc_() , 以及 lmmp_temp_stack_free_().