模擬記憶體分配

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

作業系統的上機實驗報告程式碼，這裡分享給大家：

#include<stdio.h>
#include<stdlib.h>

#define PROCESS_NAME_LEN 32        /*程序名稱的最大長度*/
#define MIN_SLICE    10            /*最小碎片的大小*/
#define DEFAULT_MEM_SIZE 1024       /*預設記憶體的大小*/
#define DEFAULT_MEM_START 0        /*預設記憶體的起始位置*/

/* 記憶體分配演算法 */
#define MA_FF 1
#define MA_BF 2 

#define MA_WF 3

/*描述每一個空閒塊的資料結構*/
struct free_block_type{
    int size;
    int start_addr;
    struct free_block_type *next;
};

/*指向記憶體中空閒塊連結串列的首指標*/
struct free_block_type *free_block;

/*每個程序分配到的記憶體塊的描述*/
struct allocated_block{
    int pid;            /*程序pid*/
    int size;           /*記憶體塊大小*/
    int 
 start_addr;     /*開始地址*/
    char process_name[PROCESS_NAME_LEN]; /*程序名*/
    struct allocated_block *next;
};
/*程序分配記憶體塊連結串列的首指標*/
struct allocated_block *allocated_block_head = NULL;
int mem_size=DEFAULT_MEM_SIZE;        /*記憶體大小*/
int ma_algorithm = MA_FF;            /*當前分配演算法*/
static int pid = 0;                    /*初始pid*/ 

int flag = 0;                      /*設定記憶體大小標誌*/

/*函式宣告*/
struct free_block_type* init_free_block(int mem_size);
void display_menu();
int set_mem_size();
void set_algorithm();
void rearrange(int algorithm);
void rearrange_FF();
void rearrange_BF();
void rearrange_WF();
int new_process();
int allocate_mem(struct allocated_block *ab);
void kill_process();
int free_mem(struct allocated_block *ab);
int dispose(struct allocated_block *free_ab);
int display_mem_usage();
void do_exit();
void swap(int* , int*);
struct allocated_block *find_process(int);

struct allocated_block *find_process(int pid)
{
    struct allocated_block *p;
    p = allocated_block_head;
    while(p!= NULL)
    {
        if(p->pid == pid)
        {
            return p;
        }
        p = p->next;
    }
    return NULL;
}


void swap(int *a,int  *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}
void do_exit()
{
}

int main()
{
    int a = 10;
    int b = 20;
    swap(&a,&b);
    char choice;
    pid=0;
    free_block = init_free_block(mem_size); //初始化空閒區
    for(;;)
    {
        display_menu(); //顯示選單
        fflush(stdin);
        choice=getchar();   //獲取使用者輸入
        switch(choice)
        {
            case '1': set_mem_size(); break;    //設定記憶體大小
            case '2': set_algorithm();flag=1; break;    //設定分配演算法
            case '3': new_process(); flag=1; break; //建立新程序
            case '4': kill_process();flag=1; break; //刪除程序
            case '5': display_mem_usage(); flag=1; break;   //顯示記憶體使用
            case '0': do_exit(); exit(0);       //釋放連結串列並退出
            default: break;
        }
        getchar();
    }
}

/*初始化空閒塊，預設為一塊，可以指定大小及起始地址*/
struct free_block_type* init_free_block(int mem_size)
{
    struct free_block_type *fb;
    fb=(struct free_block_type *)malloc(sizeof(struct free_block_type));
    if(fb==NULL)
    {
        printf("No mem\n");
        return NULL;
    }
    fb->size = mem_size;
    fb->start_addr = DEFAULT_MEM_START;
    fb->next = NULL;
    return fb;
}

/*顯示選單*/
void display_menu()
{
    printf("\n");
    printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);
    printf("2 - Select memory allocation algorithm\n");
    printf("3 - New process \n");
    printf("4 - Terminate a process \n");
    printf("5 - Display memory usage \n");
    printf("0 - Exit\n");
}
/*設定總記憶體的大小*/
int set_mem_size()
{
    int size;
    if(flag!=0)  //防止重複設定
    {
        printf("Cannot set memory size again\n");
        return 0;
    }
    printf("Total memory size =");
    scanf("%d", &size);
    if(size>0)
    {
        mem_size = size;
        free_block->size = mem_size;
    }
    flag=1;
    return 1;
}
/* 設定當前的分配演算法 */
void set_algorithm()
{
    int algorithm;
    printf("\t1 - First Fit\n");
    printf("\t2 - Best Fit \n");
    printf("\t3 - Worst Fit \n");
    scanf("%d", &algorithm);
    if(algorithm>=1 && algorithm <=3)
        ma_algorithm=algorithm;
    //按指定演算法重新排列空閒區連結串列
    rearrange(ma_algorithm);
}
/*按指定的演算法整理記憶體空閒塊連結串列*/
void rearrange(int algorithm)
{
    switch(algorithm)
    {
        case MA_FF:  rearrange_FF(); break;
        case MA_BF:  rearrange_BF(); break;
        case MA_WF: rearrange_WF(); break;
    }
}


/*按FF演算法重新整理記憶體空閒塊連結串列*/
void rearrange_FF()
{
    struct free_block_type *tmp, *work;
    printf("Rearrange free blocks for FF \n");
    tmp = free_block;
    while(tmp!=NULL)
    {
        work = tmp->next;
        while(work!=NULL)
        {
            if( work->start_addr < tmp->start_addr) /*地址遞增*/
            {
                printf("%d %d",work->start_addr,tmp->start_addr);
                swap(&work->start_addr, &tmp->start_addr);
                swap(&work->size, &tmp->size);
                printf("%d %d",work->start_addr,tmp->start_addr);
            }
            work=work->next;
        }
        tmp=tmp->next;
    }
}
/*按BF演算法重新整理記憶體空閒塊連結串列*/

void rearrange_BF()
{
    //請自行補充
    struct free_block_type *tmp, *work;
    printf("Rearrange free blocks for BF \n");
    tmp = free_block;
    while(tmp!=NULL)
    {
        work = tmp->next;
        while(work!=NULL)
        {
            if( work->size < tmp->size) /*記憶體大小遞增*/
            {
                printf("%d %d",work->start_addr,tmp->start_addr);
                swap(&work->start_addr, &tmp->start_addr);
                swap(&work->size, &tmp->size);
                printf("%d %d",work->start_addr,tmp->start_addr);
            }
            work=work->next;
        }
        tmp=tmp->next;
    }
}
/*按WF演算法重新整理記憶體空閒塊連結串列*/

void rearrange_WF()
{
    //請自行補充
    struct free_block_type *tmp, *work;
    printf("Rearrange free blocks for WF \n");
    tmp = free_block;
    while(tmp!=NULL)
    {
        work = tmp->next;
        while(work!=NULL)
        {
            if( work->size > tmp->size) /*地址遞減*/
            {
                swap(&work->start_addr, &tmp->start_addr);
                swap(&work->size, &tmp->size);
            }
            work=work->next;
        }
        tmp=tmp->next;
    }
}
/*建立新的程序，主要是獲取記憶體的申請數量*/
int new_process()
{
    struct allocated_block *ab;
    int size;
    int ret;
    ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));
    if(!ab)
    {
        exit(-5);
    }
    ab->next = NULL;
    pid++;
    sprintf(ab->process_name, "PROCESS-%02d", pid);
    ab->pid = pid;
    printf("Memory for %s:", ab->process_name);
    scanf("%d", &size);
    if(size>0)
    {
        ab->size=size;
    }
    ret = allocate_mem(ab);  /* 從空閒區分配記憶體，ret==1表示分配ok*/
    /*如果此時allocated_block_head尚未賦值，則賦值*/
    if((ret==1) && (allocated_block_head == NULL))
    {
        allocated_block_head=ab;
        return 1;
    }/*分配成功，將該已分配塊的描述插入已分配連結串列*/
    else if (ret==1)
    {
        ab->next=allocated_block_head;
        allocated_block_head=ab;
        return 2;
    }
    else if(ret==-1) /*分配不成功*/
    {
        printf("Allocation fail\n");
        free(ab);
        return -1;
    }
    return 3;
}
/*分配記憶體模組*/
int allocate_mem(struct allocated_block *ab)
{
    struct free_block_type *fbt, *pre;
    int request_size=ab->size;
    fbt = pre = free_block;
    while(fbt!=NULL)
    {
        if(fbt->size>=request_size)/*分配後空閒空間足夠大，則分割*/
        {
            //自行補充********
            ab->start_addr = fbt->start_addr;
            fbt->start_addr += request_size;
            fbt->size-= request_size;
            return 1;
        }
        pre = fbt;
        fbt = fbt->next;
    }
    return -1;
}
/*刪除程序，歸還分配的儲存空間，並刪除描述該程序記憶體分配的節點*/
void kill_process()
{
    struct allocated_block *ab;
    int pid;
    printf("Kill Process, pid=");
    scanf("%d", &pid);
    ab=find_process(pid);
    if(ab!=NULL)
    {
        free_mem(ab); /*釋放ab所表示的分配區*/
        dispose(ab);  /*釋放ab資料結構節點*/
    }
}
/*將ab所表示的已分配區歸還，並進行可能的合併*/
int free_mem(struct allocated_block *ab)
{
    int algorithm = ma_algorithm;
    struct free_block_type *fbt, *pre, *work;

    fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));
    if(!fbt)
    {
        return -1;
    }
    fbt->size = ab->size;
    fbt->start_addr = ab->start_addr;
    /*插入到空閒區連結串列的頭部並將空閒區按地址遞增的次序排列*/
    fbt->next = free_block;
    free_block=fbt;
    rearrange(MA_FF);
    pre=free_block;
    while(pre!=NULL)
    {
        work = pre->next;
        if(work!=NULL)
        {
            /*如果當前空閒區與後面的空閒區相連，則合併*/
            if(pre->start_addr+pre->size == work->start_addr)
            {
                pre->size += work->size;
                pre->next = work->next;
                free(work);
                continue;
           }
        }
        pre = pre->next;
    }
    rearrange(algorithm); /*重新按當前的演算法排列空閒區*/
    return 1;
}
/*釋放ab資料結構節點*/
int dispose(struct allocated_block *free_ab)
{
    struct allocated_block *pre, *ab;

    if(free_ab == allocated_block_head) /*如果要釋放第一個節點*/
    {
        allocated_block_head = allocated_block_head->next;
        free(free_ab);
        return 1;
    }
    pre = allocated_block_head;
    ab = allocated_block_head->next;

    while(ab!=free_ab)
    {
        pre = ab;  ab = ab->next;
    }
    pre->next = ab->next;
    free(ab);
    return 2;
}
int display_mem_usage()
{
    struct free_block_type *fbt=free_block;
    struct allocated_block *ab=allocated_block_head;
    if(fbt==NULL)
        return(-1);
    printf("----------------------------------------------------------\n");

    /* 顯示空閒區 */
    printf("Free Memory:\n");
    printf("%20s %20s\n", "      start_addr", "       size");
    while(fbt!=NULL)
    {
        printf("%20d %20d\n", fbt->start_addr, fbt->size);
        fbt=fbt->next;
    }
    /* 顯示已分配區 */
    printf("\nUsed Memory:\n");
    printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");
    while(ab!=NULL)
    {
        printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);
        ab=ab->next;
    }
    printf("----------------------------------------------------------\n");
    return 0;
}

模擬記憶體分配

作業系統的上機實驗報告程式碼，這裡分享給大家： #include<stdio.h> #include<stdlib.h> #define PROCESS_NAME_LEN 32 /*程序名稱的最大長度*/ #defi

最佳適應演算法模擬記憶體分配

最佳適應演算法從全部空閒區中找出能滿足作業要求的，且大小最小的空閒分割槽，這種方法能使碎片儘量小。問題描述 Given five memory partitions of 100 KB, 500 KB, 200 KB, 300 KB, and 600

c模擬記憶體分配演算法（首次適應演算法，最佳適應演算法，最壞適應演算法）

#include<bits/stdc++.h> using namespace std; /*定義記憶體的大小為100*/ #define MEMSIZE 100 /*如果小於此值，將不再分割記憶體*/ #define MINSIZE 2 /*記憶體分割槽空間表結構*/ typedef str

[POJ1193][NOI1999]記憶體分配(連結串列+模擬)

題意時刻 T 記憶體佔用情況程序事件 0 1 2 3 4 5 6 7 8 9 程序A申請空間（M=3

模擬可變分割槽儲存管理的記憶體分配（C）

要求：系統根據申請者的要求，按照一定的分配策略分析記憶體空間的使用情況，找出能滿足請求的空閒區，分給申請者；當程式執行完畢或主動歸還記憶體資源時，系統要收回它所佔用的記憶體空間或它歸還的部分記憶體空間，主存分配演算法使用最壞適應分配演算法。程式執行時根據檔案內容初始化

作業系統: 最佳適配演算法和鄰近適配演算法的模擬實現（記憶體分配演算法）

實現動態分割槽的分配演算法。 (1) 最佳適配演算法：選擇記憶體空閒塊中最適合程序大小的塊分配。 (2) 鄰近適配演算法：從上一次分配的地址開始查詢符合要求的塊，所查詢到的第一個滿足要求的空閒塊就分配給程序。模擬新增程序的時候，假定記憶體是一塊完整的空閒區，對於演算法(1

系統記憶體分配的首次適應演算法和最佳適應演算法連結串列模擬實現

#include<iostream> #include<stdlib.h> using namespace std; #define Free 0 //空閒狀態 #define Busy 1 //已用狀態 #define OK 1 //完成

模擬實現c語言中的動態記憶體分配malloc函式

動態儲存器分配器維護著一個程序的虛擬的儲存器區域，稱為堆（heap）。分配器將堆視為一組不同大小的塊的集合來維護。每個塊就是一個連續的虛擬儲存器片（chunk），要麼是已經分配的，要麼是空閒的。我們這裡把記憶體堆空間模擬為一個位元組陣列buf［1000］，塊的資料結構為：

記憶體分配與跟蹤

編寫一個程式，包括兩個執行緒，一個執行緒用於模擬記憶體分配活動，另一個用於跟蹤第一個執行緒的記憶體行為，要求兩個執行緒之間通過訊號量實現同步，模擬記憶體活動的執行緒可以從一個檔案中讀出要進行的記憶體操作。每個記憶體操作包含如下內容：時間：每個操作等待時間；塊數：分配記憶體的

學習筆記-C語言6（指標與動態記憶體分配）

1. 指標指標的引入：指標是C語言最強大的功能之一，使用指標可以儲存某個變數在記憶體中的地址，並且通過操作指標來對該片記憶體進行靈活的操作，例如改變原變數的值，或者構造複雜的資料結構。指標一般初始化為NULL（0）。& 是取地址運算，* 是間接運算子，通過 * 可以訪問與修改

JVM的垃圾收集機制和記憶體分配策略

首先給大家看一下JVM的資料區模型。上圖是JVM的資料區模型。但是在Hotspot JVM中，我們知道執行時常量是屬於方法區的，而方法區又屬於堆。對於棧，在hotspot中虛擬機器棧和本地棧是合二為一的。這裡在順便說一說虛擬機器物件的結構，如下圖所示

java記憶體分配之堆，棧，常量池,方法區

java棧 java棧，在函式的定義中定義的基本型別（int,long,short,byte,float,double,boolean,char）的變數資料和物件的引用變數分配的儲存空間的地方。當在程式碼塊中定義一個變數時，java棧就為這個變數分配適當的記憶體空間，當該變數退出作用域時，jav

記憶體探尋1之——值型別和引用型別的記憶體分配機制

String物件和值型別的記憶體分配機制：同樣由前延伸，上上篇《由String型別分析，所產生的對引數傳遞之惑的解答》中，最後提及，如果將引用型別的按值傳遞和按引用傳遞，用託管堆表

c++學習之路：2.預設引數&函式過載&堆記憶體分配

預設引數規則：程式從右向左延伸讀取例子：如下sortarr函式，在創造函式的時候可以直接賦值，這樣執行的時候就執行預設值。又如debug函式，不傳參就會列印------------------；函式過載理解：幾個同名函式，所設有的引數不一樣，就代表為不同函式。所以傳參的時候

Java中的陣列和記憶體分配

理解陣列概念：陣列是儲存同一種資料型別多個元素的集合。也可以看成是一個容器。陣列既可以儲存基本資料型別，也可以儲存引用資料型別，只要所有的陣列元素具有相同的資料型別即可定義陣列的方法： ①：type[] arrayName;（推薦使用這種方式） ②：ty

5.3 記憶體分配與垃圾回收

5.3 記憶體分配與垃圾回收在5.4部分中，我們將展示如何用一個暫存器機器實現一個SCHEME直譯器。為了簡化討論，我們假定我們的暫存器機器有一個列表結構的記憶體，而且操作列表結構的基本操作是原生的。當我們聚焦於在一個SCHEME直譯器中的控制機制時，假定如此的記憶

C/C++記憶體分配【轉】

（轉自：http://blog.51cto.com/jiuxiaotian/860844） 1：c中的malloc和c＋＋中的new有什麼區別 malloc和new有以下不同：（1）new、delete 是操作符，可以過載，只能在C++中使用。（2）malloc、free是函式，可以覆蓋，C

深入理解Java虛擬機器總結一垃圾收集器與記憶體分配策略(二)

深入理解Java虛擬機器總結一垃圾收集器與記憶體分配策略(二) 垃圾回收概述如何判定物件為垃圾物件垃圾回收演算法垃圾收集器詳解記憶體分配策略垃圾回收概述如何判定物件為垃圾物件引用計數法: 在物件

java記憶體分配與溢位

　　Java程式而言，Java虛擬機器有自動記憶體管理機制，不需要開發人員去手動釋放內空間，也不容易出現記憶體洩漏和溢位的問題，一切看起來都很完美。一旦出現記憶體洩漏和溢位方面的問題，如果不瞭解Java虛擬機器是怎麼樣使用記憶體的，那麼排查起來將困難。以往對記憶體的理解僅僅停留在棧、堆這兩個部分，其實Java

記憶體分配方式以及堆和棧的區別

轉載：https://blog.csdn.net/shanchangyi/article/details/51854795 對於一個程式要執行，涉及到的記憶體分配是一個首要問題，這裡簡單說一下一個簡單的程式執行所涉及到的記憶體分配方式。另外，在資料結構中存在堆和棧的概念，棧是一種先進後出的資料結

模擬記憶體分配

相關推薦