記憶體分配與任務排程

阿新 • • 發佈：2018-11-05

轉自：https://www.cnblogs.com/zhangshenghui/p/5688687.html

一、記憶體分配：

1.1 申請一塊記憶體大小定義：

#define MEM_0_SIZE (8)   //8位元組
#define MEM_1_SIZE (16)  //16位元組
#define MEM_2_SIZE (32)
#define MEM_3_SIZE (64)
#define MEM_4_SIZE (128)
#define MEM_5_SIZE (256)

1.2 設定SIZE大小記憶體可申請到的記憶體塊最大個數定義：

#define MEM_0_COUNT (16) // 
最大16個記憶體塊
#define MEM_1_COUNT (16)
#define MEM_2_COUNT (32)
#define MEM_3_COUNT (32)
#define MEM_4_COUNT (32)
#define MEM_5_COUNT (16)

1.3 記憶體陣列定義

static u8 g_8bytesmem[MEM_0_COUNT*MEM_0_SIZE];
static u8 g_16bytesmem[MEM_1_COUNT*MEM_1_SIZE];
static u8 g_32bytesmem[MEM_2_COUNT*MEM_2_SIZE];
 
static u8 g_64bytesmem[MEM_3_COUNT*MEM_3_SIZE];
static u8 g_128bytesmem[MEM_4_COUNT*MEM_4_SIZE];
static u8 g_256bytesmem[MEM_5_COUNT*MEM_5_SIZE];

1.4 記憶體管理結構體定義

typedef struct _mem_t
{
//控制標記
u32 flag;//每種記憶體最多32塊
/*每塊記憶體的大小*/
u16 size;
/*記憶體塊個數*/
u16 count;
/*記憶體開始指標*/
u8 *buf;
}mem_t;

1.5 記憶體分配設計思想：

　　我們設定動態記憶體分配的初衷在於：有些微控制器系統記憶體資源比較少，便顯得特別珍貴，因此我們要實現記憶體的反覆利用，好像就像一個池子一樣，我們要迴圈利用池子裡的水資源。比如說洗澡時，如果是噴頭式的，這樣如果不去回收水便會浪費；而如果是在澡池子裡洗澡，每次利用完水後，水資源便會重新回到池子，可迴圈的利用起來。我們設定動態記憶體分配也是這個原理，使用之前先去申請，使用結束後便釋放，下次便可繼續申請該記憶體，迴圈利用記憶體池裡的資源。

我們先定義6個數組，各個陣列大小為XXX_SIZE * XXX_COUNT，XXX_SIZE是每個記憶體塊大小，XXX_COUNT是記憶體塊的個數。將各陣列的首地址賦給g_mem_mngt[i].buf（i：0-5）m_mngt[i].buf便分別指向每個陣列的首地址。我們申請某一長度len的記憶體時，通過計算選定匹配的記憶體塊大小，然後從對應記憶體池首地址去查詢空閒的記憶體塊，找到即停止查詢，將該記憶體塊起始地址取出便為我們申請到的記憶體塊，申請到後將該地址標記，表示已被佔用，下次不能再申請到。

釋放記憶體，首先根據記憶體節點所在的起始地址與各個記憶體池起始地址和結束地址，判斷記憶體節點所有所在的記憶體池，然後從該記憶體池首地址開始查詢，定位該記憶體落在的記憶體塊控制區域，找到後則停止查詢，並將該記憶體塊標記位清零，表示該記憶體塊已空閒，下次可申請使用。

1.6 各個記憶體塊初始化，申請的起始地址、記憶體塊個數、位元組大小、標誌位定義

void mem_init(void)
{
    g_mem_mngt[0].buf = g_8bytesmem;
    g_mem_mngt[0].count = MEM_0_COUNT;
    g_mem_mngt[0].size = MEM_0_SIZE;
    g_mem_mngt[0].flag = 0;

    g_mem_mngt[1].buf = g_16bytesmem;
    g_mem_mngt[1].count = MEM_1_COUNT;
    g_mem_mngt[1].size = MEM_1_SIZE;
    g_mem_mngt[1].flag = 0;

    g_mem_mngt[2].buf = g_32bytesmem;
    g_mem_mngt[2].count = MEM_2_COUNT;
    g_mem_mngt[2].size = MEM_2_SIZE;
    g_mem_mngt[2].flag = 0;

    g_mem_mngt[3].buf = g_64bytesmem;
    g_mem_mngt[3].count = MEM_3_COUNT;
    g_mem_mngt[3].size = MEM_3_SIZE;
    g_mem_mngt[3].flag = 0;

    g_mem_mngt[4].buf = g_128bytesmem;
    g_mem_mngt[4].count = MEM_4_COUNT;
    g_mem_mngt[4].size = MEM_4_SIZE;
    g_mem_mngt[4].flag = 0;

    g_mem_mngt[5].buf = g_256bytesmem;
    g_mem_mngt[5].count = MEM_5_COUNT;
    g_mem_mngt[5].size = MEM_5_SIZE;
    g_mem_mngt[5].flag = 0;
    
    #ifdef MEM_DEBUG
    memset(g_count, 0, sizeof(g_count));
    #endif
#if CODE_REDUN
    mem_fail = 0;
#endif
}

1.7 記憶體塊申請

　　查詢可申請記憶體起始地址，返回值為記憶體塊起始地址。該型別函式有void * mem_alloc(u8 size)和void *mem_isr_alloc(u8 size)兩種函式定義，文章中只附加在非中斷模式下程式碼。在非中斷模式下，申請記憶體塊之前要先關閉中斷，申請結束後再開啟中斷通知將申請到的記憶體地址標誌位置1，表示已申請，這樣做比較安全。在中斷模式下，不必做此操作，其他寫法都一致。

void * mem_alloc(u8 size)
{
    u8 i, j;
    mem_t * memptr = NULL;
    u8 * ptr = NULL;
    /*先找到記憶體適合的控制塊所在控制頭*/
    for(i = 0; i < MEM_TYPE_COUNT; i++)
    {
        if(size <= g_mem_mngt[i].size)
        {
            memptr = &g_mem_mngt[i];
            //找到空閒的控制塊
            ptr = memptr->buf;
            for(j = 0; j < memptr->count; j++, ptr += memptr->size)
            {
                __disable_irq();
                if(!(memptr->flag & (1<<j)))
                {
                    //標記佔用
                    memptr->flag |= (1<<j);
                    __enable_irq();
                    return ptr;
                }
                __enable_irq();
            }
            #ifdef MEM_DEBUG
            //記憶體不足,記錄一下
            MEM_STATIC_INC(i);
            #endif
        }
    }
#if CODE_REDUN
    mem_fail++;
#endif
    return NULL;
}

1.8 記憶體的釋放

　　釋放記憶體，即將表示該記憶體的佔有標誌位清零，釋放後下次便可申請該記憶體。釋放記憶體函式分為void mem_free(void * ptr)和void mem_isr_free(void * ptr)兩種，一種是在非中斷模式下，一種是在中斷模式下。在非中斷模式下釋放之前應先關閉總中斷，防止被打斷，釋放結束後再開啟總中斷。在中斷模式下則不必處理該操作。

void mem_free(void * ptr)
{
    u8 i;
    mem_t * memp = NULL;
    u8 * optr = ptr;
    u8 j;
    u8 * p;

    for(i = 0; i < MEM_TYPE_COUNT; i++)
    {
        memp = &g_mem_mngt[i];
        //定位該記憶體指標落在哪個控制區域
        if(optr >= memp->buf && optr < memp->buf + memp->size*memp->count)
        {
for(p = memp->buf, j=0; j < memp->count; p += memp->size, j++)
        {
            if((optr >= p) && (optr < p + memp->size))
            {
                __disable_irq();
                memp->flag &= ~(1<<j);

                #if PRINTF_ON
                stmprintf("free size:%d,j:%d\r\n",memp->size, j);
                #endif
                __enable_irq();
                return;
            }
        }
    }
    }
}

二、任務排程

/*連結串列的定義,list_head g_idlelist表示空閒可用任務節點連結串列，list_head g_runlist表示即將使用的任務節點連結串列。*/
static struct list_head g_runlist;
static struct list_head g_idlelist;

/*任務節點*/
typedef struct node
{
    struct list_head next;   //雙向連結串列定義
    handle   callback; 　　  //任務操作函式指標
    u8       *para;         //任務操作函式引數
    u8        flag;         //,標誌欄位，當前用來表示任務優先順序
}task_node_t; //任務節點

/*任務優先順序*/
#define PRIO_HIGH (0x1)     //優先順序最高
#define PRIO_NORMAL (0x2)   //次優先順序
#define PRIO_LOW (0x4)      //最低優先順序

2.1 任務排程，該演算法思想為：

分別建立g_idlelist和g_runlist兩個雙向連結串列，在任務初始化時，為各個任務控制塊節點申請記憶體，將各個任務節點掛載到g_idlelist連結串列上，表示目前空閒可用的任務節點，當有我們要申請任務時，要從連結串列g_idlelist上取下任務節點，同時將節點掛載到g_runlist連結串列上，表示即將使用的任務節點，掛載時是有優先順序的，當g_runlist為空連結串列時，我們直接掛載上去，當g_runlist不為空連結串列時，便要考慮優先順序的問題，任務優先順序高的任務節點掛載在最前面。然後按照優先順序順序執行對應的任務，等任務執行結束後將任務節點又掛載到g_idlelist連結串列最後面。等待下次的呼叫。

2.2 任務節點初始化，為任務節點申請記憶體，並將任務節點掛載到g_idlelist連結串列上，表示未使用的任務節點。

void task_queue_init(void)
{
    u8 i;
    task_node_t * task;
    list_init_head(&g_runlist);
    list_init_head(&g_idlelist);

    for(i = 0; i < TASK_MAX_COUNT; i++)
    {
        task = mem_alloc(sizeof(task_node_t));
#if CODE_REDUN
        if(NULL == task)
        {
            return;
        }
#endif
        list_add_tail(&g_idlelist, &task->next);
    }
}

2.3 生成任務函式，包括任務節點地址的申請，任務節點各個成員的賦值。從g_idlelist節點取出將要使用的任務節點，並將要它執掛載到g_runlist連結串列上，表示即將使用的任務節點。插入g_runlist連結串列時要根據任務優先順序順序插入節點。

/*任務進入佇列：*/
static void task_in_queue(task_node_t *task)
{
    struct list_head * plist = NULL;
    task_node_t *p = NULL;

    if(list_isempty(&g_runlist))
    {
        list_add_tail(&g_runlist, &task->next);
        return;
    }

    /*佇列不為空，根據優先順序放到合適的地方*/
    for(plist = g_runlist.next; plist != &g_runlist; plist = plist->next)
    {
        p = container_of(plist, task_node_t, next);
        if(PRIO_GET(task->flag) < PRIO_GET(p->flag))
        {
            //找到位置了,終止迴圈
            list_add(&task->next, plist->prev, plist);
            return;
        }
    }

    //插入到最後
    list_add_tail(&g_runlist, &task->next);
}

/*任務控制塊記憶體申請，引數定義：*/
u8 task_create(handle func,u8 *para, u8 prio)
{
    struct list_head * plist;
    task_node_t *task;

    __disable_irq();
    plist = list_fetch(&g_idlelist);
    __enable_irq();

    if(NULL == plist)
    {
        #if PRINTF_ON
        stmprintf("TASK full\r\n");
        #endif
        return 1;
    }

    task = container_of(plist, task_node_t, next);
    list_init_head(&task->next);
    task->callback = func;
    task->para = para;
    task->flag = prio;

    __disable_irq();
    task_in_queue(task);
    __enable_irq();

    return 0;
}

2.4 任務執行函式

/*執行任務函式，從任務連結串列g_runlist取出一個優先順序最高的任務節點，執行任務。執行任務之前關閉總中斷，執行結束後開啟總中斷*/
void task_run(void)
{
    task_node_t * task;
    handle cb;
    u8 * para;
    struct list_head * plist;
    __disable_irq();
    plist = list_fetch(&g_runlist);
    if(plist)
    {
        task = container_of(plist, task_node_t, next);
        cb = task->callback;
        para = task->para;
        list_add_tail(&g_idlelist, &task->next);
        __enable_irq();

        if(cb)
        {
#if CODE_REDUN
        current_tick = get_timer6_tick();
#endif
            cb(para);
#if CODE_REDUN
            current_tick = 0;
#endif
        }
    }
    else
    {
        __enable_irq();
    }
}

記憶體分配與任務排程

記憶體分配與任務排程

記憶體分配與跟蹤

5.3 記憶體分配與垃圾回收

java記憶體分配與溢位

g++ 記憶體分配與 c 語言中的陣列越界問題（一道有趣的面試題）

JVM記憶體分配與回收學習（2）

動態開點線段樹(多棵線段樹）的記憶體分配與回收

Spark學習(四)資源排程與任務排程的整合

golang 學習筆記 ---記憶體分配與管理

動態記憶體分配與釋放（陳銳、葛麗萍編著《跟我學資料結構》整理)

核心的幾種記憶體分配與線性對映方式

垃圾收集器與記憶體分配策略（六）——記憶體分配與回收策略

JVM:GC-記憶體分配與回收策略

簡單的動態記憶體分配與釋放

C++ STL中的vector的記憶體分配與釋放

記憶體分配與欄位堆和棧 XIP(片上執行)

JVM六：記憶體分配與回收策略

spark提交任務的模式—— standalone模式與yarn模式、資源排程與任務排程

JVM之記憶體分配與回收策略

memcache原理1.5.8——記憶體分配與淘汰

記憶體分配與任務排程

相關推薦