首先看一下目录结构:
uClibc\libc\stdlib\malloc-simple
然后看一下目录下的文件:
每个文件的作用从名字就很容易看出来,打开这几个文件发现,除了alloc.c文件所有的文件只是简单的包含了
#include "alloc.c",因此实现部分集中在
alloc.c一个文件中,看到这里心里算是轻松了许多
: - )
现在把整个文件贴出来,慢慢分析:
/* alloc.c
*
*
* Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
*/
/*
* Parts of the memalign code were stolen from malloc-930716.
*/
#include <features.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/mman.h>
#include <malloc.h>
#ifdef L_malloc
void *malloc(size_t size)
{
void *result;
if (unlikely(size == 0)) {
#if defined(__MALLOC_GLIBC_COMPAT__)
//和glibc实现兼容,这size=0,则分配一个字节
size++;
#else
/* Some programs will call malloc (0). Lets be strict and return NULL */
__set_errno(ENOMEM);
return NULL;
#endif
}
#ifdef __ARCH_USE_MMU__
# define MMAP_FLAGS MAP_PRIVATE | MAP_ANONYMOUS
#else
# define MMAP_FLAGS MAP_SHARED | MAP_ANONYMOUS | MAP_UNINITIALIZE
#endif
result = mmap((void *) 0, size + sizeof(size_t), PROT_READ | PROT_WRITE,
MMAP_FLAGS, 0, 0);
//物理地址起始地址设置为0,则由操作系统自己决定映射到的物理地址起始,大小加上4字节,用于存放分配的内存大小,映射标志设置为匿名映射
if (result == MAP_FAILED)
return 0;
* (size_t *) result = size;
//头4个字节存放分配的内存大小
return(result + sizeof(size_t));
//返回偏移4个字节头后的内存地址
}
#endif
#ifdef L_calloc
void * calloc(size_t nmemb, size_t lsize)
{
void *result;
size_t size=lsize * nmemb;
/* guard vs integer overflow, but allow nmemb
* to fall through and call malloc(0) */
if (nmemb && lsize != (size / nmemb)) {
__set_errno(ENOMEM);
return NULL;
}
result = malloc(size);
#ifndef __ARCH_USE_MMU__
/* mmap'd with MAP_UNINITIALIZE, we have to blank memory ourselves */
if (result != NULL) {
memset(result, 0, size);
}
#endif
return result;
}
#endif
#ifdef L_realloc
void *realloc(void *ptr, size_t size)
{
void *newptr = NULL;
if (!ptr)
return malloc(size);
if (!size) {
free(ptr);
return malloc(0);
}
newptr = malloc(size);
//分配new的内存大小
if (newptr) {
size_t old_size = *((size_t *) (ptr - sizeof(size_t)));
//获取old内存的大小
memcpy(newptr, ptr, (old_size < size ? old_size : size));
//将old内存的内存复制到new的内存
free(ptr);
//释放掉old内存
}
return newptr;
}
#endif
#ifdef L_free
extern int weak_function __libc_free_aligned(void *ptr);
void free(void *ptr)
{
if (unlikely(ptr == NULL))
return;
if (unlikely(__libc_free_aligned != NULL)) {
if (__libc_free_aligned(ptr))
//首先尝试释放未对齐的内存,如果成功则直接返回
return;
}
ptr -= sizeof(size_t);
munmap(ptr, * (size_t *) ptr + sizeof(size_t));
//直接
void munmap(void *addr, size_t length)
}
#endif
#ifdef L_memalign
#include <bits/uClibc_mutex.h>
__UCLIBC_MUTEX_INIT(__malloc_lock, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP);
#define __MALLOC_LOCK __UCLIBC_MUTEX_LOCK(__malloc_lock)
#define __MALLOC_UNLOCK __UCLIBC_MUTEX_UNLOCK(__malloc_lock)
/* List of blocks allocated with memalign or valloc */
struct alignlist
{
struct alignlist *next;
__ptr_t aligned; /* The address that memaligned returned. */
__ptr_t exact; /* The address that malloc returned. */
};
struct alignlist *_aligned_blocks;
//未初始化的全局变量放在BSS段中,所以它的值为0,即NULL
/* Return memory to the heap. */
int __libc_free_aligned(void *ptr)
//释放对齐的内存
{
struct alignlist *l;
if (ptr == NULL)
return 0;
__MALLOC_LOCK;
for (l = _aligned_blocks; l != NULL; l = l->next) {
if (l->aligned == ptr) {
/* Mark the block as free */
l->aligned = NULL;
//保持节点
ptr = l->exact;
ptr -= sizeof(size_t);
munmap(ptr, * (size_t *) ptr + sizeof(size_t));
return 1;
}
}
__MALLOC_UNLOCK;
return 0;
}
void * memalign (size_t alignment, size_t size)
//分配对齐的内存
{
void * result;
unsigned long int adj;
result = malloc (size + alignment - 1);
if (result == NULL)
return NULL;
adj = (unsigned long int) ((unsigned long int) ((char *) result - (char *) NULL)) % alignment;
if (adj != 0) {
//分配到的内存是未对齐的
struct alignlist *l;
__MALLOC_LOCK;
// 上锁,防止线程并发访问腐化链表数据
for (l = _aligned_blocks; l != NULL; l = l->next)
//寻找空闲节点
if (l->aligned == NULL)
/* This slot is free. Use it. */
break;
if (l == NULL) {
l = (struct alignlist *) malloc (sizeof (struct alignlist));
if (l == NULL) {
free(result);
result = NULL;
goto DONE;
}
l->next = _aligned_blocks;
//新增加的节点放在头部
_aligned_blocks = l;
}
l->exact = result;
//实际分配到的内存地址
result = l->aligned = (char *) result + alignment - adj;
//对齐后的内存地址
DONE:
__MALLOC_UNLOCK;
}
return result;
}
#endif
可以看出这种实现方式实在是太简单了,不过它的缺点也是蛮多的,每次分配和释放内存都得直接调用系统调用,我们都知道系统调用代价是极大的,这极大的降低了系统的性能