模拟LRU算法&通道处理算法

最近写了两个程序，模拟操作系统的算法，只是基本实现了课本上的基本功能，实际应该是很复杂的。

 

模拟LRU页面置换算法：

 

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

#define TN 3             //分配给该程序的主存页数
#define PN 10             //地址流

typedef struct PAGE{
    int kPage;   //the kth line 分配给该程序的主存页数的索引
    int aPage;   //address page 程序页号
    int cnt;     //到当前页地址的距离计数器
}PAGE;

PAGE pg[PN];     //页地址流
int page[TN];    //主存页面表

/*页面命中和替换页面时都需要初始化调入的页面*/
void init(int k, int p){
    int i;
    for(i=0;i<k;i++){
        if(pg[i].aPage==p)
            pg[i].cnt=1;
    }   
}

/*查找页面表中最大的计数器,返回对应的索引*/
int findMax(){
    int ans=0, max_cnt=-1, cnt, index;
    int i,j;
    for(i=0;i<TN;i++) {
        /*在主存页面表中查找与给定页地址流页面相等的页面*/
        for(j=0;j<PN;j++){
            if(page[i] == pg[j].aPage){
                cnt = pg[j].cnt;
                break;
            }
        }
        if(max_cnt < cnt) {  
            max_cnt = cnt;
            ans = i;
            index = j;
        }
    } 
    return ans;
}

void LRU(){
    int i,p,k=0;  /*p：当前页面，k：页地址流全局索引*/
    int replaceIndex;
    int old;

    while(~scanf("%d",&p)){
        int inserted=0, hit=0;
            
        pg[k].aPage=p;
        /*预处理*/
        for(i=0;i<=k;i++) {
            pg[i].cnt+=1;
        }
        if(k == 0){
            printf("\n输出结果:\n\n");
            printf("时间\t页地址\t操作\t主存索引\t源页面\t目标页面\n");    
        }
        printf("%d\t%d\t",k+1,p);
        for(i=0;i<TN;i++) {
            if(p == page[i]) {      //命中
                pg[k].cnt=1;
                inserted=1;         //相当于调进
                hit=1;
                printf("命中\t%d\t\t%d\t%d",i+1,p,p);
                break;
            }
            if(!page[i]){           //有空余页
                page[i]=p;
                pg[k].kPage=i;
                pg[k].cnt=1;
                inserted=1;
                printf("调进\t%d\t\t-\t%d",i+1,p);
                break;
            }
        }
        if(hit == 1) init(k,p);
        
        /*替换操作,调进页面设置*/
        if(!inserted){
            init(k,p);
            replaceIndex=findMax();
            old=page[replaceIndex];
            page[replaceIndex]=p;     //置换
            printf("替换\t%d\t\t%d\t%d",replaceIndex+1,old,p);
        }
        printf("\n");
        k++;
    }
}
int main(){
    memset(page,0,sizeof(page));        
    memset(pg,0,sizeof(pg));        
    printf("输入页地址流:\n");
    LRU();
    return 0;
}

 测试结果:

 

字节多路通道响应和设备处理：

 

#include <iostream>
using namespace std;

#define N 5        //设备数目
#define GAP 10       //通道处理时间

struct Device{
    int cycle;       //设备周期
    int start;     //起始时间
    int priority;  //优先级
    bool applied;  //是否提出申请
}d[N];

/*初始化各设备起始状态*/
void init() {
    for(int i=0; i < N; i++) {
        d[i].applied = false;
        cin>>d[i].start>>d[i].cycle>>d[i].priority;
    }
}

int cmp(const void *a, const void *b){
    int c=((Device *)b)->priority - ((Device *)a)->priority;        //按优先级排序
    if(c == 0) return ((Device *)a)->start - ((Device *)b)->start;  
    else if(c > 0) 
            return 1;
    else return -1;
}

void swap(Device **a, Device *b){
    Device tmp;
    tmp.cycle = (*a)->cycle;
    tmp.priority = (*a)->priority;
    tmp.start = (*a)->start;
    tmp.applied = (*a)->applied;

    (*a)->cycle = b->cycle;
    (*a)->priority = b->priority;
    (*a)->start = b->start;
    (*a)->applied = b->applied;
    
    b->cycle = tmp.cycle;
    b->priority = tmp.priority;
    b->start =tmp.start;
    b->applied = tmp.applied;
}

/*p最终指向通道选中的设备,selected是选中设备的索引*/
void Quicksort(Device **p, int &selected) {
    for(int i=0; i<N; i++) {
        if(d[i].applied == true && selected!=i) {                       //只对申请的设备排序
            if(d[i].priority > (*p)->priority) {
                swap(p, &d[i]); 
                selected=i;
            }
            else if(d[i].priority == (*p)->priority){
                if(d[i].start < (*p)->start)
                    swap(p, &d[i]);
                    selected=i;
            }
        }
    }
}

void check_lose(int handle_time,int selected){
    for(int i=0; i<N; i++) {
        if(i!=selected) {
            int next_t=d[i].start+d[i].cycle; //下次申请时间
            if(handle_time>=next_t){
                int cnt=(handle_time-d[i].start)/d[i].cycle;  //连续cnt次丢失信息

                /*判断并输出第几号设备在第几次申请未得到响应*/
                printf("      %d号设备第",i);
                int k=0;
                int c=d[i].start/d[i].cycle;  //起始计数器
                while(k<cnt){
                    printf("%d ",c++);
                    k++;
                }
                printf("次申请未得到响应!\n");
                d[i].start+=cnt*d[i].cycle;
            }
        }
    }
}

void handle(int end_time){
    int t,j,i=0;
    int selected;                  //选中设备的索引
    Device *p;                      //应选中的设备
    for(t = 0; t<end_time; t+=GAP){
        int k=0;
        printf("第%d周期: ",++i);
        for(j = 0; j<N; j++) {
            selected=0;
            if(d[j].start <= t) { 
                d[j].applied=true;  //申请
                if(k==0) {
                    p=&d[j];   //暂存第一个提交申请的设备
                    selected=j;
                }
                k++;
            }
        }

        if(k == 0) {
            printf("无设备提出申请!\n");
        }
        else{
            Quicksort(&p,selected);
            printf("%d号设备被选中\n",selected);
            check_lose(t,selected);

            /*选中的设备的后处理*/
            p->applied = false;
            p->start+=p->cycle;            
        }
    }
}

int main(){
    init();
    int end_time;
    scanf("%d",&end_time);
    printf("\nresult:\n");
    handle(end_time);
    return 0;
}