操作系统综合实验验优：OSLab小型操作系统仿真实验（大大小小实验）

最后的大实验快去验优，废话少说，直接开冲：

#include
typedef struct pcb{
	char name[10];
	int ntime;//要求运行时间
	int rtime;//已运行时间
	char estate;//状态
	struct pcb *next;//指针指向下一个进程
}*pointer;
void Creatlist(pointer &head,pointer &f,pointer &l,pointer q[]){
	pointer p;
	head=new pcb;
	head->next=NULL;
	f=head;
	for(int i=1;i<=5;i++){
		p=new pcb; 
		p->next=NULL;
		cout<<"作业名字:"<>p->name;
		cout<<"作业需要运行时间:"<>p->ntime;
		p->rtime=0;
        p->estate='R';
		f->next=p;
		f=f->next;
		q[i]=p;
	}
	f=head->next;
	l=p;
	l->next=f;
}
void Cout(pointer &head,pointer q[])//输出运行的进程及其状态{
	for(int i=1;i<=5;i++){
		cout<<"标识符："<name<<" "<<"要求运行时间："<ntime<<" "<<"已运行时间："<rtime<<"状态："<estate;
		cout<
     pointer p,q;
	 q=l;
	 p=head->next;
	 while((p->next!=p)||(p->ntime!=p->rtime)){
		 p->rtime=p->rtime+1;
		 cout<name<<"已运行时间+1。"<ntime==p->rtime){
			 p->estate='E';
			 cout<name<<"已结束。"<next=p->next;
			 p=q->next;
		 }
		 else{
			 p=p->next;
			 q=q->next;
		 }
		 Cout(head,r);
	 }
}
void main(){
	pointer h,f,l,q[5];
	Creatlist(h,f,l,q);
	Cout(h,q);
	diaodusuanfa(h,f,l,q);
}

（执行结果是类似第二张图片的，下面还有类似的结果，状态栏的R表示未完成，E表示完成）

（4）源程序

#include   
using namespace std;  
#include   
#include   
#include   
//生成begin-end随机数  
int random(int begin,int end){  
    if (begin == 0) return rand() % (end + 1);  
    else return rand() % (end - begin + 1) + begin;  
}  
//生成指令序列  
void make(int* instruction) {  
    int m;  
    int n;   
    for (int i = 0; i < 320; i += 4) {  
        //在[0，319]间随机选取起点m,若m=319，顺序执行一条可能会超出范围  
        m = random(0, 318);  
        //执行地址为m+1的指令  
        instruction[i] = m + 1;  
        n = m + 1;  
        //在[0,m+1]中随机选取一条指令并执行，该指令的地址为m'，若m ≥317，顺序执行2条可能会超出范围  
        do {  
            m = random(0, n);  
        }while(m>=317);  
        //顺序执行一条指令，其地址为m' + 1  
        instruction[i+1]=m;  
        //在后地址[m'+2,319]中随机选取一条指令并执行  
        instruction[i+2]=m+1;  
        //若m=319，顺序执行一条可能会超出范围  
        m = random(m + 2, 318);  
        instruction[i + 3] = m;  
    }  
}   
//指令序列变换为页地址流  
void makePage(int* page, int* instruction) {  
    for (int i = 0; i < 320; i++)  
        page[i] = instruction[i] / 10; //每页存储十条指令 
}  
int main()  
{  
    int instruction[320];  
    int page[320];  
    int replacement[320],i;  
    for ( i = 0; i < 320; i++){  
        replacement[i]=100;  //显示状态
    }  
    int t=0;  
    make(instruction);  
    makePage(page, instruction);  
    cout <<"页面访问顺序为："<> a;  
    int *memory = new int[a];//内存块  
    int *queue = new int[a];//队列：（FIFO）先进先出算法，由此查询需要替换的是哪个页面  
    for ( i = 0; i < a; i++)  
    {  
        memory[i] = 100;  
        queue[i] = 100;//初始化  
    }  
    int count = 0;//缺页次数  
    int flag;//标记  
    int x;//暂时存储队首元素  
    int y;//标记  
    for (int j = 0; j < 320; j++)  
    {  
        for (i = 0; i < a; i++)  
        {  
            if(page[j] == memory[i])  
            {  
                flag = 0;//命中，不缺页  
                break;  
            }  
            flag = 1;  
        }  
        if (flag==1)//缺页  
        {  
            count=count+1;//缺页次数+1  
            for ( i = 0; i < a; i++) //内存块是否全满？  
            {  
                if (memory[i] == 100)//100是初始值，即内存块未全满  
                {  
                    queue[i] = page[j];//直接入队  
                    memory[i] = page[j];//直接进入内存  
                    y = 1;  
                    break;  
                }  
                y = 0;  
            }  
            if (y == 0) {//内存块全满且没有命中，要替换  
                x = queue[0];//队列第一个出列：先进先出  
                replacement[t] = x;  
                t++;  
                for (i = 0; i < a-1; i++) {  
                    queue[i] = queue[i + 1];//队列前移；  
                }  
                queue[a-1] = page[j];//新的页号放在队尾  
                for (i = 0; i < a; i++) {  
                    if (memory[i] == x)  
                        memory[i] = page[j];//找到对应的页号，替换  
                }  
            }  
        }  
        cout << "访问第" << j + 1 << "次后物理块的占有情况：（100表示空，没有存放页号，其余表示存放的页面号）：" << endl;  
        for ( i = 0; i < a; i++) {  
            cout << memory[i] << " ";  
            cout << endl;  
        }  
    }  
    cout << "被置换的页面依次为：" << endl;  
    for ( i = 0; i < 320; i++) {  
        if (replacement[i] != 100)  
            cout << replacement[i] << " ";  
    }  
    cout << endl;  
    cout << "缺页次数:" << count << endl;  
    double p = count / (320 * 1.0);  
    cout << "命中率为：" << (1.0 - p) << endl;  
    system("pause");  
    return 0;  
}  

#define n 4//假定设备类型为4  
#define j 10//假定设备总数为10  
	void init()  {  
	    counts = 6;  
	    OS[0].name = 'P';//未分配均命名为P  
	    OS[0].start = 0;//初始位置0  
	    OS[0].size = 5;  
	    OS[0].flag = 1;//分配标志未分配 = 1  
	    OS[1].name = '1';//未分配命名为P  
	    OS[1].start = 5;//初始位置0  
        OS[1].size = 5;  
	    OS[1].flag = 0;//分配标志已分配 = 0  	  
	    OS[2].name = '3';  
        OS[2].start = 10;  
	    OS[2].size = 4;  
	    OS[2].flag = 0;    
	    OS[3].name = 'P';  
	    OS[3].start = 14;  
	    OS[3].size = 12;  
	    OS[3].flag = 1;  		
	    OS[4].name = '2';  
	    OS[4].start = 26;  
        OS[4].size = 6;  
	    OS[4].flag = 0;    
	    OS[5].name = 'P';  
	    OS[5].start = 32;  
	    OS[5].size = COUNT - 32;  
	    OS[5].flag = 1;  
	}  
	  
	//插入数据  
	void insert(int m, int st, int en)  {  
	    int i;  
	    counts++;//数组长度加一  
	    for (i = counts; i > m; i--)//从插入位 由后往前后移  {  
	        OS[i] = OS[i - 1];  
	    }  
	    OS[m].start = st;//插入  
	    OS[m].size = en;  
	}  
  
	//删除数据  
	void move(int m)  	{  
	    int i;  
	    for (i = m; i < counts - 1; i++)//从删除位 由前往后前移  	    {  
	        OS[i] = OS[i + 1];  
    }  
	    counts--;//数组长度减一  
	}  
	//合并没有分配的相邻块  
	void remove(int m, int st, int en)  	{  
	    if (!OS[m - 1].flag && !OS[m + 1].flag)  
        //如果m前后都已分配 不分配  	    {  
			OS[m].name = 'P';  
	        OS[m].flag = 1;  
	    }  
	    if (OS[m - 1].flag)  
	        //如果m前未分配，后已分配 与前一个合并  	    {  
	        OS[m - 1].size = OS[m - 1].size + en;  
	        move(m);  
	    }  
	    if (OS[m + 1].flag)  
	        //如果m后未分配，前已分配 与后一个合并  	    {  
	        OS[m].size = OS[m].size + OS[m + 1].size;  
	        OS[m].name = 'P';  
	        OS[m].flag = 1;  
	        move(m + 1);  
	    }  
	}  	  
	//输出  
	void show()  	{  
	    int i;  
	    cout << "(名称 起址 长度 状态)" << endl;  
	    for (i = 0; i < counts; i++)  	    {  
	        if (OS[i].flag)//未分配  
	            cout << "P ";  
	        else//已分配  
	            cout << OS[i].name << " ";  
	        cout << " " << OS[i].start << " " << OS[i].size << " ";  
	        //依次输出块的name，起始位置，长度  
	        if (OS[i].flag)  
	            cout << "未分配" << endl;  
	        else  
	            cout << "已分配" << endl;  
	    }  
	}    
	//申请资源  
	int apply()  {  
	    int i = 0;  
	    int applyflag = 0;//标记  
	    while (!applyflag && i < counts)//遍历数组 查找连续的可分配资源是否存在？    {  	       if (OS[i].size >= num && OS[i].flag)//比较块大小、是否已分配来找空间         {  
	            if (OS[i].size == num)//大小相等 直接修改  	           {  
	                OS[i].name = c;  
	                OS[i].flag = 0;  
	            }  
	            else// 偏大 修改信息同时更新原先块为已分配和未分配两部分             {  
	                insert(i + 1, OS[i].start + num, OS[i].size - num);  
	                OS[i + 1].flag = 1;  
	                OS[i + 1].name = 'P';  
	                OS[i].start = OS[i].start;  
	                OS[i].name = c;  
	                OS[i].size = num;  
	                OS[i].flag = 0;  
	            }  
	            applyflag = 1;//申请成功的标记  
	        }  
	        i++;  
	    }  
	    if (applyflag)  	    {  
	        cout << "申请成功" << endl;  
	        return 1;  
	    }  
	    else  	    {  
	        cout << "没有足够大的空闲空间" << endl;  
	        return 0;  
	    }  
	}  	  
	//释放资源  
	int free()  	{  
	    int i = 0;  
	    int freeflag = 0;//标记  
	    while (!freeflag && i < counts)//遍历数组 查找作业是否存在 {  
	        if (OS[i].name == c)//找到作业  	        {  
	            remove(i, OS[i].start, OS[i].size);  
	            freeflag = 1;//修改标记  
	        }  
	        i++;  
	    }  
	    if (freeflag)  	    {  
	        cout << "释放成功" << endl;  
	        return 1;  
	    }  
	    else  	    {  
	        cout << "未找到匹配的进程名称" << endl;  
	        return 0;  
	    }  
	}  	  
	void shengqing(JC *p)  	{  
	    c = p->name;	//申请内存空间  
	    num = p->size;  
	    apply();  
	    show();  
	    cout << endl;  
	}  		  
	void shifang(JC *r)  	{  
	    c = r->name;	//释放上一个的内存空间  
	    num = r->size;  
	    free();  
	    show();  
	    cout << endl;  
	}  	  
	void create(JC *head)  	{  
	    JC *q = new JC();  
	    cout << "依次输入进程名，进程大小，进程到达时间，进程估计运行时间：" << endl;  
	    char name;  
	    int size, tape, ta, ts;  
	    char  printer;  
	    int x = 0;  
	    q->to = x;//完成时间  
	    q->totalTime = x;//周转时间  
	    q->weightTotalTime = x;//带权周转时间  
	    q->flag = 0;//未运行  
	    cin >> name; q->name = name;//名字  
	    cin >> size; q->size = size;//大小  
	    cin >> ta; q->ta = ta;//到达时间  
	    cin >> ts; q->ts = ts;//估计运行时间  
	    head->next = q;  
	    q->next = NULL;  
	}  	  
	void out(JC *p)//输出当前进程状态量  	{  
	    while (p != NULL) {  
	        cout << p->name << " ";  
	        cout << p->ta <<" ";  
	        cout << p->ts <<" ";  
	        cout << p->to <<" ";  
	        cout << p->totalTime <<" ";  
	        cout << p->weightTotalTime <<" ";  
	        cout << endl;  
	        p = p->next;  
	    }  
	}  	  
void operation(JC *t, JC *r)//计算该进程完成时间，周转时间，带权周转时间  	{  
    t->to = (r->to) + (t->ts);//完成时间=上一个运行进程的完成时间+当前进程估计运行的时间  
    t->totalTime = (t->to) - (t->ta);//周转时间=当前进程完成时间-到达时间  
    t->weightTotalTime = (t->totalTime) / ((t->ts)*1.0);//平均周转时间=周转时间/估计运行的时间  	}  
	int main()  	{  
		int i;
	    init();//初始化  
	    JC *head = new JC();  
	    JC *p = head;  
	    JC *r, *t = NULL;  
	    cout << "状态输出格式为：进程名,进程到达时间，进程估计运行时间，进程完成的时间，周转时间，带权周转时间：" << endl;  
	    cout << "内存空间初始分配情况：" << endl;  
	    show();    
	    cout << endl;    
	    cout << "请输入进程总个数" << endl;  
	    int x;  
	    cin >> x;  
	    for (i = 0; i < x; i++)  	    {  
	        create(p);  
	        p = p->next;  
	    }//按到达时间先后创建进程链队  
	    p = head->next;//指向第一个进程  
	    cout << "初始状态" << endl;  
	    out(p);//打印初始状态  
	    cout << "第1次选中进程" << p->name << endl;  
	    p->to = p->ts;  
	    p->totalTime = (p->to) - (p->ta);  
	    p->weightTotalTime = (p->totalTime) / ((p->ts)*1.0);  
	    p->flag = 1;  
	    out(p);    
	    shengqing(p);   
	    cout << endl;    
	    r = p;//r记住前一个已运行的进程  
	    i = 2;  
	    p = p->next;    
	    while (x != 1)  	    {  
	        while (p != NULL)          {  
	            if ((p->flag) != 1)//当前结点指向的进程未运行  	          {  
	                double y;  
	                y = ((r->to) - (p->ta)) / ((p->ts)*1.0);//计算优先权  
	                if (y > priority)  	                {  
	                    t = p;  
	                    priority = y;  
	                }  
	                p = p->next;  
	            }  
	            else if ((p->flag) == 1)  	            {  
	                p = p->next;  
	            }  
	        }  
	        operation(t, r);//计算  
	        cout << "第" << i << "次选中进程" << t->name << endl;  
	        t->flag = 1;  
	        out(head->next);//显示此时进程状态  
	        shifang(r);  
	        cout << endl;  
	        r = t;  
	        shengqing(r);     
	        cout << endl;  
	        x--;  
	        i++;  
	        priority = 0;  
	        p = (head->next);  
	    }  
	    system("pause");  
	    return 0;  
	}  

（7）实验参考文献

EOS 操作系统实验教程 海西慧学编著

上述整体到这里就没了，不过还有一个java操作系统验优程序，放下面：
感兴趣的自己去研究吧

//RAM内存类
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class RAM {
    Scanner input = new Scanner(System.in);
    static IdlePartition idle = new IdlePartition();
    private Integer size;               //总内存大小
    private Integer initialAddress;     //起址
    private Integer endAddress;         //末址
    private Integer blockNum ;          //块数
    private ArrayList blockSize;        //块大小
    private ArrayList blockAddress;     //每块的起址
    private ArrayList blockStatus;      //每块的状态

    public RAM(Integer size, Integer initialAddress) {
        this.size = size;
        this.initialAddress = initialAddress;
        this.endAddress = this.initialAddress + this.size;
        this.blockNum = 10;
        Random random = new Random();
        Integer sum = 0;
        this.blockSize = new ArrayList();
        this.blockAddress = new ArrayList();
        this.blockStatus = new ArrayList();
        for (int i = 0; i < 9; i++) {
            this.blockAddress.add(sum);
            this.blockSize.add(random.nextInt(100)+30);
            sum += (Integer)(this.blockSize.get(i));
            this.blockStatus.add("未分配");
        }
        this.blockSize.add(this.size - sum);
        this.blockAddress.add(sum);
        this.blockStatus.add("未分配");
        Printer();
    }
    public IdlePartition Changing(){
        ArrayList initialAddress1 = new ArrayList(); //起始地址
        ArrayList lenth = new ArrayList();          //长度
        ArrayList status = new ArrayList();          //状态
        for (int i = 0; i < this.blockNum; i++) {
            if (this.blockStatus.get(i) == "未分配"){
                initialAddress1.add(this.blockAddress.get(i));
                lenth.add(this.blockSize.get(i));
                status.add(this.blockStatus.get(i));
            }
        }
        idle.setInitialAddress(initialAddress1);
        idle.setLenth(lenth);
        idle.setStatus(status);
        return idle;
    }
    public void Printer(){
        System.out.println("***********内存分块说明表*************");
        System.out.printf("%-7s%-10s%-10s%-10sn","编号","起址","长度","状态");
        for (int i = 0; i < this.blockNum; i++) {
            System.out.printf( "%2d%10d%s%10d%s%10sn",i+1,this.blockAddress.get(i),"K"
                    ,this.blockSize.get(i) ,"K",this.blockStatus.get(i) );
        }
    }
    public void Printer1(IdlePartition idlePartition){
        System.out.println("***********空闲说明表*************");
        System.out.printf("%-7s%-10s%-10s%-10sn","编号","起址","长度","状态");
        for (int i = 0; i < idlePartition.getStatus().size(); i++) {
            System.out.printf( "%2d%10d%s%10d%s%10sn",i+1,idlePartition.getInitialAddress().get(i),"K"
                    ,idlePartition.getLenth().get(i) ,"K",idlePartition.getStatus().get(i) );
        }
    }

    
    public void FindingIdlePartition(IdlePartition idlePartition,Integer size,Integer a){
        for (int i = 0; i < idlePartition.getStatus().size(); i++) {
            if (size == 0) {
                System.out.println("申请无效！");
                return;
            }
            if ((Integer)(this.blockSize.get(i)) >= size && this.blockStatus.get(i).equals("未分配"))  {
                this.blockStatus.set(i,"作业" + a + "正在使用中");
                if ((Integer)(idlePartition.getLenth().get(i)) == size){
                    this.blockSize.set(i,size);
                    return;
                }else {
                    //使用空间，并建立新的空闲分区
                    this.blockAddress.add(i+1,(Integer)(this.blockAddress.get(i)) + size);
                    this.blockStatus.add(i+1,"未分配");
                    this.blockSize.add(i+1,((Integer)this.blockSize.get(i)) - size);
                    this.blockSize.set(i,size);
                    this.blockNum++;
                    return;
                }
            }
        }
        System.out.println("未找到适当的内存，请重新申请！！！");
    }
    
    public void Applying(Integer i){
        System.out.print("请输入要申请的作业" + i + "占用内存：");
        FindingIdlePartition(idle,input.nextInt(),i);
    }
    
    public void Freeing(Integer i){
        for (int j = 0; j < this.blockNum; j++) {
            if (this.blockStatus.get(j).equals("作业" + i + "正在使用中")){
                this.blockStatus.set(j,"未分配");
             this.blockSize.set(j,(Integer)this.blockSize.get(j)+(Integer)this.blockSize.get(j+1));
                this.blockSize.remove(j+1);
                this.blockAddress.remove(j+1);
                this.blockStatus.remove(j+1);
                this.blockNum--;
                return;
            }
        }
        System.out.println("未找到作业" + i + "正在使用中，请重新输入！！！");
    }

    public ArrayList getBlockAddress() {
        return blockAddress;
    }

    public ArrayList getBlockStatus() {
        return blockStatus;
    }

    public Integer getBlockNum() {
        return blockNum;
    }

    public ArrayList getBlockSize() {
        return blockSize;
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

    public Integer getInitialAddress() {
        return initialAddress;
    }

    public void setInitialAddress(Integer initialAddress) {
        this.initialAddress = initialAddress;
    }

    public Integer getEndAddress() {
        return endAddress;
    }

}
// IdlePartition空闲区类
import java.util.ArrayList;
public class IdlePartition {
    private ArrayList initialAddress; //起始地址
    private ArrayList lenth;          //长度
    private ArrayList status;          //状态
    public IdlePartition() {}
    public ArrayList getInitialAddress() {
        return initialAddress;
    }
    public void setInitialAddress(ArrayList initialAddress) {
        this.initialAddress = initialAddress;
    }
    public ArrayList getLenth() {
        return lenth;
    }
    public void setLenth(ArrayList lenth) {
        this.lenth = lenth;
    }
    public ArrayList getStatus() {
        return status;
    }
    public void setStatus(ArrayList status) {
        this.status = status;
    }
}
//Test测试类
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        RAM ram = new RAM(1024,0);
        ram.Changing();
        ram.Printer1(ram.Changing());
        Scanner input = new Scanner(System.in);
        while(true){
            System.out.println("1、申请t2、释放（输入其它数字退出）");
            System.out.print("请输入要对作业进行的操作序号：");
            switch (input.nextInt()){
                case 1:
                    System.out.print("请输入要申请的作业序号：");
                    ram.Applying(input.nextInt());
                    break;
                case 2:
                    System.out.print("请输入要释放的作业序号：");
                    ram.Freeing(input.nextInt());
                    break;
                default:
                    System.exit(0);
                    break;
            }
            ram.Changing();
            ram.Printer1(ram.Changing());
            ram.Printer();
        }
    }
}