static tlsf_t sTLSF = nullptr;
......
extern "C" void InitMemory() {
#if USE_POOL
	if (sTLSF == nullptr) {
		void*buffer = malloc(mReservedSize);
		sTLSF = tlsf_create_with_pool(buffer, mReservedSize);
	}
#endif
}

static void*GetMemory(size_t size) {
	if (sTLSF==nullptr){
		InitMemory();
	}
	void * ptrMemory = tlsf_malloc(sTLSF, size);
	while (ptrMemory == nullptr) {
		void*add_pool = malloc(104857600);//100MB
		tlsf_add_pool(sTLSF, add_pool, 104857600);
		ptrMemory = tlsf_malloc(sTLSF, size);
	}
	return ptrMemory;
}

tlsf_t tlsf_create_with_pool(void* mem, size_t bytes)
{
	// mem是直接malloc出来的，没做偏移
	tlsf_t tlsf = tlsf_create(mem);
	// (char*)mem + tlsf_size() 原始位置做Controller大小的偏移，size也是一样，减去Controller的大小
	tlsf_add_pool(tlsf, (char*)mem + tlsf_size(), bytes - tlsf_size());
	return tlsf;
}

tlsf_t tlsf_create(void* mem)
{
#if _DEBUG
	if (test_ffs_fls())
	{
		return 0;
	}
#endif

	if (((tlsfptr_t)mem % ALIGN_SIZE) != 0)
	{
		printf("tlsf_create: Memory must be aligned to %u bytes.\n",
			(unsigned int)ALIGN_SIZE);
		return 0;
	}
	// mem是直接malloc出来的，没做偏移
	control_construct((control_t*)mem);

	return (tlsf_t*)mem;
}

/* The TLSF control structure. */
typedef struct control_t
{
	/* Empty lists point at this block to indicate they are free. */
	block_header_t block_null;

	/* Bitmaps for free lists. */
	unsigned int fl_bitmap;
	unsigned int sl_bitmap[FL_INDEX_COUNT];

	/* Head of free lists. */
	block_header_t* blocks[FL_INDEX_COUNT][SL_INDEX_COUNT];//segrageted lists
} control_t;

---------------------------------------

/* Clear structure and point all empty lists at the null block. */
// 在内存最前面初始化了control_t
static void control_construct(control_t* control)
{
	int i, j;

	control->block_null.next_free = &control->block_null;
	control->block_null.prev_free = &control->block_null;

	control->fl_bitmap = 0;
	for (i = 0; i < FL_INDEX_COUNT; ++i)
	{
		control->sl_bitmap[i] = 0;
		for (j = 0; j < SL_INDEX_COUNT; ++j)
		{
			control->blocks[i][j] = &control->block_null;
		}
	}
}

// (char*)mem + tlsf_size() 原始位置做Controller大小的偏移，size也是一样，减去Controller的大小
tlsf_add_pool(tlsf, (char*)mem + tlsf_size(), bytes - tlsf_size());

------------------------------------------------------------------------------------------------

/*
** Since block sizes are always at least a multiple of 4, the two least
** significant bits of the size field are used to store the block status:
** - bit 0: whether block is busy or free
** - bit 1: whether previous block is busy or free
*/
static const size_t block_header_free_bit = 1 << 0;//0
static const size_t block_header_prev_free_bit = 1 << 1;//1   1：free 0：busy

------------------------------------------------------------------------------------------------

pool_t tlsf_add_pool(tlsf_t tlsf, void* mem, size_t bytes)
{
	block_header_t* block;
	block_header_t* next;

	// 额外的  2 * sizeof(size_t) 字节，在头部留下的
	const size_t pool_overhead = tlsf_pool_overhead();
	// 字节对齐后的空间大小 pool_bytes = malloc - sizeof(control_t) - pool_overhead 
	const size_t pool_bytes = align_down(bytes - pool_overhead, ALIGN_SIZE);

	if (((ptrdiff_t)mem % ALIGN_SIZE) != 0)
	{
		printf("tlsf_add_pool: Memory must be aligned by %u bytes.\n",
			(unsigned int)ALIGN_SIZE);
		return 0;
	}

	// 最大1G
	if (pool_bytes < block_size_min || pool_bytes > block_size_max)
	{
#if defined (TLSF_64BIT)
		printf("tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n", 
			(unsigned int)(pool_overhead + block_size_min),
			(unsigned int)((pool_overhead + block_size_max) / 256));
#else
		printf("tlsf_add_pool: Memory size must be between %u and %u bytes.\n", 
			(unsigned int)(pool_overhead + block_size_min),
			(unsigned int)(pool_overhead + block_size_max));
#endif
		return 0;
	}

	/*
	** Create the main free block. Offset the start of the block slightly
	** so that the prev_phys_block field falls outside of the pool -
	** it will never be used.
	*/
  // 这里会减去-4byte，因为对于第一个block，prev_phys没有意义
	block = offset_to_block(mem, -(tlsfptr_t)block_header_overhead);//((char*)mem-4)
	block_set_size(block, pool_bytes);
	block_set_free(block);
	block_set_prev_used(block);
	block_insert(tlsf_cast(control_t*, tlsf), block);

	/* Split the block to create a zero-size sentinel block. */
	next = block_link_next(block);
	block_set_size(next, 0);
	block_set_used(next);
	block_set_prev_free(next);

	return mem;
}

/* Return location of next block after block of given size. */
static block_header_t* offset_to_block(const void* ptr, size_t size)
{
	return tlsf_cast(block_header_t*, tlsf_cast(tlsfptr_t, ptr) + size);
}

static void block_set_size(block_header_t* block, size_t size)
{
	const size_t oldsize = block->size;

	// oldsize & 0000 0000 0000 0011 ,变相的等于把size最后两位过滤出来，然后与size做或操作，等于把旧数据写入新的size最后两位
	// e.g.：oldsize如果后面两位是1（前面一个block空闲）0（自己忙碌），那么无论new size第二位是怎么记录的，都会把1保留下来，也就是会保留前一个block的状态。
	block->size = size | (oldsize & (block_header_free_bit | block_header_prev_free_bit));
}

static void block_set_free(block_header_t* block)
{
  // block_header_free_bit = 1，与操作相当于无脑把size 0位上写入1，也就是free
	block->size |= block_header_free_bit;
}

static void block_set_prev_used(block_header_t* block)
{
	block->size &= ~block_header_prev_free_bit;
}

/* Insert a given block into the free list. */
static void block_insert(control_t* control, block_header_t* block)
{
	int fl, sl;
	mapping_insert(block_size(block), &fl, &sl);
	insert_free_block(control, block, fl, sl);
}

static void mapping_insert(size_t size, int* fli, int* sli)
{
	int fl, sl;
	if (size < SMALL_BLOCK_SIZE)
	{
		/* Store small blocks in first list. */
		fl = 0;
		sl = tlsf_cast(int, size) / (SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
	}
	else
	{
		fl = tlsf_fls_sizet(size);//find last set
		sl = tlsf_cast(int, size >> (fl - SL_INDEX_COUNT_LOG2)) ^ (1 << SL_INDEX_COUNT_LOG2);
		fl -= (FL_INDEX_SHIFT - 1);
	}
	*fli = fl;
	*sli = sl;
}

static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl)
{
	block_header_t* current = control->blocks[fl][sl];
	tlsf_assert(current && "free list cannot have a null entry");
	tlsf_assert(block && "cannot insert a null entry into the free list");
	block->next_free = current;
	block->prev_free = &control->block_null;
	current->prev_free = block;

	tlsf_assert(block_to_ptr(block) == align_ptr(block_to_ptr(block), ALIGN_SIZE)
		&& "block not aligned properly");
	/*
	** Insert the new block at the head of the list, and mark the first-
	** and second-level bitmaps appropriately.
	*/
	control->blocks[fl][sl] = block;
	control->fl_bitmap |= (1 << fl);
	control->sl_bitmap[fl] |= (1 << sl);
}

static void block_set_used(block_header_t* block)
{
  // 取反为1111 1111 1111 1101
  // 与操作最终值看size本身的30位，等于保留size值，但是第二位是0 & X ，必然等于0。也就是把第二位置为0 了
	block->size &= ~block_header_free_bit;
}

#define offsetof(s,m) ((size_t)&(((s*)0)->m))

// 这里block_start_offset = 4+4 = 8
static const size_t block_start_offset =
	offsetof(block_header_t, size) + sizeof(size_t);

// 这里等于把block向后偏移8字节，然后转成了void*
static void* block_to_ptr(const block_header_t* block)
{
	return tlsf_cast(void*,
		tlsf_cast(unsigned char*, block) + block_start_offset);
}

/* Return location of next block after block of given size. */
static block_header_t* offset_to_block(const void* ptr, size_t size)
{
	return tlsf_cast(block_header_t*, tlsf_cast(tlsfptr_t, ptr) + size);
}

/* Return location of next existing block. */
static block_header_t* block_next(const block_header_t* block)
{
	block_header_t* next = offset_to_block(block_to_ptr(block),block_size(block) - block_header_overhead);
	tlsf_assert(!block_is_last(block));
	return next;
}

/* Link a new block with its physical neighbor, return the neighbor. */
static block_header_t* block_link_next(block_header_t* block)
{
	block_header_t* next = block_next(block);
	next->prev_phys_block = block;
	return next;
}

block_set_size(next, 0);
block_set_used(next);
block_set_prev_free(next);