设计一个虚拟存储区和内存工作区，并使用FIFO和LRU算法计算机访问命中率。
<程序设计>
    先用srand()函数和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算相应的命中率。
<程序1>
#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL 0

#define total_instruction 320/*共320条指令*/
#define total_vp 32/*虚存页共32*/
#define clear_period 50

typedef struct{/*页面类型*/
    int pn, pfn, counter, time;/*页号、页面号、一个周期内访问该页面的次数、访问时间*/
}pl_type;
pl_type pl[32];

typedef struct pfc_struct{/*页面控制结构*/
    int pn, pfn;
    struct pfc_struct *new;
}pfc_type;
pfc_type pfc[32];
pfc *freepf_head,*busypf_head,*busypf_tail;/*空闲页头指针，忙页头指针，忙页尾指针*/

int disaffect; /*缺页次数*/
int a[total_instruction];/*指令流数组*/
int page[total_instruction], offset[total_instruction];/*每条指令的页和页内偏移*/

void initialize( );
void FIFO( );
void LRU( );
/*void OPT( );根据需要可选*/

void main(){
    int s,i,j;
    int s,i,j;
    srand(10*getpid());/*用进程号作为初始化随机数队列的种子*/
    s=(float)319*rand()/32767/3267/2+1;
    for(i=0;i<total_instruction;i+=4){/*产生指令队列*/
        if(s<0||s>319){
            printf("when i==%d,error,s==%d\n",i,s);
            exit(0);
        }
        a[i]=s;/*任意选一指令访问点m*/
        a[i+1]=a[i]+1;/*顺序执行下一条指令*/
        a[i+2]=(fload)a[i]*rand()/32767/32767/2;/*执行前地址指令m'*/
        a[i+3]=a[i+2]+1;/*顺序执行一条指令*/
        s=(float)(318-a[i+2])*rand()/32767/32767/2+a[i+2]+2;
        if((a[i+2]>318)||(s>319)) printf("a[%d+2,a number which is:%d and s=%d\n",i,a[i+2],s);        
    }
    for(i=0;i<total_instruction;i++){/*将指令序列变成页地址流*/
        page[i]=a[i]/10;
        offset[i]=a[i]%10;
    }
    for(i=4;i<=32;i++){/*用户内存工作区从4个页面到32个页面*/
        printf("%2d page frames",i);
        FIFO(i);/*计算用FIFO置换时第i个页面时的命中率*/
        LRU(i);/*计算用LRU置换时第i个页面时的命中率*/
        /*此处也可添加其它函数，如OPT()*/
        printf("\n");
    }
}

void initialize(total_pf)/*初始化相关数据结构*/
int total_pf;/*用户进程的内存页面数*/
{
    int i;
    disfeffect=0;
    for(i=0;i<total_vp;i++){
        pl[i].pn=i;
        pl[i].pfn=INVALID;/*置页面控制结构中的页号、页面号为空*/
        pl[i].counter=0;/*置页面控制结构中的访问次数为0*/
        pl[i].time=-1;    /*置页面控制结构中的时间为-1*/
    }
    for(i=0;i<total_pf-1;i++){
        pfc[i].next=&pfc[i+1];
        pfc[i].pfn=i;
    }
    pfc[total_pf-1].next=NULL;
    pfc[total_pf-1].pfn=total_pf-1;
    freef_head=&pfc[0];   
}

void FIFO(total_pf)
int total_pf;/*用户进程的内存页面数*/
{
    int i,j;
    pfc_type *p;
    initialize(total_pf);/*初始化相关数据结构*/
    busypf_head=busypf_tail=NULL;
    for(i=0;i<total_instruction;i++){
        if(pl[page[i]].pfn==INVALID){/*页面失效*/
            diseffect+=1;/*失效次数*/
            if(freef_head==NULL){/*无空闲页面*/
                p=busypf_head->next;
                p1[busypf_head->pn].pfn=INVALID;
                freepf_head=busypf_head;/*释放忙页面队列的第一个页面*/
                freepf_head->next=NULL;
                busypf_head=p;
            }
            p=freepf_head->next;/*按FIFO方式调新页面入内存*/
            freepf_head->next=NULL;
            freepf_head->pn=page[i];
            pl[page[i]].pfn=freepf_head->pfn;
            if(busypf_tail==NULL) busypf_head=busypf_tail=freepf_head;
            else{
                busypf_tail->next=freepf_head;/*free页面减少一个*/
                busypf_tail=freepf_head;
            }
            freepf_head=p;
        }   
    }
    printf("FIFO:%6.4f",1-(float)diseffect/320);   
}

void LRU(total_pf)
int total_pf;
{
    int min,minj,i,j,present_time;
    initialize(total_pf);
    present_time=0;
    for(i=0;i<total_instruction;i++){
        if(pl[page[i]].pfn==INVALID){/*页面失效*/
            diseffect++;
            if(freepf_head==NULL){/*无空闲页面*/
                min=32767;
                for(j=0;j<total_vp;j++)/*找出time的最小值*/
                    if(min>pl[j].time&&pl[j].pfn!=INVALID){
                        min=pl[j].time;
                        minj=j;
                    }
                freepf_head=pfc[pl[minj].pfn];/*腾出一个单元*/
                pl[minj].pfn=INVALID;
                pl[minj].time=-1;
                free_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;/*有空闲页面，改为有效*/
            pl[page[i]].time=present_time;
            freepf_head=freef_head->next;/*减少一个free页面*/
        }
        else pl[page[i]].time=present_time;/*命中，则增加该单元的访问次数*/
        present_time++;
    }
    printf("LRU:%6.4f",1-(float)diseffect/320);
}
<分析>
从结果可知，在内存页面数较少（小于15）时，两种算法的命中率差别不大，都是60%左右；在内存页面数为16~28之间时，两者的命中率有了一定的差别，LRU的命中率更高；当内存页面数大于28个页面时，由于用户进程的所有指令基本上都已经装入内存，从而命中率大增，故算法之间的差别不大。

请问如何把它改在VC 环境下来运行？？