2. 程式人生 > >c語言介面與實現--再論記憶體管理含例項

c語言介面與實現--再論記憶體管理含例項

阿新 • • 發佈：2019-01-06

本章開頭指出上一章節描述的記憶體管理方法存在一些缺陷，比如不適合頻繁建立和銷燬記憶體的應用場景；所以在本章重新給出了另外一種設計思路。提出了記憶體池的概念，如果熟悉的小夥伴，還接觸過執行緒池的概念。個人認為這一章節比前一章節更好理解。

本書中的程式碼有個地方的設計容易讓人誤解，在標頭檔案中程式碼如下

#ifndef ARENA_INCLUDED
#define ARENA_INCLUDED

#include "except.h"

#define T Arean_T
// T* 和T名字一樣，這樣設計讓人費解
typedef struct T *T;

extern const Except_T Arena_NewFailed;
extern
 
 const Except_T Arena_Failed;

extern T Arean_new (void);
extern void Arena_dispose(T *ap);

extern void *arena_alloc(T arena, long nbytes, const char *file, int line);
extern void *Arena_calloc(T arena, long count, long nbytes, const char *file, int line);

extern void Arena_free(T arena);


#endif

在原始檔arena.c中也有巨集定義

#define T Arena_T

這樣就不容易分清楚程式碼中T是如何替換的，核對書中給的程式碼，可以看出凡是T前面含struct的則會用巨集定義替代，即Arena_T，凡是無struct的會被typedef struct T* T替代，如下程式碼所示

struct T 
{
    T prev; // 這裡的T，由typedef struct T* T替代
            // 替換後為 Arena_T * prev;
    char *avail;
    char *limit;
};

union header 
{
    struct
 
 T b; // 這裡的T會被#define T Arena_T替代
                // 替代後為struct Arena_T b;
    union align a;
};

而且gcc編譯器，建立結構體後定義結構體變數時如果不加struct會報錯，如下面舉例程式碼

struct st_tmp
{
    int idata;
};

// 有的gcc編譯器在缺少struct的情況下會報錯
static st_tmp tmp_a;
static struct st_tmp tmp_b;

所以在書中給的程式碼進一步驗證，如果不帶struct，則由struct T *替代，而T則再次替換為Arena_T替換。

替換後的標頭檔案為
arena_l.h

#ifndef ARENA_INCLUDED
#define ARENA_INCLUDED

#include "../../include/except.h"

#define T Arena_T
typedef struct T* PT;


extern const struct Except_T Arena_NewFailed;
extern const struct Except_T Arena_Failed;

extern struct Arena_T* Arean_new (void);
extern void Arena_dispose(struct Arena_T* *ap);

extern void *Arena_alloc(struct Arena_T* arena, long nbytes, const char *file, int line);
extern void *Arena_calloc(struct Arena_T* arena, long count, long nbytes, const char *file, int line);

extern void Arena_free(struct Arena_T* arena);

#define NEW(t,p) \
    ((p) = Arena_alloc(t, sizeof(*(p)), __FILE__, __LINE__))  

#undef T
#endif

arena.c書中原始碼為

#include <stdlib.h>
#include <string.h>
#include "assert.h"
#include "except.h"
#include "arena.h"
#define T Arena_T

const struct  Except_T Arena_NewFailed = {"Arena Creation Failed"};
const Except_T Arena_Failed = {"Arena Allocation Failed"};



struct T 
{
    T prev;
    char *avail;
    char *limit;
};

union align {
    int i;
    long l;
    long *lp;
    void *p;
    void (*fp) (void);
    float f;
    double d;
    long double ld;
};

union header 
{
    struct T b;
    union align a;
};

static T freechunks;
static int nfree;
T Arena_new(void)
{
    T arena = malloc(sizeof(*arena));
    if(arena == NULL)
    {
        RAISE(Arena_NewFailed);
    }
    arena->prev = NULL;
    arena->limit = arena>avail = NULL;

    return arena;
}

void  Arena_dispose(T *ap)
{
    assert(ap && *ap);
    Arena_free(*ap);
    free(*ap);
    *ap = NULL:
}
void *Arena_alloc(T arena, long nbytes, const char *file, int line)
{
    assert(arena);
    assert(nbytes > 0);

    nbytes = ((nbytes + sizeof(union align) -1) / (sizeof(union align))) * (sizeof(union align));

    while (nbytes > arena->limit - arena->avail)
    {
        T ptr;
        char *limit;
        if ((ptr = freechunks) != NULL)
        {
            freechunks = freechunks->prev;
            nfree--;
            limit = ptr->limit;
        }else
        {
            long m = sizeof(union header) + nbytes + 10*1024;
            ptr = malloc(m);
            if(ptr == NULL)
            {
                if (file == NULL)
                {
                    RAISE(Arena_failed);
                }else
                {
                    Except_raise(&Arena_Failed, file, line);
                }
            }
            limit = (char *)ptr + m;
        }
        *ptr = *arena;
        arena->avail = (char *) ((union header *)ptr + 1);
        arena->limit = limit;
        arena->prev = ptr;
    }

    arena->avail += nbytes;
    return arena->avail - nbytes;
}

void * Arena_calloc(T arena, long count, long nbytes, const char *file, int line)
{
    void * ptr;
    assert(count > 0);
    ptr = Arena_alloc(arena, count *nbytes, file, line);
    memset(ptr, '\0', count *nbytes);
    return ptr;
}


void Arena_free(T arena)
{
    assert(arena);
    while(arena->prev)
    {
        struct T tmp = *arena->prev;
        if(nfree < THRESHOLD)
        {
            arena->prev->prev = freechunks;
            freechunks = arena->prev;
            nfree++;
            freechunks->limit = arena->limit;
        }else
        {
            free(arena->prev);
        }
        *arena = tmp;
    }

    assert(arena->limit == NULL);
    assert(arena->avail == NULL);
}

#define THRESHOLD 10

經過替換後的程式碼如下，這樣就更好理解了
arena_n.c

#include <stdlib.h>
#include <string.h>
#include "assert.h"
#include "except.h"
#include "arena.h"
#define T Arena_T

const struct  Except_T Arena_NewFailed = {"Arena Creation Failed"};
const Except_T Arena_Failed = {"Arena Allocation Failed"};



struct Arena_T
{
    // T prev;
    struct Arena_T* prev;
    char *avail;
    char *limit;
};

union align {
    int i;
    long l;
    long *lp;
    void *p;
    void (*fp) (void);
    float f;
    double d;
    long double ld;
};

union header 
{
    // struct T b;
    struct Arena_T b;
    union align a;
};

// static T freechunks;
static struct Arena_T* freechunks;
static int nfree;

//T Arena_new(void)
struct Arena_T* Arena_new(void)
{
    // T arena = malloc(sizeof(*arena));
    struct Arena_T* arena = malloc(sizeof(*arena));
    if(arena == NULL)
    {
        RAISE(Arena_NewFailed);
    }
    arena->prev = NULL;
    arena->limit = arena->avail = NULL;

    return arena;
}

// void Arena_dispose(T *ap)
void  Arena_dispose(struct Arena_T* *ap)
{
    assert(ap && *ap);
    Arena_free(*ap);
    free(*ap);
    *ap = NULL:
}

// void * Arena_alloc(T arena, ...)
void *Arena_alloc(struct Arena_T* arena, long nbytes, const char *file, int line)
{
    assert(arena);
    assert(nbytes > 0);

    nbytes = ((nbytes + sizeof(union align) -1) / (sizeof(union align))) * (sizeof(union align));

    while (nbytes > arena->limit - arena->avail)
    {
        // T ptr;
        struct Arena_T* ptr;
        char *limit;
        if ((ptr = freechunks) != NULL)
        {
            freechunks = freechunks->prev;
            nfree--;
            limit = ptr->limit;
        }else
        {
            long m = sizeof(union header) + nbytes + 10*1024;
            ptr = malloc(m);
            if(ptr == NULL)
            {
                if (file == NULL)
                {
                    RAISE(Arena_failed);
                }else
                {
                    Except_raise(&Arena_Failed, file, line);
                }
            }
            limit = (char *)ptr + m;
        }
        *ptr = *arena; // 只要兩個結構體型別相同是可以直接賦值的
        arena->avail = (char *) ((union header *)ptr + 1);
        arena->limit = limit;
        arena->prev = ptr;
    }

    arena->avail += nbytes;
    return arena->avail - nbytes;
}
//void * Arena_calloc(T arena,...)
void * Arena_calloc(struct Arena_T* arena, long count, long nbytes, const char *file, int line)
{
    void * ptr;
    assert(count > 0);
    ptr = Arena_alloc(arena, count *nbytes, file, line);
    memset(ptr, '\0', count *nbytes);
    return ptr;
}

// void Arena_T(T arena)
void Arena_free(struct Arena_T* arena)
{
    assert(arena);
    while(arena->prev)
    {
        //struct T tmp = *arena->prev;
        struct Arean_T tmp = *arena->prev;
        if(nfree < THRESHOLD)
        {
            arena->prev->prev = freechunks;
            freechunks = arena->prev;
            nfree++;
            freechunks->limit = arena->limit;
        }else
        {
            free(arena->prev);
        }
        *arena = tmp;
    }

    assert(arena->limit == NULL);
    assert(arena->avail == NULL);
}

#define THRESHOLD 10

下面主要闡述兩個函式Arena_alloc和Arena_free，其他相對好理解；閱讀這些程式碼需要充分理解設計這些方法的連結串列結構，資料結構在程式設計中的地位不用多說。閒言少敘，直接進入正題。
分配和回收記憶體空間，重點是要理解兩個結構體，一個是由Arena_new生成的arena，一個arena對應一個記憶體池，一般來說只需要執行一次Arena_new；另外一個就是靜態變數freechunks，用於回收或者釋放記憶體空間。
這裡寫圖片描述

下面結合程式碼說明

void *Arena_alloc(struct Arena_T* arena, long nbytes, const char *file, int line)
{
    assert(arena);
    assert(nbytes > 0);

    // 大小與align大小對齊，與前一章節一致
    nbytes = ((nbytes + sizeof(union align) -1) / (sizeof(union align))) * (sizeof(union align));

   // 如果申請空間nbytes大於已有空間，則進入迴圈，否則跳過
   // 如果是第一次申請空間arena->limit和arena->avail都是NULL,相減結果為0，必然進入到while迴圈
    while (nbytes > arena->limit - arena->avail)
    {
        // T ptr;
        struct Arena_T* ptr;
        char *limit;
        // 第一次進入freechunks靜態變數不為NULL，執行freechunks=freechunks->prev後，freechunks==NULL，細節描述見下圖
        if ((ptr = freechunks) != NULL)
        {
            freechunks = freechunks->prev;
            nfree--;
            limit = ptr->limit;
        }else
        {
            long m = sizeof(union header) + nbytes + 10*1024;
            ptr = malloc(m);
            if(ptr == NULL)
            {
                if (file == NULL)
                {
                    RAISE(Arena_failed);
                }else
                {
                    Except_raise(&Arena_Failed, file, line);
                }
            }
            limit = (char *)ptr + m;
        }
        *ptr = *arena;
        arena->avail = (char *) ((union header *)ptr + 1);
        arena->limit = limit;
        arena->prev = ptr;
    }

    arena->avail += nbytes;
    return arena->avail - nbytes;
}

這裡寫圖片描述

如果ptr空間大小分配完了或者不夠用，則重新malloc中，且是從arena之後插入新建立的ptr節點，借用書中的圖片來說明
這裡寫圖片描述

再來說說Arena_free函式，設定了空閒模組長度為10，大於10則呼叫free釋放arena->prev節點，可以看到所有的操作都是針對arena的prev節點來的，而arena如果需要則是通過Arena_dispose函式實現。

// void Arena_T(T arena)
void Arena_free(struct Arena_T* arena)
{
    assert(arena);
    while(arena->prev)
    {
        //struct T tmp = *arena->prev;
        struct Arean_T tmp = *arena->prev;
        if(nfree < THRESHOLD)
        {
            arena->prev->prev = freechunks;
            freechunks = arena->prev;
            nfree++;
            freechunks->limit = arena->limit;
        }else
        {
            free(arena->prev);
        }
        *arena = tmp;
    }

    assert(arena->limit == NULL);
    assert(arena->avail == NULL);
}

這裡寫圖片描述

簡單例項
arena_main.c

#include <stdio.h>
#include "arena_l.h"

typedef struct STDATA
{
    unsigned char ucData;
    int iData;
    char *str;
    int (*func)(int,int);
}STDATA, *PDATA;

int calc(int a, int b)
{
    return (a+b);
}

void main(void)
{
    struct Arena_T * arena = Arena_new();
    PDATA pDat;
    STDATA *pArr[14];
    int i=0;
    while(i<3)
    {
        NEW(arena, pDat);
        if(pDat != NULL)
        {
            pDat->str = (char *)Arena_alloc(arena, 100, __FILE__, __LINE__);
            strcpy(pDat->str, "Hello, world");
        }
        pArr[i] = pDat; 
        i++;
    }
    Arena_free(arena);
    i=0;
    while(i<3)
    {
        NEW(arena, pDat);
        if(pDat != NULL)
        {
            pDat->str = (char *)Arena_alloc(arena, 100, __FILE__, __LINE__);
        }
        pArr[i] = pDat; 
        printf("pArr[%d] value:%s\n",i, pArr[i]->str);
        i++;
    }
}

執行結果
這裡寫圖片描述

中間呼叫Arena_free並不是真正的free,而是將記憶體收回到freechunks中，如果再次申請，原來的資料都還在，所以如果真正使用是獲得的記憶體空間記得初始化一下。

相關推薦

c語言介面與實現--再論記憶體管理含例項

本章開頭指出上一章節描述的記憶體管理方法存在一些缺陷，比如不適合頻繁建立和銷燬記憶體的應用場景；所以在本章重新給出了另外一種設計思路。提出了記憶體池的概念，如果熟悉的小夥伴，還接觸過執行緒池的概念。個人認為這一章節比前一章節更好理解。 本書中的程式碼有個地方的

C語言介面與實現[+]

static char rcsid[] = "$Id: H:/drh/idioms/book/RCS/text.doc,v 1.10 1996/06/26 23:02:01 drh Exp $"; #include <string.h> #include <limits.h> #

讀書筆記--C語言介面與實現--介面與實現

介面實現 重點內容在本書中的第二章中，介紹了介面的封裝例子。 1. 介面定義 C語言中可將介面封裝好，讓後以.h檔案作文擴充套件，簡單例子： extern int Arith_max(int x, int y); extern int Ari

C語言介面與實現

1. 模組化程式設計        面向物件程式設計是一種思想，和語言無關。學過C++、java等面向物件程式語言的同學，應該都知道面向物件的三大特性是封裝、繼承和多型。而C語言一直被蒙上了面向過程程式設計的面紗。工作後從事的是嵌入式軟體開發，在開發過程中運用最多的還是C語

《C語言介面與實現》實驗——格式化（Fmt_T）

實驗程式是用vc6編譯，一定注意副檔名為c，不是cpp，下載前面幾個測試程式（連結串列、表、原子中有下載連結）中直接將下面源程式覆蓋1.c的內容即可！ 再次強烈建議在這些函式上設上斷點，按F11跟進去把原始碼走一遍，才有真正的學習效果！ 源程式如下： #inc

C語言再學習 -- 再論記憶體管理

但現在看來，缺少示例。從新再寫一篇文章，著重介紹常見記憶體錯誤、跨函式使用儲存區。開始吧，再論記憶體管理！！發生記憶體錯誤是件非常麻煩的事情。編譯器不能自動發現這些錯誤，通常是在程式執行時才能捕捉到。而這些錯誤大多沒有明顯的症狀時隱時現增加了改錯的難度。一、常見的記憶體錯誤及

《Effective c++ 》 介面與實現分離 檔案間的編譯依存關係降至最低

參考Effective c++中的條款31 將檔案間的編譯依存關係降至最低 。 Person.h class Date; // 類的前置宣告 class Address; class Perso

關於C++中介面與實現的理解

        所謂介面繼承，就是派生類只繼承函式的介面，也就是宣告；而實現繼承，就是派生類同時繼承函式的介面和實現。       我們都很清楚C++中有幾個基本的概念，虛擬函式、純虛擬函式、非虛擬函式。       虛擬函式：       C++實現執行中的多型性是通過

C語言基礎知識筆記：day5記憶體管理

day10 記憶體管理 @toc 一、變數作用域 全域性變數和區域性變數 一個C語言變數的作用域可以是程式碼塊，作用域就是函式作用域或者檔案作用域 程式碼塊：{}之間的一段程式碼； 1.檔案作用域： 如果一個變數在其他的程式碼檔案中已經定義了，可以在本程式中使用

《C語言深度剖析》學習筆記----記憶體管理（2）

開始陸續的發一下唐老師視訊的筆記吧，順便帶一些正衝哥書的的內容。不能一下都發出來，因為內容發多了自己也受不了，而且發的都是學習視訊時候的一些筆記，可能會有一些問題不是很清晰。 先說一下C語言中的記憶體管理。 1.動態記憶體分配 ①原因：程式執行過程中，很有可能需要一些額外的

二值形態學——腐蝕與膨脹 及 C語言代碼實現

hide 內部 isp 反射 尺寸 恢復 lag pos 參考 參考文獻：數字圖像處理(第三版) 何東健 西安電子科技大學出版社 二值形態學中的運算對象是集合， 但實際運算中， 當涉及兩個集合時並不把它們看作是互相對等的。 一般設A為圖像集合， S為結構元素， 數

C語言介面實現2048小遊戲

這是我在大一第二學期（兩年前）為了參加比賽，自學後寫的一個Dome，拿出來和大家分享一下，程式碼為兩年前的程式碼，未改動，優化以及各式可能很一般，請見諒。 #include "stdio.h" #include "stdlib.h" #include "time.h" #d

C語言再學習 -- 記憶體管理

malloc ( )函式: malloc ( ) 向系統申請分配指定size個位元組的記憶體空間。返回型別是 void* 型別。void* 表示未確定型別的指標。C,C++規定，void* 型別可

彙編:實現C語言的 ||與&&運算

;C程式轉匯編(或運算連結) DATAS SEGMENT a Dw 5 b dw 6 cc dw 7 d dw 8 m dw 2 n dw 2 string db 6 dup(?) DATAS ends CODES SEGMENT ASSUME CS:CODES, DS:DATAS

c語言堆與棧及記憶體分配

原文：http://www.cnblogs.com/TonyEwsn/archive/2010/01/29/1659496.html 格式和部分內容稍作修改。 在計算機領域，堆疊是一個不容忽視的概念，我們編寫的C語言程式基本上都要用到。但對於很多的初學著來說，堆疊是

c語言動態與靜態分配記憶體空間的區別

所謂動態記憶體分配就是指在程式執行的過程中動態地分配或者回收儲存空間的分配記憶體的方法。動態記憶體分配不象陣列等靜態記憶體分配方法那樣需要預先分配儲存空間，而是由系統根據程式的需要即時分配，且分配的大小就是程式要求的大小。例如我們定義一個float型陣列：float score[100]; 但是，在使用陣列

C語言實現簡單的記憶體管理機制

在C型別程式中，棧記憶體比較珍貴，大部分用在區域性或者類成員(因為稀少… 不適合長時間佔用一塊棧記憶體)，對於大量資料一般使用堆來分配。重複用堆分配有一個顯著的缺點就是容易造成外部碎片，在這種情況下系統記憶體不再連貫，一些記憶體得不到使用，久而久之系統記憶體會變

C語言++a與a++的實現機制與操作符結合優先順序

看到一道“經典Linux C“面試題，關於左值和右值的。 華為筆試題 1.寫出判斷ABCD四個表示式的是否正確, 若正確, 寫出經過表示式中 a的值(3分) int a = 4; (A)a += (a++); (B) a += (++a) ;(C) (a++) += a;

C語言編程實現斐波那契數列（遞歸與非遞歸）

() code tdi clu return include 位置 c語言編程 數組 一.非遞歸 <1>數組 #include<stdio.h> #include<stdlib.h> int main() { int a[1000

06-圖1 列出連通集 25分C語言鄰接表實現

aop iba mdx cab hid ctr and shang tel %E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3java%E8%99%9A%E6%8B%9F%E6%9C%BA5---%E5%AD%97%E8%8A%82%E7%A0%81%