uclibc中malloc-simple实现分析

首先看一下目录结构： uClibc\libc\stdlib\malloc-simple

然后看一下目录下的文件：

每个文件的作用从名字就很容易看出来，打开这几个文件发现，除了alloc.c文件所有的文件只是简单的包含了 #include "alloc.c"，因此实现部分集中在 alloc.c一个文件中，看到这里心里算是轻松了许多  : - ) 

现在把整个文件贴出来，慢慢分析：

/* alloc.c

*

* Copyright (C) 2000-2006 Erik Andersen < andersen@uclibc.org >

*

* 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

可以看出这种实现方式实在是太简单了，不过它的缺点也是蛮多的，每次分配和释放内存都得直接调用系统调用，我们都知道系统调用代价是极大的，这极大的降低了系统的性能