goahead源码分析---块内存分配--balloc.c文件

最新推荐文章于 2022-05-27 14:58:12 发布
最新推荐文章于 2022-05-27 14:58:12 发布
阅读量1.7k 收藏 4
点赞数 1
分类专栏： WEB 文章标签： balloc goahead
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xueqi_114/article/details/8299971
版权
到目前为止,个人发现的goahead的一个特点：
1、函数执行过程中需要的缓冲区都不是由外部提供的，而是什么时候需要什么时候申请，用完后释放，如果申请的内存存放了调用者需要的信息，则将这块内存的地址通过参          数 传出去，同时由调用者负责释放。

2、在HTTP请求等地方频繁的进行了内存的申请和分配。


也许系统的malloc函数有种种缺点，goahead提供了自己的块内存分配函数，其核心文件为balloc.c文件。其设计思想如下:

1.该模块不是用来替代整个系统的内存的管理,他只用来管理程序中指定的一块内存Mem,这块内存可以是动态分配的,也可以是一个大的数组.
2.该模块以块为单位来管理内存,块的大小为16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536.分配时不时你申请多次就分配多少,而是分配一个满足你       申请的大小的最小的块.
3.这些以块为单位的内存并不是一开始就存在的,而是你申请时从Mem中划分出来,只是在你释放的时候并不返还给Mem,返还给管理模块,逐步建立起来不同的块.

4.对于大于最大块的内存,管理模块根据配置来决定是动态分配还是返回分配失败


基于上面所述,要解决如下的问题:


1.必须跟踪Mem的使用情况.系统定义了如下变量来跟踪 
static char				*bFreeBuf;				/* Pointer to free memory */
static char				*bFreeNext;				/* Pointer to next free mem */
static int				bFreeSize;				/* Size of free memory */
static int				bFreeLeft;				/* Size of free left for use */


bFreeBuf在初始化的时候指向Mem,bFreeSize记录Mem的大小,bFreeLeft永远指向剩余内存的起始地址,bFreeLeft记录剩余内存的大小.


2.如何描述块内存,同时如何区分已分配的一块内存是来自管理模块分配的块还是动态分配的.系统定义了如下结构体 

typedef struct {
	union {
		void	*next;							/* Pointer to next in q */
		int		size;							/* Actual requested size */
	} u;
	int			flags;							/* Per block allocation flags */
} bType;



size用来记录该块的大小(不包括管理块用的内存)
flags用来记录该块的特性,动态分配的还是块内存等.
next用来形成链表.


3.如何管理这些块
这个比较简单,将相同大小的块用next域形成链表,再定义一个数组指向不同块大小的链表的第一个元素. 
static bType			*bQhead[B_MAX_CLASS];	/* Per class block q head */

bQhead就是那个数组,整体结构如下图






该模块不适用于多线程，同时假定新定义的变量初值为0.



1.模块打开函数


//参数说明:
//buf:用户指定的一块缓冲区,如果为NULL，则函数根据flags标志来决定是否自己分配
//bufsize:传入的缓冲区大小
//flags:程序中使用的为B_USE_MALLOC，允许分配内存
int bopen(void *buf, int bufsize, int flags)
{
	bFlags = flags;


	//初始化一个随机数产生器函数 不知道做什么用的
	#ifdef BASTARD_TESTING
	srand(time(0L));
	#endif /* BASTARD_TESTING */


/*
 * If bopen already called by a shared process, just increment the count
 * and return;
 */
	if (++bopenCount > 1) {
	return 0;
	}
	//如果传入的为NULL且大小为0则函数自己分配一个默认大小的内存块
	if (buf == NULL) {
		if (bufsize == 0) {
			bufsize = B_DEFAULT_MEM;
		}
//IRIX是一个操作系统 其内存要求4字节对齐
#ifdef IRIX
		bufsize = ROUNDUP4(bufsize);
#endif
		if ((buf = malloc(bufsize)) == NULL) {
         /* resetting bopenCount lets client code decide to attempt to call
          * bopen() again with a smaller memory request, should it desire to.
          * Fix suggested by Simon Byholm.
          */
         		--bopenCount;
			return -1;
		}
//记录动态分配内存的总大小，用于统计内存时使用
#ifdef B_STATS
		bStatsMemMalloc += bufsize;
#endif
	} else {
		bFlags |= B_USER_BUF;
	}


	//对于要管理的内存有总大小记录，剩余大小记录
	bFreeSize = bFreeLeft = bufsize;
	//bFreeBuf为要管理的内存块的起始地址 bFreeNext 为剩余内存的起始地址
	bFreeBuf = bFreeNext = buf;
	//对相同大小的块构成一个链表，bQhead中的每一个元素指向相应大小的可用链表的第一个块
	memset(bQhead, 0, sizeof(bQhead));
	//为了调试，可以填充分配的缓冲区为指定值
#if (defined (B_FILL) || defined (B_VERIFY_CAUSES_SEVERE_OVERHEAD))
	bFillBlock(buf, bufsize);
#endif
//不知道用处
#ifdef B_STATS
	bStackStart = &buf;
#endif
#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
	//wzf? 此处调用此函数会有问题
	verifyFreeBlock(buf, bufsize);
#endif
	return 0;
}


2.该模块的关闭操作，当应用程序退出时调用 

void bclose()
{
#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
	verifyBallocSpace();
#endif
	if (--bopenCount <= 0 && !(bFlags & B_USER_BUF)) {
		free(bFreeBuf);
		bopenCount = 0;
	}
}


3.内存的分配
先放一张流程图 





//参数说明：
//B_ARGS_DEC：该宏展开后为一个字符指针，一个整形参数，用来传入调用者所在的文件和行号
//size:请求内存的大小
//对比流程如图，比较容易理解
void *balloc(B_ARGS_DEC, int size)
{
	bType	*bp;
	int		q, memSize;

/*
 *	Call bopen with default values if the application has not yet done so
 */
	//如果没有调用过bopen函数，则在第一次使用时调用
	if (bFreeBuf == NULL) {
		if (bopen(NULL, B_DEFAULT_MEM, 0) < 0) {
			return NULL;
		}
	}
	//验证分配的内存是否有问题
#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
	verifyBallocSpace();
#endif
	//检查请求的内存大小是否合法
	if (size < 0) {
		return NULL;
	}

	//应该是用来模拟分配失败的情况
#ifdef BASTARD_TESTING
	if (rand() == 0x7fff) {
		return NULL;
	}
#endif /* BASTARD_TESTING */

	//计算满足请求大小的最小的内存块大小和加上管理开销后的总内存大小
	memSize = ballocGetSize(size, &q);

	//如果块的大小大于最大管理的块大小则根据配置来决定是否动态分配内存
	if (q >= B_MAX_CLASS) {
/*
 *		Size if bigger than the maximum class. Malloc if use has been okayed
 */
		//允许动态分配内存
		if (bFlags & B_USE_MALLOC) {
#ifdef B_STATS
			bstats(0, NULL);
#endif
#ifdef IRIX
			memSize = ROUNDUP4(memSize);
#endif
			bp = (bType*) malloc(memSize);
			if (bp == NULL) {
				traceRaw(T("B: malloc failed\n"));
				return NULL;
			}
#ifdef B_STATS
			bStatsMemMalloc += memSize;
#endif
#if (defined (B_FILL) || defined (B_VERIFY_CAUSES_SEVERE_OVERHEAD))
			bFillBlock(bp, memSize);
#endif

		} else {
			//不允许动态分配则直接返回失败
			traceRaw(T("B: malloc failed\n"));
			return NULL;
		}

/*
 *		the u.size is the actual size allocated for data
 */
		bp->u.size = memSize - sizeof(bType);
		bp->flags = B_MALLOCED;

	} else if ((bp = bQhead[q]) != NULL) {
		//需要的内存在管理的范围之内且有可用块
/*
 *		Take first block off the relevant q if non-empty
 */
		bQhead[q] = bp->u.next;
#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
		verifyFreeBlock(bp, q);
#endif
#if (defined (B_FILL) || defined (B_VERIFY_CAUSES_SEVERE_OVERHEAD))
		bFillBlock(bp, memSize);
#endif
		bp->u.size = memSize - sizeof(bType);
		bp->flags = 0;

	} else {
		//需要的块大小在管理的范围内但是当前没有可用的块，如果剩余的可分配内存足够则从剩余内存中划分
		if (bFreeLeft > memSize) {
/*
 *			The q was empty, and the free list has spare memory so 
 *			create a new block out of the primary free block
 */
			bp = (bType*) bFreeNext;
#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
			verifyFreeBlock(bp, q);
#endif
			bFreeNext += memSize;
			bFreeLeft -= memSize;
#if (defined (B_FILL) || defined (B_VERIFY_CAUSES_SEVERE_OVERHEAD))
			bFillBlock(bp, memSize);
#endif
			bp->u.size = memSize - sizeof(bType);
			bp->flags = 0;

		} else if (bFlags & B_USE_MALLOC) {
			//如果剩余内存不够但允许动态分配则动态分配
#ifdef B_STATS
			static int once = 0;
			if (once++ == 0) {
				bstats(0, NULL);
			}
#endif
/*
 *			Nothing left on the primary free list, so malloc a new block
 */
#ifdef IRIX
			memSize = ROUNDUP4(memSize);
#endif
			if ((bp = (bType*) malloc(memSize)) == NULL) {
				traceRaw(T("B: malloc failed\n"));
				return NULL;
			}
#ifdef B_STATS
			bStatsMemMalloc += memSize;
#endif
#if (defined (B_FILL) || defined (B_VERIFY_CAUSES_SEVERE_OVERHEAD))
			bFillBlock(bp, memSize);
#endif
			bp->u.size = memSize - sizeof(bType);
			bp->flags = B_MALLOCED;

		} else {
			traceRaw(T("B: malloc failed\n"));
			return NULL;
		}
	}

#ifdef B_STATS
	bStatsAlloc(B_ARGS, bp, q, memSize);
#endif
	bp->flags |= B_INTEGRITY;

/*
 *	The following is a good place to put a breakpoint when trying to reduce
 *	determine and reduce maximum memory use.
 */
#if 0
#ifdef B_STATS
	if (bStatsBallocInUse == bStatsBallocMax) {
		bstats(0, NULL);
	}
#endif
#endif
	return (void*) ((char*) bp + sizeof(bType));
}



4.释放一个不再使用的内存块给管理模块 

	a_assert((bp->flags & B_INTEGRITY_MASK) == B_INTEGRITY);

	if ((bp->flags & B_INTEGRITY_MASK) != B_INTEGRITY) {
		return;
	}

	memSize = ballocGetSize(bp->u.size, &q);

#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
	verifyUsedBlock(bp,q);
#endif
#ifdef B_STATS
	bStatsFree(B_ARGS, bp, q, bp->u.size+sizeof(bType));
#endif
	if (bp->flags & B_MALLOCED) {
		free(bp);
		return;
	}
		
#ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
	bFillBlock(bp, memSize);
#endif

/*
 *	Simply link onto the head of the relevant q
 */
	bp->u.next = bQhead[q];
	bQhead[q] = bp;

	bp->flags = B_FILL_WORD;
}

5.安全释放函数

这个没什么要说的,主要是检查了下指针是否为空,不为空则调用释放函数

void bfreeSafe(B_ARGS_DEC, void *mp)
{
	if (mp) {
		bfree(B_ARGS, mp);
	}
}

6.在UNICODE编码下复制一个字符串 

char *bstrdupA(B_ARGS_DEC, char *s)
{
	char	*cp;
	int		len;

	if (s == NULL) {
		s = "";
	}
	len = strlen(s) + 1;
	//分配一块空间,拷贝字符串
	if (cp = balloc(B_ARGS, len)) {
		strcpy(cp, s);
	}
	return cp;
}

7.重新分配一块内存

重新分配一块较大的内存,并将原来内存中的数据拷贝到新内存中.

要注意的是模块是按块分配的,有可能已分配的内存也满足新请求的大小,此时直接返回原来的内存就可以

void *brealloc(B_ARGS_DEC, void *mp, int newsize)
{
	bType	*bp;
	void	*newbuf;

	//如果是空指针,直接分配返回
	if (mp == NULL) {
		return balloc(B_ARGS, newsize);
	}
	//找到管理数据所在的位置
	bp = (bType*) ((char*) mp - sizeof(bType));
	a_assert((bp->flags & B_INTEGRITY_MASK) == B_INTEGRITY);

/*
 *	If the allocated memory already has enough room just return the previously
 *	allocated address.
 */
	//如果当前块已经满足则返回
	if (bp->u.size >= newsize) {
		return mp;
	}
	//分配新内存,然后拷贝数据
	if ((newbuf = balloc(B_ARGS, newsize)) != NULL) {
		memcpy(newbuf, mp, bp->u.size);
		bfree(B_ARGS, mp);
	}
	return newbuf;
}

8.由块大小计算出其包含管理数据的大小,和该块在bQhead数组中的位置

static int ballocGetSize(int size, int *q)
{
	int	mask;

	//计算
	mask = (size == 0) ? 0 : (size-1) >> B_SHIFT;//B_SHIFT为4  宏定义
	for (*q = 0; mask; mask >>= 1) {
		*q = *q + 1;
	}
	return ((1 << (B_SHIFT + *q)) + sizeof(bType));
}

9.将内存填充为固定值,方便调试和检查 

static void bFillBlock(void *buf, int bufsize)
{
	memset(buf, B_FILL_CHAR, bufsize);
}


还差一点内存使用统计和一些小函数
---------未完待续------


雪琦
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
goahead源码解析（一） 从主函数到I/O事件循环
chenlonglong2014的博客
08-20 3448
goahead是一个成熟的嵌入式WEB服务器，在未来物联网行业中，相信可以发挥更大的作用。我们刚买路由器的时候，通常需要连接网线登陆一个页面配置路由器IP，WIFI密码，这个就是嵌入式WEB服务器的一个应用。
goAhead 源码解析
02-26
goAhead 的源码解析,比较详细的描述了源码，对初学者有点帮助。
转载goahead webserver源码分析
weixin_30364325的博客
02-02 182
1.一个txt文本架构图 main() | |--websOpenServer() | |-- websOpenListen() | |--socketOpenConnection() |...
goahead源码分析
12-03
goahead_webserver源码分析
GoAhead2.5源代码分析之5-块分配模块（h.c和balloc.c）
weixin_33738578的博客
12-22 172
h.c和balloc.c int hAlloc(void ***map) 功能：分配使用的map数组 说明： -----------------------------------------------------------------------------------------------------------------   int hFree(void ***map...
前端大厂最新面试题-Buffer.docx
最新发布
06-06
2. Buffer.alloc()：创建一个指定大小的 Buffer 对象，例如：`const bAlloc1 = Buffer.alloc(10)`。 Buffer 的编码和解码： 1. Buffer 支持多种编码格式，包括 ascii、utf8、utf16le、ucs2、base64 和 latin 等。 ...
操作系统实验文件系统设计.doc
12-22
（5）磁盘块分配函数balloc()：用于分配磁盘块。 （6）磁盘块释放函数bfree()：用于释放磁盘块。 （7）分配i 节点区函数ialloc()：用于分配i 节点区。 （8）释放i 节点区函数ifree()：用于释放i 节点区。 （9）...
模拟UNIX文件系统的设计及实现
03-28
7. `balloc()`：分配空闲磁盘块，若无空闲块则从文件读取，更新超级块的空闲块信息。 8. `bfree()`：回收磁盘块，更新空闲块栈和超级块信息，当栈满时写回文件。 9. `_dir()`：显示目录内容，遍历目录结构，显示...
sun公司的设备驱动编程
08-14
9. **内存管理**：理解和使用Bcopy、Bzero、Balloc等内核级别的内存操作函数，以确保高效且无泄漏的内存使用。 10. **API与系统调用**：熟悉Solaris提供的设备驱动开发API，如ioctl和read/write系统调用，以及如何...
goahead 源码结构分析
风曲的博客
12-24 2425
源码结构： -------------------------------------------------------------------------------------- MAIN(goahead, int argc, char **argv, char **envp) -------------------------------------初始化过程开始-------------...
goahead代码分析
06-13
goahead小型服务的代码分析，源码官网提供，适合应用于嵌入式开发。
goahead2.5
03-09
goahead2.5, 2011.3.9号最新的版本
goahead嵌入式Web服务器源码解析(内存映射图，hash算法，事件调度)
xiyuan255的博客
04-29 812
Sym(hash)和callback的内存映射关系图： 说明：Sym和Callbacks指向的主映射表是不同，这里只是为了方便画在一起。并且在主映射表的有效单元是可以出现多个Sym或Callbacks，或者任何void *类型的对象类型指针。主映射表是以16个单元为增量进行递增的，且每个单元为一个void *类型的长度，在32位操作系统上为4个字节。 HashTable的存储和算法...
goahead源码解析(三)-------初始化服务器（websOpen函数）
weixin_44074105的博客
05-24 1087
websOpen函数的源码和解析
goahead-3.3.6源码分析
Ataraxia的专栏
09-21 1327
主要分为访问网页文件以及接口的调用逻辑 首先网页访问流程：网页访问事件注册 程序中需要返回html网页文件已经相关的图片、css等资源上面的流程是直接使用websDefineHandler来把响应网页访问的事务添加到事务表，具体的网页文件返回的逻辑则在fileHandler函数中处理// fileHandler函数判断和处理需要返回到浏览器的html文件数据 static bool fileHan
goahead源码解析(二)---------MAIN函数
weixin_44074105的博客
05-23 768
goahead MAIN函数详解
goahead源码解析(五)---------整体的任务执行流程
weixin_44074105的博客
05-27 1151
goahead框架讲解
balloc.c分析（一）
weixin_45742312的博客
11-02 465
2021SC@SDUSC balloc.c是和block分配有关的文件，block和inode是文件系统最基础的部分，所以balloc.c会涉及很多底层内容。 在文件的开始定义了一个宏，用来判断参数b是否在参数(first)-(first+len-1)这段内存中。 #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1) 下...
balloc.c分析（二）
weixin_45742312的博客
11-09 777
2021SC@SDUSC ext2_try_to_allocate的作用是尝试在给定的范围内分配块，参数group为给定的分配块组，grp_goal是给定组内的目标块，count是分配的块的目标数量。首先设置块的分配范围start到end，然后如果我们有一个窗口，我们在预留窗口内进行分配重设start和end的值，并且判断grp_goal是否在分配范围中，不在则grp_goal设为-1。然后判断grp_goal是否小于0，是则调用find_next_usable_block在分配范围中找到一...
讲解一个Linux内核文件系统源码
03-28
balloc.c文件实现了ext4文件系统的块分配器，主要负责分配和释放数据块。它包括多个函数，其中比较重要的有： - ext4_new_blocks：分配一个或多个数据块。 - ext4_free_blocks：释放一个或多个数据块。 dir.c dir...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值