Linux虚拟存储器系统

Posted 2022-12-09 the_scent_of_th_soul

一个虚拟存储系统要求硬件和内核软件之间紧密协作，版本与版本之间细节都不尽相同，在这里我们的目标是对Linux的虚拟系统做一个描述，大致理解操作系统是如何组织虚拟存储器以及如何缺页的。

虚拟地址空间:一套虚拟地址的集合。cpu从一个有N=2^n个地址的虚拟地址空间中生成虚拟地址来访问内存。Linux为每一个进程维持了一个单独的虚拟地址空间,虚拟地址空间可以有间隙。

（一）Linux虚拟存储器定义：Linux的虚拟存储器是由一些区域（也叫做段）组成的集合。一个区域(area)就是已经存在着的（已分配的）虚拟存储器的连续片（chunk），这些页是以某种方式关联的。例如，代码段、数据段、堆、共享库段、以及用户栈都是不同的区域。每个存在的虚拟页面都保存在某个区域中，而不属于某个区域的虚拟页面是不存在的，并且不能被进程引用。内核不用记录那些不存在的虚拟页面，这样的页也不用占存储器、磁盘、或者内核本身的用存任何额外资源。

b.进程中虚拟存储器的数据结构：内核为系统中每个进程维护一个单独的任务结构。任务结构中的元素包含或指向内核运行该进程所需要的所有信息。（可理解为结构体里面有好多个结构体总共标明了所有信息）（所需要的信息举例：PID、指向用户栈的指针、可执行目标文件的名字以及程序计数器）。

（二）Linux存储器映射：虚拟存储器区域　与一个　磁盘上的对象　关联起来的过程称为存储器映射。存储器映射的目的是初始化该虚拟存储器区域的内容。虚拟存储器区域可以映射到Unix文件系统中的普通文件和匿名文件这两种类型的对象中的一种。

Unix进程可以使用mmap函数来创建新的虚拟存储器区域，并将对象映射到这些区域中。例如：

int main(int argc, char **argv)

    int fd;         //获取文件描述符
    char *fp;       //接受虚拟存储空间返回的指针

    if( (fd=open(argv[1], O_RDWR))==-1 )
        printf("open error\\n");
        exit(-1);
    

    //用mmap函数创建虚拟地址空间
    fp=mmap(NULL, 1000000, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    printf("%s" ,fp);

    //用munmap函数删除虚拟地址空间
    printf("==%d\\n", munmap(fp, 10) );
    printf("%s\\n" ,fp);

return 0;

一个对象可以被映射到虚拟存储器的一个区域，要么作为共享对象，要么作为私有对象。一个映射到共享对象的虚拟存储器区域叫做共享区域，类似地，也有私有区域。

1.共享对象：类似于ｃ语言中函数对全局变量和私有变量的操作，进程对共享区域的任何写操作，对于其他进程的　映射于该共享对象的共享区域来说，是可见的。而且，这些变化也会反应在磁盘上的原始对象中。在这里，即使对象被映射到了多个共享区域，物理存储器中也只需要存放共享对象的一个拷贝。

2.私有对象：与共享对象一样，物理存储器只保存私有对象的一份拷贝。两个进程可以共享同一个物理拷贝，将私有对象映射到它们自己的私有区域。

私有对象是使用一种叫做写时拷贝的巧妙技术被映射到虚拟存储器中的。对于每个映射私有对象的进程，相应私有区域的页表条目都被标记为只读，并且区域结构被标记为私有的写时拷贝。当有进程试图写私有区域的某个页面时，这个写操作就会触发一个保护屏障。此时，故障处理程序会在物理存储器上重新创建这个页面的一个拷贝，给这个新拷贝可写权限，更新页表条目指向这个新拷贝。当故障处理程序返回时，CPU重新执行这个写操作，现在就可以写了。

也就是说，不管是私有对象还是共享对象，在物理存储器上都只有一份拷贝，都可以共享。但是，进程可以顺利地在共享区域执行写操作　并且为其他的　把这个共享对象映射到虚拟存储器的进程可见　还会反映到磁盘上的原始对象中。而进程对私有区域的写操作依赖于写时拷贝技术，不但对其他进程不可见，而且不会反映在磁盘上的对象中。

（三）动态存储器分配：因为经常要到程序实际运行时，我们才知道某些数据结构的大小，所以用动态存储分配器更方便，而且有更好的可移植性。

1.动态存储分配器维护着一个进程的虚拟存储器区域，称为堆。分配器将堆视为一组不同大小的块儿的集合来维护。每个块就是一个连续的虚拟存储器片(chunk)，已分配的块显示地保留为供应用程序使用，空闲块可用来分配。

2.显示分配器：显示分配器要求显示地释放任何已分配的块。例如，c标准库提供的malloc程序包的显示分配器。ｃ程序通过调用malloc函数来调用一个块，并调用free函数来释放一个块。c++里面的new和delete操作符与c中的malloc和free相当。
3.隐式分配器：隐式分配器也叫做垃圾收集器，要求分配器检测一个已分配块何时不再被程序所使用，那么就释放这个块。自动释放未使用的已分配的块的过程叫做垃圾收集，例如java之类的高级语言就依赖垃圾收集来释放已分配的块。

4.实现一个简单的显示分配器：构造一个分配器是一件富有挑战性的任务。设计空间很大，有多种块格式、空闲链表格式，以及放置、分割和合并策略可供选择。
下面，我们选择特定格式来实现一个简单的分配器。
代码如下：

#include<stdio.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdlib.h>
#include<assert.h>
#include<sys/socket.h>
#include<string.h>
#include<errno.h>

#define WSIZE 4                 //字的大小
#define DSIZE 8                 //双字的大小
#define CHUNKSIZE (1<<12)       //扩展堆时的默认大小
#define MAX(x, y) ((x) > (y) ? (x) :(y))
//将大小和已分配位结合起来并返回一个值，可以把它存放在头部或脚部
#define PACK(size, alloc) ((size) | (alloc))

//read and write a word at address p
#define GET(p) (*(unsigned int*)(p))
#define PUT(p,val) (*(unsigned int*)(p)=(val))

//read the size and allocated files from address p
#define GET_SIZE(p) (GET(p) & ~0x7)        //从地址p处的头部或尾部返回大小
#define GET_ALLOC(p) (GET(p) & 0x1)     //从地址p处的头部或尾部返回已分配位

//Give block ptr bp,compute address of its header and footer

#define HDRP(bp) ((char *)(bp)-WSIZE)                       //返回指向这个块儿头部指针
#define FTRP(bp) ((char *)(bp)+GET_SIZE(HDRP(bp))-DSIZE)    //尾部

//Give block ptr bp, compute address of next and previous blocks
//
//根据这一块儿的头部确定这块儿的大小从而跳到下一块儿
#define NEXT_BLKP(bp) ((char *)(bp) + GET_SIZE( ((char *)(bp) -WSIZE ) ))       //返回指向后面块的指针

//根据上一块儿的尾部以获得上一块儿的大小从而跳到上一块儿
#define PREV_BLKP(bp) ((char *)(bp) + GET_SIZE( ((char *)(bp)-DSIZE) ))         //返回指向前面块的指针

#define MAX_HEAP (10*(1<<12))       //10MB

/*Private global variables*/
static char *mem_heap;              //Points to first byte of heap
static char *mem_brk;               //Points to last byte of heap plus 1
static char *mem_max_addr;          //Max legal heap addr plus 1
static char *heap_listp;            //指向序言块儿
static void *coalesce(void *bp);    //合并空闲块儿

/*
 *函数声明部分
*/

void mem_init(void);                    //申请一大块儿地址空间
void *mem_sbrk(int incr);               //请求额外的堆存储器，拒绝缩堆
int mm_init(void);                      //初始化堆Dstatic voia *extend_heap(size_t words);  
static void *extend_heap(size_t words); //扩展堆
void mm_free(void *bp);                 //堆释放
static void *find_fit(size_t asizei);   //首次适配搜索
static void place(void *bp, size_t asize);                  //将asize大小的空闲位　置为　已分配位

//mem_init -Initial the memory system model
void mem_init(void)

    mem_heap=(char *)malloc(MAX_HEAP);
    mem_brk=(char *)mem_heap;
    mem_max_addr=(char *)(mem_heap + MAX_HEAP);


/*mem_sbrk _Simple model of the sbrkfunction.Extends the heap by incr
 * bytes and returns the start address of the new area.In this model,
 * the heap cannot be shrunk
*/
void *mem_sbrk(int incr)

    char *old_brk=mem_brk;

    if((incr < 0) || ((mem_brk + incr) > mem_max_addr))
        errno=ENOMEM;
        fprintf(stderr, "ERROR: mem_sbrk faild. Ran out of memory...\\n");
        return (void *)-1;
    
    mem_brk += incr;
    return (void *)old_brk;


//合并空闲块儿
static void *coalesce(void *bp)

    size_t prev_alloc=GET_ALLOC(FTRP(PREV_BLKP(bp)));       //获取前面块儿的已分配位
    size_t next_alloc=GET_ALLOC(HDRP(NEXT_BLKP(bp)));       //获取后面块儿的已分配位
    size_t size=GET_SIZE(HDRP(bp));                         
    if(prev_alloc && next_alloc)
        return bp;                      //前后都被占用   case1 
                               
    else if(prev_alloc && !next_alloc)
        size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
        PUT(HDRP(bp), PACK(size, 0));
        PUT(FTRP(bp), PACK(size, 0));
                                       //前一个块儿空闲
    else if(!prev_alloc && next_alloc)

        size += GET_SIZE(HDRP(PREV_BLKP(bp)));
        PUT(FTRP(bp), PACK(size, 0));
        PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
        bp = PREV_BLKP(bp);
                                       //后一个块儿空闲
    else
        size += GET_SIZE(HDRP(PREV_BLKP(bp)))+GET_SIZE(FTRP(NEXT_BLKP(bp)));
        PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
        PUT(FTRP(NEXT_BLKP(bp)), PACK(size, 0));
        bp = PREV_BLKP(bp);
                                       //前后块儿都空闲
    return bp;


//扩展堆函数
static void *extend_heap(size_t words)

    char *bp;
    size_t size;

    size = (words % 2) ? (words+1)*WSIZE : words * WSIZE;
    if((long)(bp=mem_sbrk(size)) == -1)
        return NULL;

    //初始化空闲的头尾和结尾块儿
    PUT(HDRP(bp), PACK(size, 0));
    PUT(FTRP(bp), PACK(size, 0));
    PUT(HDRP(NEXT_BLKP(bp)), PACK(0,1) );

    //合并空闲块儿
    return coalesce(bp);


// 创建一个带初始空闲块儿的堆
int mm_init(void)

    /*create the initial empty heap*/
    if( ( heap_listp = mem_sbrk(4*WSIZE)) == (void *)-1 )
        return -1;

    PUT(heap_listp, 0);                                     //填充块儿
    PUT(heap_listp + (1*WSIZE), PACK(DSIZE, 1));            //序言块儿
    PUT(heap_listp + (2*WSIZE), PACK(DSIZE, 1));            //序言块儿
    PUT(heap_listp + (3*WSIZE), PACK(0,1));                 //结尾块儿

    heap_listp += 2*WSIZE;
    /*Extend the empty heap eith a free block of CHUNKSIZE bytes*/
    if(extend_heap(CHUNKSIZE/WSIZE) == NULL)
        return -1;
    return 0;



//释放空间
void mm_free(void *bp)

    size_t size=GET_SIZE(HDRP(bp));
    PUT(HDRP(bp), PACK(size, 0));
    PUT(FTRP(bp), PACK(size, 0));
    coalesce(bp);


/*static void *find_fit(size_t asize)

    char *heap_cir=heap_listp;          //指向合适块儿的头
    while(heap_cir < mem_brk)
        if( (GET_ALLOC(heap_cir) ==0) && (GET_SIZE(heap_cir) >= asize) )
            return heap_cir;
        
        else 
            heap_cir += GET_SIZE(heap_cir);
       
    return NULL;
*/


//对隐式空闲链表进行首次适配搜索
static void *find_fit(size_t asize)

    /*First fit search*/
    void *bp;
    for(bp = heap_listp; GET_SIZE(HDRP(bp)) > 0 ; bp=NEXT_BLKP(bp) )
        if(!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp))) )
            return bp;
        
    
    return NULL;


//将空闲位标志为分配位
static void place(void *bp, size_t asize)

    size_t csize=GET_SIZE(HDRP(bp));

    //如果一个块儿不够
    if((csize-asize) >= (2*DSIZE))

        PUT(HDRP(bp), PACK(asize, 1));
        PUT(FTRP(bp), PACK(asize, 1));
        bp=NEXT_BLKP(bp);

        //占用下一个块儿一些空间
        PUT( HDRP(bp), PACK(csize-asize, 0) );  
        PUT( FTRP(bp), PACK(csize-asize, 0) );  
    else
        PUT(HDRP(bp), PACK(csize, 1));
        PUT(FTRP(bp), PACK(csize, 1));
    


//从空闲链表分配一个块儿
void *mm_malloc(size_t size)

    size_t asize;
    size_t extendsize;
    char *bp;

    /*Ignore spurious requests*/
    if(size == 0)
        return NULL;
    

    /*Adjust block size to include overhead and alignment reqs*/
    if(size <= DSIZE)
//      printf("size <= DSIZE\\n");
        asize = 2*DSIZE;
    
    else 
        asize = DSIZE*( (size + (DSIZE) + (DSIZE-1) )/DSIZE );

    //Search the free list for a fit
    if((bp=find_fit(asize)) != NULL)
        place(bp, asize);
//      printf("!=NULL  242\\n");
        return bp;
    

    extendsize=MAX(asize, CHUNKSIZE);
    if( (bp=extend_heap(extendsize/WSIZE)) == NULL)
        return NULL;
    
    place(bp, asize);
    return bp;


int main(void)


    size_t a=4;
    int *bp;
    int *m;
    int *n;

    mem_init();//先用malloc函数 申请一大块儿空间，也可使用mmap函数
    mm_init();      //初始化堆

    printf("\\nthe heap = %p\\n", mem_heap);  //输出malloc申请的空间起始地址
    /*打印优化了的分配器使用的单独的私有全局变量它指向序言块儿的下一块*/
    printf("listp=%p\\n\\n", heap_listp); 

    bp=(int *)mm_malloc(a);                 //调用mm_malloc函数申请一块空间
    printf("bp=%p\\n\\n",bp);                 //打印出地址


    m=(int *)mm_malloc(a);                  //再申请一块空间
     mm_free(bp);                       //调用mm_free函数释放第一次申请的空间

    n=(int *)mm_malloc(a);                  //重新申请一块空间
    printf("n=%p\\n",n);                     //打印出地址
    printf("m=%p\\n\\n",m);                   //打印出上一次申请的空间的地址

    return 0;

从显示结果可以看出，mm_malloc函数和mm_free函数分别实现了分配和释放空间功能。

实现分配器的特定格式分别为：
(a).块格式为：字是４字节的对象，双字是８字节的对象
(b).数据结构选择隐式空闲链表　
(c).放置策略为首次适配
(d).分割策略：将空闲块分为两部分。第一部分变成分配块，剩下的变成一个新的空闲块。
(e).合并策略为带边界标记的合并。

对Linux虚拟存储器的介绍大致就说到这里，刚刚学的新知识理解不深，如果有什么理解不对的地方，敬请指出！