1. MemoryContext介绍

• 合理管理碎片小内存。频繁的向 OS 申请和释放内存效率是很差的。MemoryContext 会以 trunk 为单位向 OS 申请成块的内存，并管理起来。当程序需求小内存时从 trunk 中分配，用完后归还给对应的 MemoryContext ，并不归还给 OS。
• 内存上下文借鉴的操作系统的概念，操作系统为每个进程分配了进程执行环境，进程环境之间不互相影响，由操作系统来对环境进行切换，进程可以在其进程环绕中调用一些库函数(如 malloc free realloc等)来执行内存操作 类似的，一 个内存上下文实际上就相当于一个进程环境， PostgreSQL 以类似的方式提供了在内存上下文进行内存操作的函数:palloc，pfree，repalloc

2. 内存上下文相关的数据类型

2.1 MemoryContext

typedef struct MemoryContextData
{
	NodeTag		type;			/* identifies exact kind of context */
	/* these two fields are placed here to minimize alignment wastage: */
	bool		isReset;		/* T = no space alloced since last reset */
	bool		allowInCritSection; /* allow palloc in critical section */
	MemoryContextMethods *methods;	/* virtual function table */
	MemoryContext parent;		/* NULL if no parent (toplevel context) */
	MemoryContext firstchild;	/* head of linked list of children */
	MemoryContext prevchild;	/* previous child of same parent */
	MemoryContext nextchild;	/* next child of same parent */
	char	   *name;			/* context name (just for debugging) */
	MemoryContextCallback *reset_cbs;	/* list of reset/delete callbacks */
} MemoryContextData;

2.2 AllocSetContex

typedef struct AllocSetContext
{
	MemoryContextData header;	/* Standard memory-context fields */
	/* Info about storage allocated in this context: */
	AllocBlock	blocks;			/* head of list of blocks in this set */
	AllocChunk	freelist[ALLOCSET_NUM_FREELISTS];	/* free chunk lists */
	/* Allocation parameters for this context: */
	Size		initBlockSize;	/* initial block size */
	Size		maxBlockSize;	/* maximum block size */
	Size		nextBlockSize;	/* next block size to allocate */
	Size		allocChunkLimit;	/* effective chunk size limit */
	AllocBlock	keeper;			/* if not NULL, keep this block over resets */
} AllocSetContext;

• header标准的内存上下文区域，即抽象类型MemoryContext（可理解为子类对象中的基类对象的内存区域。），通过这个字段可以区分各内存上下文的层次关系。
• blocks内存块链表，记录内存上下文向操作系统申请的连续大块内存,指向AllocBlockData。它是实际分配内存的地方，AllocSetContext中内存的分配是以Block（块）为单位向OS申请的，多个Block之间以单链表的方式连接起来。此blocks是单链表的头节点，在清除内存上下文时从它开始遍历整个链表，是否所有的Block中的内存。
• freelist组织该内存上下文里所有内存块中已释放的内存片的链表结构。它是一个数组成员，其数组大小是ALLOCSET_NUM_FREELISTS（该值是11）。freelist数组中各成员分别表示不同大小的AllocChunkData。在AllocSetContext的实现中，对于小的内存块（8 ~ 8192Byte）来说，当释放的时候不会归还给OS，而是将其缓存到freelist中。
• initBlockSizeBlock的初始化大小，默认8KB。
• maxBlockSizeBlock的最大大小。
• nextBlockSize下一个Block的大小。
• allocChunkLimit内存片的阈值，申请的内存超过此阀值直接分配新的block。
• keeper为防止一些需要频繁重置的小的内存上下文重复的进行malloc，重置时保留第一次申请的内存块。
• freeListIndex在context_freelists全局数组中的顺序，0表示默认freelist，1表示小内存的freelist，-1表示不需要进入freelist（比如超过allocChunkLimit的Block）。context_freelists的的数据类型是AllocSetFreeList

2.3 AllocBlockData

/*
 * AllocBlock
 *		An AllocBlock is the unit of memory that is obtained by aset.c
 *		from malloc().  It contains one or more AllocChunks, which are
 *		the units requested by palloc() and freed by pfree().  AllocChunks
 *		cannot be returned to malloc() individually, instead they are put
 *		on freelists by pfree() and re-used by the next palloc() that has
 *		a matching request size.
 *
 *		AllocBlockData is the header data for a block --- the usable space
 *		within the block begins at the next alignment boundary.
 */
typedef struct AllocBlockData
{
	AllocSet	aset;			/* aset that owns this block */
	AllocBlock	prev;			/* prev block in aset's blocks list, if any */
	AllocBlock	next;			/* next block in aset's blocks list, if any */
	char	   *freeptr;		/* start of free space in this block */
	char	   *endptr;			/* end of space in this block */
}			AllocBlockData;

2.4 AllocChunkData

/*
 * AllocChunk
 *		The prefix of each piece of memory in an AllocBlock
 */
typedef struct AllocChunkData
{
	/* size is always the size of the usable space in the chunk */
	Size		size;
#ifdef MEMORY_CONTEXT_CHECKING
	/* when debugging memory usage, also store actual requested size */
	/* this is zero in a free chunk */
	Size		requested_size;
#if MAXIMUM_ALIGNOF > 4 && SIZEOF_VOID_P == 4
	Size		padding;
#endif

#endif							/* MEMORY_CONTEXT_CHECKING */

	/* aset is the owning aset if allocated, or the freelist link if free */
	void	   *aset;

	/* there must not be any padding to reach a MAXALIGN boundary here! */
}			AllocChunkData;

2.5 MemoryContextMethods

/*
 * MemoryContext
 *		A logical context in which memory allocations occur.
 *
 * MemoryContext itself is an abstract type that can have multiple
 * implementations, though for now we have only AllocSetContext.
 * The function pointers in MemoryContextMethods define one specific
 * implementation of MemoryContext --- they are a virtual function table
 * in C++ terms.
 *
 * Node types that are actual implementations of memory contexts must
 * begin with the same fields as MemoryContext.
 *
 * Note: for largely historical reasons, typedef MemoryContext is a pointer
 * to the context struct rather than the struct type itself.
 */

typedef struct MemoryContextMethods
{
	void	   *(*alloc) (MemoryContext context, Size size);
	/* call this free_p in case someone #define's free() */
	void		(*free_p) (MemoryContext context, void *pointer);
	void	   *(*realloc) (MemoryContext context, void *pointer, Size size);
	void		(*init) (MemoryContext context);
	void		(*reset) (MemoryContext context);
	void		(*delete_context) (MemoryContext context);
	Size		(*get_chunk_space) (MemoryContext context, void *pointer);
	bool		(*is_empty) (MemoryContext context);
	void		(*stats) (MemoryContext context, int level, bool print,
						  MemoryContextCounters *totals);
#ifdef MEMORY_CONTEXT_CHECKING
	void		(*check) (MemoryContext context);
#endif
} MemoryContextMethods;

    oldcontext = MemoryContextSwitchTo(TopMemoryContext );
    ...
    fctx = palloc(sizeof(directory_fctx));
    ...   
    MemoryContextSwitchTo(oldcontext);
    
    
    //MemoryContextSwitchTo函数实现
    
    MemoryContextSwitchTo(MemoryContext context)
{
    MemoryContext old = CurrentMemoryContext;

    CurrentMemoryContext = context;
    return old;
}

3. 内存上下文的初始化和创建

3.1 初始化内存上下文

void MemoryContextInit(void)
{
 //封装的assert()断言函数的功能, 即AssertState括号中的判别式需要为true
 AssertState(TopMemoryContext == NULL);

 /* 首先, 初始化TopMemoryContext,它是所有其他内存上下文的父节点. */
 TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
            "TopMemoryContext",
            ALLOCSET_DEFAULT_SIZES);

 /* 没有任何其他位置指向 CurrentMemoryContext,请将其指向TopMemoryContext. 调用者应尽快更改此选项！ */
 CurrentMemoryContext = TopMemoryContext;

 /*
 将 ErrorContext 初始化为一个增长速度较慢的 AllocSetContext ——我们并不真正期望在其中分配太多内存.
  更重要的是,要求它在任何时候至少8K. 只有在这种情况下,上下文中的保留内存才是必不可少的——
  我们要确保ErrorContext仍然有一些内存,即使我们在其他地方已经用完了! 此外,
  允许在关键部分的ErrorContext中进行分配.否则,在打印出失败的真正原因之前,
  死机将导致错误报告代码中的断言失败.

 这应该是此函数的最后一步,因为elog.c假设一旦ErrorContext为非空,内存管理器就可以工作.
  */
 ErrorContext = AllocSetContextCreate(TopMemoryContext,
             "ErrorContext",
             8 * 1024,
             8 * 1024,
             8 * 1024);
 MemoryContextAllowInCriticalSection(ErrorContext, true);
}

3.2 内存上下文节点的创建

if (!MyTopMemoryContext){
        MyTopMemoryContext = AllocSetContextCreate(TopMemoryContext,
                                                    "MyTopMemoryContext",
                                                    ALLOCSET_DEFAULT_SIZES);
 }

3.2 内存上下文中内存的分配、重分配和释放

palloc(内存分配)

void *
palloc(Size size)
{
    /* duplicates MemoryContextAlloc to avoid increased overhead */
    void       *ret;

    AssertArg(MemoryContextIsValid(CurrentMemoryContext));
    AssertNotInCriticalSection(CurrentMemoryContext);

    if (!AllocSizeIsValid(size))
        elog(ERROR, "invalid memory alloc request size %zu", size);

    CurrentMemoryContext->isReset = false;
    //调用palloc 实际就是调用 alloc 指向的AllocSetAlloc 函数
    ret = (*CurrentMemoryContext->methods->alloc) (CurrentMemoryContext, size);
    if (ret == NULL)
    {
        MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed on request of size %zu.", size)));
    }

    VALGRIND_MEMPOOL_ALLOC(CurrentMemoryContext, ret, size);

    return ret;
}

AllocSetAlloc(内存分配)

• 函数AllocSetAlloc负责处理具体的内存分配工作，该函数的参数为一个内存上下文节点以及需要申请的内存大小。
• AllocSetAlloc为内存片分配空间时并不是严格按照申请的大小来分配的，而是将申请的大小向上对齐为2的幂，然后按照对齐的大小来分配空间。例如，我们要申请一块大小 30 字节的空间，则 AllocSetAlloc实际会为我们分配1块大小为 2^5=32 节的内存片。 该内存片对应的AlloChunkData 中的 size 段设置为 32 ，而 requested_size 设置为 30。

repalloc(内存重分配)

释放内存上下文

• 释放1个内存上下文中指定的内存片

• 重置内存上下文

• 释放当前内存上下文中的全部内存块