#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

lmmp.h 的引用(Include)关系图:

此图展示该文件直接或间接的被哪些文件引用了:

结构体
struct	lmmp_heap_allocator_t

宏定义
#define	LAMMP_API __declspec(dllimport)

#define	LAMMP_DEBUG_ASSERT_CHECK 0

#define	LAMMP_DEBUG_MEMORY_CHECK 0

#define	LAMMP_DEBUG_MEMORY_LEAK 0

#define	LAMMP_DEBUG_PARAM_ASSERT_CHECK 0

#define	LAMMP_DEBUG_STACK_OVERFLOW_CHECK 0
	Copyright (C) 2026 HJimmyK(Jericho Knox)

#define	LAMMP_MAX_ALIGN 16

#define	LAMMP_MEMORY_MORE_ALLOC_TIMES 1

#define	LAMMP_NORETURN /* no definition */

#define	LAMMP_THREAD_LOCAL _Thread_local

#define	LIMB_BITS 64

#define	LIMB_BYTES 8

#define	LIMB_MAX (~(mp_limb_t)0)

#define	LLIMB_BITS 32

#define	LLIMB_BYTES 4

#define	LLIMB_MASK ((mp_limb_t)0xffffffff)

#define	LMMP_ABS(x) ((x) >= 0 ? (x) : -(x))

#define	lmmp_assert(x)

#define	lmmp_copy(dst, src, n) memmove((dst), (src), ((size_t)(n) << 3))

#define	lmmp_debug_assert(x) ((void)0)

#define	lmmp_leak_tracker ((void)0)

#define	LMMP_MAX(h, i) ((h) > (i) ? (h) : (i))

#define	LMMP_MIN(l, o) ((l) < (o) ? (l) : (o))

#define	lmmp_param_assert(x) ((void)0)

#define	LMMP_POW2_Q(n) (((n) & ((n) - 1)) == 0)

#define	LMMP_ROUND_UP_MULTIPLE(a, m) ((a) + (m) - 1 - ((a) + (m) - 1) % (m))

#define	LMMP_SWAP(x, y, type)

#define	lmmp_zero(dst, n) memset((dst), 0, ((size_t)(n) << 3))

#define	LOG2_LIMB_BITS 6

#define	STATIC_ASSERT(cond, msg) typedef char static_assert_##__LINE__[(cond) ? 1 : -1]

类型定义
typedef void(*	lmmp_abort_fn) (lmmp_error_t type, const char msg, const char func, int line)
	LAMMP 全局退出函数指针类型

typedef void (	lmmp_heap_alloc_fn) (size_t size)

typedef void(*	lmmp_heap_free_fn) (void *ptr)

typedef void (	lmmp_realloc_fn) (void *ptr, size_t size)

typedef size_t	mp_bitcnt_t

typedef uint8_t	mp_byte_t

typedef uint64_t	mp_limb_t

typedef mp_limb_t *	mp_ptr

typedef uint64_t	mp_size_t

typedef int64_t	mp_slimb_t

typedef const mp_limb_t *	mp_srcptr

typedef int64_t	mp_ssize_t

typedef char	static_assert___LINE__[(sizeof(void *)==8) ? 1 :-1]

枚举
enum	lmmp_error_t { LAMMP_ERROR_ASSERT_FAILURE = 1 , LAMMP_ERROR_DEBUG_ASSERT_FAILURE = 2 , LAMMP_ERROR_PARAM_ASSERT_FAILURE = 3 , LAMMP_ERROR_MEMORY_ALLOC_FAILURE = 4 , LAMMP_ERROR_MEMORY_FREE_FAILURE = 5 , LAMMP_ERROR_OUT_OF_BOUNDS = 6 , LAMMP_ERROR_MEMORY_LEAK = 7 , LAMMP_ERROR_UNEXPECTED_ERROR = 8 }

函数
void	lmmp_abort (lmmp_error_t type, const char msg, const char func, int line)
	LAMMP 全局退出函数，内部错误或断言失败时调用，若设置了全局退出函数，则会调用该函数，否则会调用默认的退出函数。

void *	lmmp_alloc (size_t size)
	内存分配函数（调用lmmp_heap_alloc_fn）

int	lmmp_alloc_count (int cnt)
	堆内存分配计数器（线程局部）

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 *ptr, size_t size)
	内存重分配函数（调用lmmp_realloc_fn）

lmmp_abort_fn	lmmp_set_abort_fn (lmmp_abort_fn func)
	设置 LAMMP 全局退出函数（所有线程均生效）

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 全局栈初始化函数（通常不需要手动调用）

结构体说明

◆ lmmp_heap_allocator_t

struct lmmp_heap_allocator_t

在文件 lmmp.h 第 169 行定义.

lmmp_heap_allocator_t 的协作图:

成员变量
lmmp_heap_alloc_fn	alloc
lmmp_heap_free_fn	free
lmmp_realloc_fn	realloc

宏定义说明

◆ LAMMP_API

#define LAMMP_API __declspec(dllimport)

在文件 lmmp.h 第 61 行定义.

◆ LAMMP_DEBUG_ASSERT_CHECK

#define LAMMP_DEBUG_ASSERT_CHECK 0

在文件 lmmp.h 第 48 行定义.

◆ LAMMP_DEBUG_MEMORY_CHECK

#define LAMMP_DEBUG_MEMORY_CHECK 0

在文件 lmmp.h 第 50 行定义.

◆ LAMMP_DEBUG_MEMORY_LEAK

#define LAMMP_DEBUG_MEMORY_LEAK 0

在文件 lmmp.h 第 52 行定义.

◆ LAMMP_DEBUG_PARAM_ASSERT_CHECK

#define LAMMP_DEBUG_PARAM_ASSERT_CHECK 0

在文件 lmmp.h 第 49 行定义.

◆ LAMMP_DEBUG_STACK_OVERFLOW_CHECK

#define LAMMP_DEBUG_STACK_OVERFLOW_CHECK 0

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/.

在文件 lmmp.h 第 47 行定义.

◆ LAMMP_MAX_ALIGN

#define LAMMP_MAX_ALIGN 16

在文件 lmmp.h 第 84 行定义.

◆ LAMMP_MEMORY_MORE_ALLOC_TIMES

#define LAMMP_MEMORY_MORE_ALLOC_TIMES 1

在文件 lmmp.h 第 51 行定义.

◆ LAMMP_NORETURN

#define LAMMP_NORETURN /* no definition */

在文件 lmmp.h 第 151 行定义.

◆ LAMMP_THREAD_LOCAL

#define LAMMP_THREAD_LOCAL _Thread_local

在文件 lmmp.h 第 102 行定义.

◆ LIMB_BITS

#define LIMB_BITS 64

在文件 lmmp.h 第 86 行定义.

◆ LIMB_BYTES

#define LIMB_BYTES 8

在文件 lmmp.h 第 87 行定义.

◆ LIMB_MAX

#define LIMB_MAX (~(mp_limb_t)0)

在文件 lmmp.h 第 89 行定义.

◆ LLIMB_BITS

#define LLIMB_BITS 32

在文件 lmmp.h 第 90 行定义.

◆ LLIMB_BYTES

#define LLIMB_BYTES 4

在文件 lmmp.h 第 91 行定义.

◆ LLIMB_MASK

#define LLIMB_MASK ((mp_limb_t)0xffffffff)

在文件 lmmp.h 第 92 行定义.

◆ LMMP_ABS

#define LMMP_ABS ( x ) ((x) >= 0 ? (x) : -(x))

在文件 lmmp.h 第 349 行定义.

◆ lmmp_assert

#define lmmp_assert ( x )

值:

    do {                                                                    \
        if (!(x)) {                                                         \
            lmmp_abort(LAMMP_ERROR_ASSERT_FAILURE, #x, __func__, __LINE__); \
        }                                                                   \
    } while (0)

在文件 lmmp.h 第 373 行定义.

       {                                                                    \
        if (!(x)) {                                                         \
            lmmp_abort(LAMMP_ERROR_ASSERT_FAILURE, #x, __func__, __LINE__); \
        }                                                                   \
    } while (0)

◆ lmmp_copy

#define lmmp_copy	(	dst,
		src,
		n
	)	memmove((dst), (src), ((size_t)(n) << 3))

在文件 lmmp.h 第 367 行定义.

◆ lmmp_debug_assert

#define lmmp_debug_assert ( x ) ((void)0)

在文件 lmmp.h 第 390 行定义.

◆ lmmp_leak_tracker

#define lmmp_leak_tracker ((void)0)

在文件 lmmp.h 第 345 行定义.

◆ LMMP_MAX

#define LMMP_MAX	(	h,
		i
	)	((h) > (i) ? (h) : (i))

在文件 lmmp.h 第 353 行定义.

◆ LMMP_MIN

#define LMMP_MIN	(	l,
		o
	)	((l) < (o) ? (l) : (o))

在文件 lmmp.h 第 351 行定义.

◆ lmmp_param_assert

#define lmmp_param_assert ( x ) ((void)0)

在文件 lmmp.h 第 401 行定义.

◆ LMMP_POW2_Q

#define LMMP_POW2_Q ( n ) (((n) & ((n) - 1)) == 0)

在文件 lmmp.h 第 362 行定义.

◆ LMMP_ROUND_UP_MULTIPLE

#define LMMP_ROUND_UP_MULTIPLE	(	a,
		m
	)	((a) + (m) - 1 - ((a) + (m) - 1) % (m))

在文件 lmmp.h 第 364 行定义.

◆ LMMP_SWAP

#define LMMP_SWAP	(	x,
		y,
		type
	)

值:

    do {                      \
        type _swap_ = (x);    \
        (x) = (y);            \
        (y) = _swap_;         \
    } while (0)

在文件 lmmp.h 第 355 行定义.

       {                      \
        type _swap_ = (x);    \
        (x) = (y);            \
        (y) = _swap_;         \
    } while (0)

◆ lmmp_zero

#define lmmp_zero	(	dst,
		n
	)	memset((dst), 0, ((size_t)(n) << 3))

在文件 lmmp.h 第 369 行定义.

◆ LOG2_LIMB_BITS

#define LOG2_LIMB_BITS 6

在文件 lmmp.h 第 88 行定义.

◆ STATIC_ASSERT

#define STATIC_ASSERT	(	cond,
		msg
	)	typedef char static_assert_##__LINE__[(cond) ? 1 : -1]

在文件 lmmp.h 第 111 行定义.

类型定义说明

◆ lmmp_abort_fn

typedef void(* lmmp_abort_fn) (lmmp_error_t type, const char *msg, const char *func, int line)

LAMMP 全局退出函数指针类型

参数

type	退出类型（可以查看lmmp_abort函数对此参数的说明，这里不再重复）
msg	退出信息，取决于type
func	退出处的函数名
line	退出处的行号

在文件 lmmp.h 第 229 行定义.

◆ lmmp_heap_alloc_fn

typedef void *(* lmmp_heap_alloc_fn) (size_t size)

在文件 lmmp.h 第 165 行定义.

◆ lmmp_heap_free_fn

typedef void(* lmmp_heap_free_fn) (void *ptr)

在文件 lmmp.h 第 166 行定义.

◆ lmmp_realloc_fn

typedef void *(* lmmp_realloc_fn) (void *ptr, size_t size)

在文件 lmmp.h 第 167 行定义.

◆ mp_bitcnt_t

typedef size_t mp_bitcnt_t

在文件 lmmp.h 第 82 行定义.

◆ mp_byte_t

typedef uint8_t mp_byte_t

在文件 lmmp.h 第 75 行定义.

◆ mp_limb_t

typedef uint64_t mp_limb_t

在文件 lmmp.h 第 76 行定义.

◆ mp_ptr

typedef mp_limb_t* mp_ptr

在文件 lmmp.h 第 80 行定义.

◆ mp_size_t

typedef uint64_t mp_size_t

在文件 lmmp.h 第 77 行定义.

◆ mp_slimb_t

typedef int64_t mp_slimb_t

在文件 lmmp.h 第 78 行定义.

◆ mp_srcptr

typedef const mp_limb_t* mp_srcptr

在文件 lmmp.h 第 81 行定义.

◆ mp_ssize_t

typedef int64_t mp_ssize_t

在文件 lmmp.h 第 79 行定义.

◆ static_assert_LINE

typedef char static_assert___LINE__[(sizeof(void *)==8) ? 1 :-1]

在文件 lmmp.h 第 114 行定义.

枚举类型说明

◆ lmmp_error_t

enum lmmp_error_t

枚举值
LAMMP_ERROR_ASSERT_FAILURE
LAMMP_ERROR_DEBUG_ASSERT_FAILURE
LAMMP_ERROR_PARAM_ASSERT_FAILURE
LAMMP_ERROR_MEMORY_ALLOC_FAILURE
LAMMP_ERROR_MEMORY_FREE_FAILURE
LAMMP_ERROR_OUT_OF_BOUNDS
LAMMP_ERROR_MEMORY_LEAK
LAMMP_ERROR_UNEXPECTED_ERROR

在文件 lmmp.h 第 211 行定义.

             {
    LAMMP_ERROR_ASSERT_FAILURE = 1,
    LAMMP_ERROR_DEBUG_ASSERT_FAILURE = 2,
    LAMMP_ERROR_PARAM_ASSERT_FAILURE = 3,
    LAMMP_ERROR_MEMORY_ALLOC_FAILURE = 4,
    LAMMP_ERROR_MEMORY_FREE_FAILURE = 5,
    LAMMP_ERROR_OUT_OF_BOUNDS = 6,
    LAMMP_ERROR_MEMORY_LEAK = 7,
    LAMMP_ERROR_UNEXPECTED_ERROR = 8
} lmmp_error_t;

函数说明

◆ lmmp_abort()

void lmmp_abort	(	lmmp_error_t	type,
		const char *	msg,
		const char *	func,
		int	line
	)

LAMMP 全局退出函数，内部错误或断言失败时调用，若设置了全局退出函数，则会调用该函数，否则会调用默认的退出函数。

参数

msg	退出信息，assert类型的错误信息通常仅包含断言内容，其他类型的错误则因类型不同而不同。
func	退出处的函数名
line	退出处的行号
type	退出类型。有以下几个类型： 1. ASSERT_FAILURE （枚举值为1）为lmmp_assert触发的退出，lmmp_assert触发的普通退出几乎不可能发生，其通常代表不可能发生的计算错误，可能表明程序执行此处时必须正确的输入错误。比如预期无进位的加法产生了进位。此类错误不可接受，会导致计算无法继续进行，导致程序崩溃。 2. DEBUG_ASSERT_FAILURE （枚举值为2）为lmmp_debug_assert触发的退出。其通常表明预期之外的错误，这通常是调用者的UB，如无UB的情况下触发此错误；也可能是LAMMP内部的逻辑错误，开发者期待的输入错误，在该逻辑处仅简单考虑了某些情况。如有此类错误，可以报告给开发者。此类型只会在定义了 LAMMP_DEBUG_ASSERT_CHECK 宏为 1 的情况下才会触发。 3. PARAM_ASSERT_FAILURE （枚举值为3）为参数检查失败导致的退出。其通常表明调用者传入了无效的参数，导致函数的行为不符合预期。此类错误不可接受，会导致计算无法继续进行，导致程序崩溃。此类型的错误只有在定义了 LAMMP_DEBUG_PARAM_ASSERT_CHECK 宏为 1 的情况下才会触发。 4. MEMORY_ALLOC_FAILURE （枚举值为4）为内存分配失败退出。在使用堆分配器时，申请内存失败，导致触发此错误。此类型错误不受明确的宏调控，Realse模式下，会保留必要的触发场景，部分场景下，在一些检查宏定义时，可能会额外触发此错误。 5. MEMORY_FREE_FAILURE （枚举值为5）为内存释放错误。当释放堆内存时可能触发，原因通常为头部信息被损坏，极有可能源于传入错误的指针，又或者缓冲区溢出导致此头部损坏。LAMMP_DEBUG_MEMORY_CHECK 宏为 1 时，才可能触发。 6. OUT_OF_BOUNDS （枚举值为6）为数组越界访问导致的退出。通常表明未按规定使用空间。此类型的错误在堆分配器中，当释放堆内存时，检测到数组尾部魔数不匹配，导致此错误。LAMMP_DEBUG_MEMORY_CHECK 宏为 1 时，才可能触发。 7. MEMORY_LEAK （枚举值为7）为内存泄漏导致的退出。在检查点处，堆内存计数器不为0，或者当前栈帧不在栈底，又或者缓冲池定不在缓冲池底，都会触发此错误。触发原因可能为，在调用堆分配器重置函数时，显式检查到此时的堆计数器不为0或者栈帧以及缓冲池不为底部。又或者手动调用 lmmp_leak_tracker 宏来进行检查，检查到了相同的情况。需注意，手动调用此宏时，请先调用 lmmp_global_deinit 进行全局共享的堆资源的安全释放（因为部分全局共享资源也会被计数）。 8. UNEXPECTED_ERROR （枚举值为8）为其他未知错误导致的退出。

警告: LAMMP内部中断都将会调用此函数，如果全局退出函数为NULL，则使用默认的退出函数，会打印出全部错误信息，并调用 abort 函数中断程序。自定义全局退出函数请通过 lmmp_set_abort_fn 函数进行设置。请不要在全局退出函数里做任何危险的操作，本库的开发者不对其调用产生的影响做任何保证。

在文件 abort.c 第 102 行定义.

                                                                                {
    abort_func_lock();
    lmmp_abort_fn fn = lmmp_abort_func;
    abort_func_unlock();
 
    if (fn != NULL) {
        fn(type, msg, func, line);
    } else {
        fprintf(stderr, "LAMMP abort at [%s]:%d\n", func, line);
        fprintf(stderr, "Abort type: %s, abort msg: \n%s\n", type_to_str(type), msg);
        fflush(stderr);
    }
    abort();
}

引用了 abort_func_lock(), abort_func_unlock(), lmmp_abort_func, n , 以及 type_to_str().

被这些函数引用 check_extra_memory_overflow(), check_memory_block_integrity(), lmmp_alloc_debug(), lmmp_chech_memory(), lmmp_leak_tracker(), lmmp_realloc_debug(), lmmp_stack_init(), lmmp_temp_heap_alloc_() , 以及 lmmp_temp_stack_alloc_().

函数调用图:

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

◆ 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_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_abort_fn()

lmmp_abort_fn lmmp_set_abort_fn ( lmmp_abort_fn func )

设置 LAMMP 全局退出函数（所有线程均生效）

参数

func	退出函数指针，可以为NULL

警告: 请注意，我们将不会对 func 的调用做任何保护，因此请不要在 func 里做任何危险的操作，本库的开发者不对 func 函数的调用产生的影响做任何保证。

注解: 若 func 为 NULL，则代表使用默认的退出机制。lmmp_abort 函数被标记为无返回值，因此设置的函数也应当无返回值，即使自定义的func函数真的会返回了，那么也将会调用 abort 函数中断程序。

返回: 返回之前的退出函数指针，若原指针为NULL，则返回NULL。

在文件 abort.c 第 70 行定义.

                                                    {
    abort_func_lock();
    lmmp_abort_fn old = lmmp_abort_func;
    lmmp_abort_func = func;
    abort_func_unlock();
 
    return old;
}

引用了 abort_func_lock(), abort_func_unlock(), lmmp_abort_func , 以及 n.

函数调用图:

◆ 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().

函数调用图:

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

结构体

宏定义

类型定义

枚举

函数

结构体说明

◆ lmmp_heap_allocator_t

宏定义说明

◆ LAMMP_API

◆ LAMMP_DEBUG_ASSERT_CHECK

◆ LAMMP_DEBUG_MEMORY_CHECK

◆ LAMMP_DEBUG_MEMORY_LEAK

◆ LAMMP_DEBUG_PARAM_ASSERT_CHECK

◆ LAMMP_DEBUG_STACK_OVERFLOW_CHECK

◆ LAMMP_MAX_ALIGN

◆ LAMMP_MEMORY_MORE_ALLOC_TIMES

◆ LAMMP_NORETURN

◆ LAMMP_THREAD_LOCAL

◆ LIMB_BITS

◆ LIMB_BYTES

◆ LIMB_MAX

◆ LLIMB_BITS

◆ LLIMB_BYTES

◆ LLIMB_MASK

◆ LMMP_ABS

◆ lmmp_assert

◆ lmmp_copy

◆ lmmp_debug_assert

◆ lmmp_leak_tracker

◆ LMMP_MAX

◆ LMMP_MIN

◆ lmmp_param_assert

◆ LMMP_POW2_Q

◆ LMMP_ROUND_UP_MULTIPLE

◆ LMMP_SWAP

◆ lmmp_zero

◆ LOG2_LIMB_BITS

◆ STATIC_ASSERT

类型定义说明

◆ lmmp_abort_fn

◆ lmmp_heap_alloc_fn

◆ lmmp_heap_free_fn

◆ lmmp_realloc_fn

◆ mp_bitcnt_t

◆ mp_byte_t

◆ mp_limb_t

◆ mp_ptr

◆ mp_size_t

◆ mp_slimb_t

◆ mp_srcptr

◆ mp_ssize_t

◆ static_assert___LINE__

枚举类型说明

◆ lmmp_error_t

函数说明

◆ lmmp_abort()

◆ lmmp_alloc()

◆ lmmp_alloc_count()

◆ lmmp_free()

◆ lmmp_global_deinit()

◆ lmmp_global_init()

◆ lmmp_leak_tracker()

◆ lmmp_realloc()

◆ lmmp_set_abort_fn()

◆ lmmp_set_heap_allocator()

◆ lmmp_stack_deinit()

◆ lmmp_stack_init()

◆ static_assert_LINE