fifoc.cs

用C#写的关于虚拟存储器的算法

using System;
using System.Collections.Generic;
using System.Text;

namespace WindowsApplication1.classes
{
   public class FIFOC
    {


      public List<addInstruction> lla = new List<addInstruction>();
      public Queue<int> qi = new Queue<int>();
      int mm = -1;
       int outnu=-1;
       public FIFOC()
       {
           
       }
       public void mekeFifo(instructionProgram lip)
       {
               int pagenum = lip._pageNumber;
               if (findPageNum(pagenum)==true)
               {
                   makeTrue(pagenum,lip);
               }
               else
               {
                   makeIntrrupt(pagenum,lip);
                   makeTrueAno(pagenum, lip,outnu);

               }

       }
       public bool findPageNum(int pagenum)
       {
           bool rs = false;
           foreach (fifoProgram lp in pageTable.lf)
           {
               int pagenumber = lp._pageNumber;
               int pagemark = lp._pageMark;
               if (pagenum == pagenumber && pagemark == 1)
               {
                   rs = true;
                   return rs;
               }
               else
               {
                   continue;
               }

           }
           return rs;
       }

       //却页中断处理方法
       public void makeIntrrupt(int pagenum, instructionProgram lip)
       {
           if (qi.Count >= 4)
           {
               
               int i = qi.Dequeue();
               foreach (fifoProgram fp in pageTable.lf)
               {
                   if (fp._pageNumber == i)
                   {
                       fp._pageMark=0;
                       mm = fp._memoryNumber;
                       outnu = fp._pageNumber;
                       fp._memoryNumber = 0;
                       continue;
                   }
                  
                   else
                   {
                       continue;
                   }
               }
               foreach (fifoProgram fp in pageTable.lf)
               {
                  
                   if (fp._pageNumber == pagenum)
                   {
                       fp._pageMark = 1;
                       fp._memoryNumber = mm;
                       continue;
                   }
                   else
                   {
                       continue;
                   }
               }
               qi.Enqueue(pagenum);

           }
           else
           {
               foreach (fifoProgram fp in pageTable.lf)
               {
                   if (fp._pageNumber == pagenum)
                   {
                       fp._pageMark = 1;
                   }
               }
               qi.Enqueue(pagenum);

           }

       }

       public void makeTrueAno(int pagenum, instructionProgram lip, int tt)
       {
           if (lip._operateCode.Equals("write"))
           {
               foreach (fifoProgram fp in pageTable.lf)
               {
                   if (fp._pageNumber == pagenum)
                   {
                       fp._ifChange = 1;
                   }
               }
           }
           if (qi.Count <= 3)
           {
               qi.Enqueue(pagenum);
               addInstruction ai = new addInstruction();
               ai._operateCode = lip._operateCode;
               ai._outNumber = tt;
               ai._pageNumber = lip._pageNumber;
               ai._position = makePosition(lip, pagenum);
               lla.Add(ai);

           }
           else
           {

               addInstruction ai = new addInstruction();
               ai._operateCode = lip._operateCode;
               ai._outNumber = tt;
               ai._pageNumber = lip._pageNumber;
               ai._position = makePosition(lip, pagenum);
               lla.Add(ai);
           }
           
       }
       //处理命中方法
       public void makeTrue(int pagenum, instructionProgram lip)
       {
           //if (qi.Count > 4)
           //{
           if (lip._operateCode.Equals("write"))
           {
               foreach (fifoProgram fp in pageTable.lf)
               {
                   if (fp._pageNumber == pagenum)
                   {
                       fp._ifChange = 1;
                   }
               }
           }
           if (qi.Count <=3)
           {
               qi.Enqueue(pagenum);
               addInstruction ai = new addInstruction();
               ai._operateCode = lip._operateCode;
               ai._outNumber = -1;
               ai._pageNumber = lip._pageNumber;
               ai._position = makePosition(lip, pagenum);
               lla.Add(ai);

           }
           else
           {

               addInstruction ai = new addInstruction();
               ai._operateCode = lip._operateCode;
               ai._outNumber = -1;
               ai._pageNumber = lip._pageNumber;
               ai._position = makePosition(lip, pagenum);
               lla.Add(ai);
           }
           
       }
       public int makePosition(instructionProgram lip, int pagenum)
       {
           int rs=0;
           foreach (fifoProgram lp in pageTable.lf)
           {
               int pagenumber = lp._pageNumber;
               int pagemark = lp._pageMark;
               if (pagenum == pagenumber && pagemark == 1)
               {
                   rs = lp._memoryNumber * 128 + lip._unitNumber;
                   return rs;
               }
               else
               {
                   continue;
               }

           }
           return rs;
       }
    }
}