操作系统课程设计——页式虚拟存储系统设计

最新推荐文章于 2022-07-31 16:38:47 发布
最新推荐文章于 2022-07-31 16:38:47 发布
阅读量1.3k 收藏 12
点赞数
分类专栏： 设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyy_1998/article/details/82414755
版权

语言：C#

工具：VS2017

代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApp2
{
    public partial class Form1 : Form
    {

        
        int[] Memory = new int[100005];
        int[] vist = new int[10005];
        int[,] process = new int[10005, 10005];
        int[] proPageNum = new int[10005];
        int[,] runad = new int[10005, 10005];
        int[,] processhave = new int[10005, 10005];//暂时分配的页数
        int[] visid = new int[10005];
        int[] que = new int[10005];
        int[] Mpr = new int[10005];
        int frameSize;
        int frameNum;
        string []binaryAd=new string[100];
        int tot,ad;
        int ans = 0;
        int par=0;
        
     

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string kas = textBox1.Text;
            if (kas.Equals(""))
            {
                MessageBox.Show("请输入有效值！");
                return;
            }
            frameSize = int.Parse(kas);
           
            
            kas = textBox2.Text;
            if (kas.Equals(""))
            {
                MessageBox.Show("请输入有效值！");
                return;
            }
            int b = int.Parse(kas);
            if (frameSize == 0)
            {
                MessageBox.Show("非法！");
                return;
            }
            else
            {
                for(int i=0;i<10005;i++)
                {
                    for(int j=0;j<10005;j++)
                    {
                        process[i, j] = -1;
                    }
                }
                frameNum = b / frameSize;
                tot = frameNum;
                MessageBox.Show("内存初始化完成，主存共有" + frameNum + "个物理框。");
                ad = 0;
                int qd = frameSize;
                while(qd!=0)
                {
                    ad++;
                    qd /= 2;
                }
                ad--;
            }
            
            progressBar1.Maximum =b;//设置最大长度值


        }
        private void textBox2_TextChanged(object sender, EventArgs e)
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {
            string s = textBox3.Text;
            if (s.Equals(""))
            {
                MessageBox.Show("请输入有效值！");
                return;
            }
            int id = int.Parse(s);
            string ss = textBox4.Text;
            if (ss.Equals(""))
            {
                MessageBox.Show("请输入有效值！");
                return;
            }
            int size = int.Parse(ss);
            
            if (frameSize==0)
            {
                MessageBox.Show("非法！");
            }
            else
            {
                size = (int)Math.Ceiling((double)size/ frameSize);
                int icv = size;
                if (visid[id] == 1)
                {
                    MessageBox.Show("进程号唯一，请重新输入作业号（从1开始）");
                    return;
                }
                else if (size > tot)
                {
                    MessageBox.Show("主存剩余空间不能装下该作业，请求失败.");
                    return;

                }
                else
                {
                    for(int i=0;i<10005;i++)
                    {
                        process[id, i] = -1;
                    }
                    tot -= size;
                    visid[id] = 1;
                    MessageBox.Show("分配成功！将顺序为此进程分配" + size + "个物理框");
                    proPageNum[id] = size;
                    for (int i = 0, k = 0; i < frameNum && k < size; i++)
                    {
                        if (Memory[i] == 0)
                        {

                            process[id, k] = i;
                            Memory[i] = id;
                            k++;
                        }
                    }
                }
               
                if (progressBar1.Value + icv <= progressBar1.Maximum)
                {
                    progressBar1.Value += icv*frameSize; ;//设置当前值
                }

            }



        }

        private void label5_Click(object sender, EventArgs e)
        {

        }

        private void button3_Click(object sender, EventArgs e)
        {
            string s = string.Empty;
            for (int i = 0; i < frameNum; i++)
            {
                if (Memory[i] == 0) s += " N    ";
                else { s+=" "+Memory[i].ToString()+"    "; }
                if ((i+1 )% 5 == 0)
                {
                    s += "\r\n";
                }
            }
            textBox5.Text = s;
        }

        private void button4_Click(object sender, EventArgs e)
        {
            int processid;
            string s = textBox7.Text;
            if (s.Equals(""))
            {
                MessageBox.Show("请输入有效值！");
                return;
            }
            processid = int.Parse(s);
         string rs = string.Empty;
            if (visid[processid] == 0)
            {
                MessageBox.Show("没有该进程！");

            }
            else
            {
                rs = "     页号     物理框号\r\n\r\n";

                for (int i = 0; i <10005; i++)
                {
                    if (process[processid, i] == -1) continue;
                    rs += "       "+i+"          " + process[processid, i].ToString() + "\r\n";
                }
                textBox6.Text = rs;
            }

        }

        private void 跑进程_Click(object sender, EventArgs e)
        {

        }

        private void button5_Click(object sender, EventArgs e)
        {
            if(radioButton1.Checked==true)
            {
                //MessageBox.Show("FIFO");
                
                
                Mpr = new int[1000];
                vist = new int[1000];
                string s = string.Empty;
                
                if (textBox8.Text.Equals("")|| textBox9.Text.Equals("")||textBox10.Text.Equals(""))
                {
                    MessageBox.Show("请输入有效值！");
                    return;
                }
                int number = int.Parse(textBox8.Text);//进程号
                if(visid[number]==1)
                {
                    MessageBox.Show("进程号唯一，请重新输入。");
                    return;
                 }
                
                int fnum =int.Parse( textBox9.Text);//物理框数
                if(fnum>tot)
                {
                    MessageBox.Show("主存剩余空间不能装下该作业，请求失败.");
                    return;
                }
                visid[number] = 1;
                for (int i = 0; i <10005; i++)
                {
                    process[number, i] = -1;
                }
                for (int i = 0, k = 1; i < frameNum && k <= fnum; i++)
                {
                    if (Memory[i] == 0)
                    {

                        processhave[number,k] = i;
                      
                        k++;
                    }
                }
                string os = textBox10.Text;
                runad = new int[1000, 1000];
                int a = 0;
                int cnt = 0;
               
                for (int i = 0; i < os.Length; i++)
                {
                    if (os[i] != ' ')
                    {
                        a = a * 10 + os[i] - '0';
                    }
                    else
                    {
                        if (a > 0)
                        {
                            runad[number, ++cnt] = a;
                          
                        }
                        a = 0;
                    }

                }
                if (a > 0) runad[number, ++cnt] = a;
               
                int cntt = cnt;

                s += "物理框号  ";
                for (int i = 1; i <= fnum; i++)
                {
                     s+=processhave[number,i].ToString()+" ";
                }

                s += "     状态\r\n\r\n";

                int cas = 0;
                int top = 0;
                int tail = 0;
                int ming = 0;
              
                for (int i = 1; i <= cnt; i++)
                {
                    cas = 0;

                    s += "          " + runad[number, i].ToString() + "| ";
                  
                    if (vist[runad[number,i]]==1)
                    {
                        for (int j = 1; j <= fnum; j++)
                        {
                           
                            s+= Mpr[processhave[number,j]].ToString()+ " ";
                        }
                        s +="    命中\r\n";
                        ming++;
                        continue;
                    }

                    for (int j = 1; j <= fnum; j++)
                    {
                        //cout<<j<<"++"<<number<<"++"<<Memory[processhave[number][j]]<<" ";

                        if (processhave[number, j]!=-1&&Memory[processhave[number,j]] == 0)
                        {
                            process[number,runad[number,i]] = processhave[number,j];
                            Memory[processhave[number,j]] = number;
                            que[tail++] = runad[number,i];
                            Mpr[processhave[number,j]] = runad[number,i];
                            vist[runad[number,i]] = 1;
                            break;
                        }
                        else cas++;
                    }
                    int toppage=0;
                    if (cas == fnum)
                    {
                       toppage = que[top++];
                        // cout<<"++"<<toppage<<endl;
                        vist[toppage] = 0;
                        process[number,runad[number,i]] = process[number,toppage];

                        vist[runad[number,i]] = 1;
                        Mpr[process[number,toppage]] = runad[number,i];
                        que[tail++] = runad[number,i];
                        process[number,toppage] = -1;

                        //cout<<"淘汰的页面"<<endl;
                    }
                    for (int j = 1; j <= fnum; j++)
                    {
                        s+=Mpr[processhave[number,j]].ToString()+ " ";
                    }
                    if (cas == fnum) s += "    置换" + toppage.ToString();
                    else
                    {
                        s += "    直接调页";
                    }
                    s += "\r\n";
                    
                }
                int maxl =0;
                for(int i=0;i<10005;i++)
                {
                    if (process[number, i] != -1) maxl++;
                }
                proPageNum[number] =maxl;
               double hide = Convert.ToDouble(ming)/Convert.ToDouble(cnt);
              
                MessageBox.Show(s+"\r\n利用FIFO置换算法，其中命中"+ming+"次"+"，命中率为"+hide.ToString("0.00"));
                progressBar1.Value += frameSize * fnum;
                tot -= fnum;
            }
            else if(radioButton2.Checked==true)
            {
                //MessageBox.Show("LRU");

                /*fkdsnfgkodsg*/
                Mpr = new int[1000];
                vist = new int[1000];
                string s = string.Empty;

                if (textBox8.Text.Equals("") || textBox9.Text.Equals("") || textBox10.Text.Equals(""))
                {
                    MessageBox.Show("请输入有效值！");
                    return;
                }
                int number = int.Parse(textBox8.Text);//进程号
                if (visid[number] == 1)
                {
                    MessageBox.Show("进程号唯一，请重新输入。");
                    return;
                }

                int fnum = int.Parse(textBox9.Text);//物理框数
                if (fnum > tot)
                {
                    MessageBox.Show("主存剩余空间不能装下该作业，请求失败.");
                    return;
                }
                visid[number] = 1;
                for (int i = 0; i < 10005; i++)
                {
                    process[number, i] = -1;
                }
                for (int i = 0, k = 1; i < frameNum && k <= fnum; i++)
                {
                    if (Memory[i] == 0)
                    {

                        processhave[number, k] = i;

                        k++;
                    }
                }
                string os = textBox10.Text;
                runad = new int[1000, 1000];
                int a = 0;
                int cnt = 0;

                for (int i = 0; i < os.Length; i++)
                {
                    if (os[i] != ' ')
                    {
                        a = a * 10 + os[i] - '0';
                    }
                    else
                    {
                        if (a > 0)
                        {
                            runad[number, ++cnt] = a;

                        }
                        a = 0;
                    }

                }
                if (a > 0) runad[number, ++cnt] = a;

                int cntt = cnt;

                s += "物理框号  ";
                for (int i = 1; i <= fnum; i++)
                {
                    s += processhave[number, i].ToString() + " ";
                }

                s += "     状态\r\n\r\n";

                int cas = 0;
               
                int ming = 0;

                for (int i = 1; i <= cnt; i++)
                {
                    cas = 0;

                    s += "          " + runad[number, i].ToString() + "| ";

                    if (vist[runad[number, i]] == 1)
                    {
                        for (int j = 1; j <= fnum; j++)
                        {

                            s += Mpr[processhave[number, j]].ToString() + " ";
                        }
                        s += "    命中\r\n";
                        ming++;
                        continue;
                    }

                    for (int j = 1; j <= fnum; j++)
                    {
                        //cout<<j<<"++"<<number<<"++"<<Memory[processhave[number][j]]<<" ";

                        if (processhave[number, j] != -1 && Memory[processhave[number, j]] == 0)
                        {
                            process[number, runad[number, i]] = processhave[number, j];
                            Memory[processhave[number, j]] = number;
                     
                            Mpr[processhave[number, j]] = runad[number, i];
                            vist[runad[number, i]] = 1;
                            break;
                        }
                        else cas++;
                    }
                    int toppage = 0;
                    if (cas == fnum)
                    {

                        int pos = i;
                        int knum = 0;
                        while(knum<fnum)
                        {
                            if (runad[number, pos] != runad[number, pos - 1]) knum++;
                            if (knum == fnum)
                            {
                                toppage = runad[number, pos-1];
                                break;
                            }
                            pos--;
                        }

                        vist[toppage] = 0;
                        process[number, runad[number, i]] = process[number, toppage];
                        vist[runad[number, i]] = 1;
                        Mpr[process[number, toppage]] = runad[number, i];
                        process[number, toppage] = -1;

                        //cout<<"淘汰的页面"<<endl;
                    }
                    for (int j = 1; j <= fnum; j++)
                    {
                        s += Mpr[processhave[number, j]].ToString() + " ";
                    }
                    if (cas == fnum) s += "    置换" + toppage.ToString();
                    else
                    {
                        s += "    直接调页";
                    }
                    s += "\r\n";

                }
                int maxl = 0;
                for (int i = 0; i < 10005; i++)
                {
                    if (process[number, i] != -1) maxl++;
                }
                proPageNum[number] = maxl;
                double hide = Convert.ToDouble(ming) / Convert.ToDouble(cnt);

                MessageBox.Show(s + "\r\n利用LRU置换算法，其中命中" + ming + "次" + "，命中率为" + hide.ToString("0.00"));
                progressBar1.Value += frameSize * fnum;
                tot -= fnum;













            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void progressBar1_Click(object sender, EventArgs e)
        {

        }

        private void label6_Click(object sender, EventArgs e)
        {

        }

        private void button6_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        private void panel1_Paint(object sender, PaintEventArgs e)
        {
              
        }
        private Point mousePoint = new Point();
        private void panel1_MouseMove(object sender, MouseEventArgs e)
        {
            base.OnMouseMove(e);
            if (e.Button == MouseButtons.Left)
            {
                this.Top = Control.MousePosition.Y - mousePoint.Y;
                this.Left = Control.MousePosition.X - mousePoint.X;
            }
        }

        private void panel1_MouseDown(object sender, MouseEventArgs e)
        {
            base.OnMouseDown(e);
            this.mousePoint.X = e.X;
            this.mousePoint.Y = e.Y;
        }

      
      

        private void button6_Click_1(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;
        }

        private void button7_Click(object sender, EventArgs e)
        {
            DialogResult result = MessageBox.Show("是否退出？", "操作提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
            if (result == DialogResult.Yes)
            {
                //this.Dispose();
                Application.Exit();
            }
        }

        private void button8_Click(object sender, EventArgs e)
        {
            int id = int.Parse(textBox12.Text);
            int sub = proPageNum[id];
            for (int i = 0; i <10005; i++)
            {
                if(process[id,i]!=-1)
                Memory[process[id,i]] = 0;
                process[id,i] = -1;
            }
            visid[id] = 0;
            tot += proPageNum[id];
            proPageNum[id] = 0;
            MessageBox.Show("回收完毕！");
            progressBar1.Value -= sub * frameSize;
        }

        private void button9_Click(object sender, EventArgs e)
        {
            Dictionary<string, string> M = new Dictionary<string, string>();
            //添加键值对数据,键必须唯一,值可重复
            M.Add("0000", "0");
            M.Add("0001", "1");
            M.Add("0010", "2");
            M.Add("0011", "3");
            M.Add("0100", "4");
            M.Add("0101", "5");
            M.Add("0110", "6");
            M.Add("0111", "7");
            M.Add("1000", "8");
            M.Add("1001", "9");
            M.Add("1010", "A");
            M.Add("1011", "B");
            M.Add("1100", "C");
            M.Add("1101", "D");
            M.Add("1110", "E");
            M.Add("1111", "F");

           

            binaryAd['0'] = "0000";
            binaryAd['1'] = "0001";
            binaryAd['2'] = "0010";
            binaryAd['3'] = "0011";
            binaryAd['4'] = "0100";
            binaryAd['5'] = "0101";
            binaryAd['6'] = "0110";
            binaryAd['7'] = "0111";
            binaryAd['8'] = "1000";
            binaryAd['9'] = "1001";
            binaryAd['A'] = "1010";
            binaryAd['B'] = "1011";
            binaryAd['C'] = "1100";
            binaryAd['D'] = "1101";
            binaryAd['E'] = "1110";
            binaryAd['F'] = "1111";
            int number=int.Parse(textBox13.Text);
           
            string s, ds = "";
            s = textBox11.Text;
         
            int adlen = 10 + ad;
          
            int totalen = (s.Length - 1) * 4;
            for (int i = 0; i < s.Length - 1; i++)
            {
                ds += binaryAd[s[i]];
            }
       
            int pagenum = 0;
            int two = 1;
            string ss = "";
            for (int i = totalen - adlen - 1; i >= 0; i--)
            {
                if (i != totalen - adlen - 1)
                    two *= 2;
                pagenum += two * (ds[i] - '0');
                ss += ds[i];
            }
            //cout<<ss<<endl;
            textBox14.Text = pagenum.ToString();
            //cout << "程序页号:" << pagenum << endl;
            string res = ds.Substring(totalen - adlen, adlen);
            textBox16.Text = res;
            //cout << "偏移地址:" << res << endl;
            if (process[number,pagenum] == -1)
            {
                MessageBox.Show("该程序此页没有调入主存。");
                return;
               // cout << "此页没有调入主存内。" << endl;
            }
            else
            {
                int mappage = process[number,pagenum];
                int mappage2 = mappage;
                textBox15.Text = mappage2.ToString();//物理框号
                ss = "";
                while (mappage!=0)
                {
                    ss += mappage % 2 ;
                    
                    mappage /= 2;
                   
                }


                string sss = "";
                for(int i=ss.Length-1;i>=0;i--)
                {
                    sss += ss[i];
                }
                ss = sss;
                MessageBox.Show(ss);
               // Reverse(ss.begin(), ss.end());
                ss += res;
                //MessageBox.Show(ss);
               
                res = "";

                int ads = ss.Length % 4;
                if(ads>0)
                {
                    ads = 4 - ads;
                }
                    for (int i = 1; i <=ads; i++)
                    {
                        res += '0';
                    }
                
                res += ss;
                //cout << res << endl; 
                //MessageBox.Show(res);
                string ans = "";
                string ws;
                for (int i = 0; i < res.Length; i++)
                {
                    ws= "";
                    ws+= res[i];
                    ws+= res[i + 1];
                    ws+= res[i + 2];
                    ws+= res[i + 3];
                    i += 3;
                    ans += M[ws];
                   

                }
                textBox17.Text = ans+"H";
               // cout << ans << endl;
            }

        }
    }
}

实现结果：

zyy_2017
关注
专栏目录
页式虚拟存储器系统设计java_操作系统-页式虚拟存储器管理系统设计
weixin_31519139的博客
02-28 220
1 voidinitpgc()2 {3 for(int i=0; i4 {5 pgclub[i]=0;6 }7 num=pgcnum/bknum;8 cout<12 {13 surplus=0;14 for(int i=0; i28 }29 cout<42 cout<45 cout<50...
操作系统学习笔记十二(基于分页的虚拟存储系统)
zheng2780071070的博客
02-21 1946
导图 1. 虚拟存储器 1.1 是什么 虚拟存储器是指具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。 1.2 实质 1）就是说，先将进程的一部分装入内存，其余的部分什么时候需要，什么时候请求系统装入，即请求调入。 2）如果请求调入时，没有足够的内存，则由操作系统选择一部分内存中的进程内容移到外存，以腾出空间把当前需要装入的内存调入，即置换。 1.3 优点 1）提高内存利用率 2）提高多道程序度：在进行进程运行的时候，并不是一口气...
操作系统课程设计 存储管理
05-28
#include<stdio.h> #include<string.h> #include<iostream.h> const int MAXSIZE=1000;//定义最大页面数 const int MAXQUEUE=3;//定义页框数 typedef struct node { int loaded; int hit; }page; page pages[MAXQUEUE]; //定义页框表 int queue[MAXSIZE]; int quantity; //初始化结构函数 void initial() { int i; for(i=0;i<MAXQUEUE;i++) { pages[i].loaded=-1; pages[i].hit=0; } for(i=0;i<MAXSIZE;i++) { queue[i]=-1; } quantity=0; } //初始化页框函数 void init() { int i; for(i=0;i<MAXQUEUE;i++) { pages[i].loaded=-1; pages[i].hit=0; } } //读入页面流 void readData() { FILE *fp; char fname[20]; int i; cout<<"请输入页面流文件名:"; cin>>fname; if((fp=fopen(fname,"r"))==NULL) { cout<<"错误,文件打不开,请检查文件名"; } else { while(!feof(fp)) { fscanf(fp,"%d ",&queue[quantity]); quantity++; } } cout<<"读入的页面流:"; for(i=0;i<quantity;i++) { cout<<queue[i]<<" "; } } //FIFO调度算法 void FIFO() { int i,j,p,flag; int absence=0; p=0; cout<<endl<<"----------------------------------------------------"<<endl; cout<<"先进先出调度算法(FIFO)页面调出流:"; for(i=0;i<quantity;i++) { flag=0; for(j=0;j<MAXQUEUE;j++) { if(pages[j].loaded==queue[i]) { flag=1; } } if(flag==0) { if(absence>=MAXQUEUE) { cout<<pages[p].loaded<<" "; } pages[p].loaded=queue[i]; p=(p+1)%MAXQUEUE; absence++; } } absence-=MAXQUEUE; cout<<endl<<"总缺页数:"<<absence<<endl; } //最近最少使用调度算法（LRU） void LRU() { int absence=0; int i,j; int flag; for(i=0;i<MAXQUEUE;i++) { pages[i].loaded=queue[i]; } cout<<endl<<"----------------------------------------------------"<<endl; cout<<"最近最少使用调度算法(LRU)页面流:"; for(i=MAXQUEUE;i<quantity;i++) { flag=-1; for(j=0;j<MAXQUEUE;j++) { if(queue[i]==pages[j].loaded) { flag=j; } } //CAUTION pages[0]是队列头 if(flag==-1) { //缺页处理 cout<<pages[0].loaded<<" "; for(j=0;j<MAXQUEUE-1;j++) { pages[j]=pages[j+1]; } pages[MAXQUEUE-1].loaded=queue[i]; absence++; } else { //页面已载入 pages[quantity]=pages[flag]; for(j=flag;j<MAXQUEUE-1;j++) { pages[j]=pages[j+1]; } pages[MAXQUEUE-1]=pages[quantity]; } } cout<<endl<<"总缺页数:"<<absence<<endl; } //显示 void version() { cout<<" /*******************虚拟存储管理器的页面调度****************/"<<endl; cout<<endl; } void main() { version(); initial(); readData(); FIFO(); init(); LRU(); init(); init(); }
操作系统课程设计分页式虚拟存储管理系统
07-07
c++编译的操作系统课程设计,分页虚拟存储管理和FIFO
深入理解操作系统——虚拟存储详解
weixin_41186611的博客
07-31 1318
因为程序的大小在不断的变大，内存的增长速度远远跟不上程序增大的速度，所以内存需要外存的配合来完成对程序的运行存储。虚拟存储是非连续内存分配的延续，后者是在内存里的存储空间让它不连续，前者是在后者的基础上将一部分内容放在外存中的做法，可以让应用程序有更大的空间可以使用。虚拟存储就是只把部分程序放入内存中，从而运行比物理内存大的程序，它的前提思想是局部性原理。交换技术覆盖是一个程序的内存空间不够，交换是一个程序够用，但由于多道程序的运行，使得另一个程序占用了内存空间，使得之前的空间不够。...
操作系统课程设计——页面置换算法模拟实现
02-24
通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储技术的原理及特点。 设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰...
段式虚拟存储管理系统——操作系统课设
04-28
系统应该包含两个部分，一个部分是按内核代码原则设计的请求分段存储管理系统，由一系列的函数组成；另一个部分是演示系统，调用请求分段存储管理系统的相应函数，以让其运行，同时提供系统的展示界面，可以是GUI...
操作系统段页式课程设计.rar
05-07
依据操作系统课程所介绍的虚拟内存实现方案，按照内核代码的实现原则， 设计和实现一个段页虚拟存储管理系统的模型。 系统包含两个部分，一个部分是按内核代码原则设计的固定分区分配存储管 理系统，由一系列的...
操作系统课程设计——基于JAVA的请求式页面替换算法
12-15
分页式虚拟存储系统是将作业信息的副本存放在磁盘中，当作业被调度投入运行时，不把作业的程序和数据全部装入主存，而仅装入立即使用的页面，在执行过程中访问到不在主存的页面时（比如产生缺页中断）再把它们动态...
操作系统课程设计——存储管理与页面置换算法模拟
资源摘要信息:"该资源为操作系统课程设计的存储管理部分，涉及请求分页管理技术、页面置换算法以及相关数据结构的设计和实现。本课程设计目的在于通过模拟请求分页存储管理，使学生能够深入理解虚拟存储技术的原理与...
OS课设+虚拟存储器（报告+实验完整版）
01-17
高质量操作系统课程设计——虚拟存储器，内涵报告+实验，基于 Android 平台，采用 AndroidStudio 进行开发！！！
C#编写的模拟操作系统虚拟内存分页请求管理
06-13
C#编写的模拟操作系统虚拟内存分页请求管理 计算机操作系统第三版 汤小丹等编著 根据课本算法流程编写 原创
实现请求页式存储管理模拟程序
01-26
编写一个请求页式存储管理模拟程序，通过对页面置换过程的模拟，加深对请求页式存储管理方式基本原理及实现过程的理解。 要求： 1. 从键盘输入页面访问序列及分配给进程的内存块数； 2. 分别采用OPT、FIFO和LRU算法进行页面置换（说明：对于OPT算法，在有多个页面可选的情况下，先淘汰较早进入的页面）。 3. 计算缺页次数及缺页率。 测试用例格式如下： 输入： 算法（1--OPT，2--FIFO，3--LRU） 内存块数 页面序列（页面1,页面2,页面3,...) 输出： 页面变化时内存块装入页面列表1-是否命中/页面变化时内存块装入页面列表2-是否命中/... 缺页次数 其中： 页面变化时内存块装入页面列表：内存块1装入页面,内存块2装入页面,内存块3装入页面...，未装入任何页面时由"-”表示 是否命中：1-命中，0-缺页
操作系统课程设计--虚拟内存
01-25
操作系统课程设计--虚拟内存 操作系统课程设计--虚拟内存
OS课程设计，分页虚拟存储系统设计与实现
09-28
OS课程设计任务：编程实现一个请求分页虚拟存储器演示，该系统至少实现先进先出页面置换算法（FIFO）、最近最少使用算法（LRU），最佳淘汰算法（OPT），进程占用的页框数、页面访问序列可配置，并且实时显示内存占用情况、页表等。 系统运行时，随机产生页面访问序列，选定不同的页面置换算法和页块数，可以实现以上说的所有功能。
操作系统课程设计-页式虚拟存储管理页面置换算法-c++描述
欢迎来到GEEK卷轶浩繁的博客
05-31 8682
1．目的和要求 存储管理的主要功能之一是合理的分配空间。请求页式管理是一种常用的虚拟存储管理技术。本实验的目的是：通过编写和调试请求页式存储管理中页面置换算法的模拟程序以加深对存储管理方案的理解，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换方法。 2．实验内容 阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。 编写程序模拟实现页式虚拟存储管理的最佳页面置换算法。 前提： ...
页式存储管理（模拟操作系统）
coderlyf的博客
12-30 1万+
最近操作系统课程实践要求，我们模拟页式存储管理，起初自己很没有思路，但是在详细的画出整个的流程的时候自己还是发现了一些规律，并且发现可以数组和队列进行模拟，我在自己写程序的时候用的是数组模拟的，当然在程序中，也会有很多的数组表示各种要记录的东西，这就要求你对页式存储管理要相当的熟悉。 这里我简单的讲述一下其中需要模拟的相关信息 1)首先需要将逻辑地址转换为对应的页号以及页内位移(这里我默认页面
存储管理系统课程设计——C语言实现请求页式存储管理模拟系统
weixin_43977664的博客
02-13 1万+
分页存储管理是将一个进程的逻辑地址空间分成若干个大小相等的片，称为页面或页，并为各页加以编号，从0开始，如第0页、第1页等。相应地，也把内存空间分成与页面相同大小的若干个存储块，称为(物理)块或页框(frame)，也同样为它们加以编号，如0#块、1#块等等。在为进程分配内存时，以块为单位将进程中的若干个页分别装入到多个可以不相邻接的物理块中。虚拟内存的作用内存在计算机中的作用很大，电脑中所有运行的程序都需要经过内存来执行，如果执行的程序很大或很多，就会导致内存消耗殆尽。为了解决这个问题，Windows中运用
操作系统存储管理之虚拟存储与分页式虚拟存储系统
热门推荐
总结沉淀
04-24 1万+
虚拟存储实现思路在实际运行过程，把有关作业的全部信息都装入主存储器后，作业执行时实际上不是同时使用全部信息的，有些部分运行一遍便再也不用,甚至有些部分在作业执行的整个过程中都不会被使用到(如错误处理部分)。进程在运行时不用的，或暂时不用的，或某种条件下才用的程序和数据,全部驻留于内存中是对宝贵的主存资源的一种浪费，大大降低了主存利用率。 于是，提出了这样的问题：作业提交时，先全部进入辅助存储器,作
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值