---

ToyVirtualMem.c

/***************************************************************************
                          ToyVirtualMem.c  -  Glue logic to simplify the
    use of virtual memory in the Toy Memory Manager.
                             -------------------
    begin                : Sat Feb 22 2003
    copyright            : (C) 2003 by Tyler Montbriand
    email                : monttyle@heavyspace.ca
 ***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "ToySegment.h"
#include "ToySegmentList.h"
#include "ToyProcess.h"
#include "ToyMemType.h"
#include "ToyMem.h"
#include "ToyMem_Internal.h"
#include "ToyLoad.h"
#include "ToyMemPage.h"
#include "ToyVirtualMem.h"
#include "ToySwap.h"

int TMM_PagingEnabled(ToyMM *tmm)
{
  if((tmm->invPageTable==NULL)||(tmm->pageSize==0))
  {
    return(-1);
  }
  else
  {
   return(0);
  }
}

void TMM_ClearFrameStatus(ToyMM *tmm, int frame)
{
  InvPageTable *ipt=TMM_GetFrame(tmm,frame);
  if(ipt==NULL) return;

  ipt->status=0;
}

void TMM_SetFrameStatus(ToyMM *tmm, int frame)
{
  InvPageTable *ipt=TMM_GetFrame(tmm,frame);
  if(ipt==NULL) return;

  ipt->status=1;
}


void TMM_IncrementLinearScan(ToyMM *tmm)
{
  if(TMM_PagingEnabled(tmm)<0)  return;

  tmm->page++;
  if(tmm->page>=TMM_GetNumPages(tmm))
  {
    tmm->page=0;
  }
  else if(tmm->page<0)
  {
    tmm->page=0;
  }
}

void TMM_MarkPageSwappedOut(ToyMM *tmm,int process,int page)
{
  tmm->processList[process]->pagetable[page].paged=1;
  tmm->processList[process]->pagetable[page].frame=-1;
}

int TMM_PageSwappedIn(ToyMM *tmm, int process, int page)
{
  PageTable *pt=TMM_GetPage(tmm,process,page);
  if(pt==NULL)          return(-1);
  else if(pt->paged==1) return(-1);
  else if(pt->frame<0)  return(-1);
  else                  return(0);
}

int TMM_PageSwappedOut(ToyMM *tmm, int process, int page)
{
  PageTable *pt=TMM_GetPage(tmm,process,page);
  if(pt==NULL)          return(-1);
  else if(pt->paged==0) return(-1);
  else if(pt->frame>=0) return(-1);
  else                  return(0);
}

int TMM_CountFreePages(ToyMM *tmm, int process)
{
  int n=-1;
  int freepages=0;
  Process *proc=TMM_GetProcess(tmm,process);
  if(proc==NULL)                           return(-1);
  else if(TMM_PagingEnabled(tmm)<0)        return(-1);

  for(n=0; n<TMM_GetNumPages(tmm); n++)
  {
    if(TMM_PageFree(tmm,process,n)>=0) freepages++;
  }

  return(freepages);
}

InvPageTable *TMM_GetFrame(ToyMM *tmm, int frame)
{
  if(tmm==NULL)                           return(NULL);
  else if(TMM_PagingEnabled(tmm)<0)       return(NULL);
  else if(frame<0)                        return(NULL);
  else if(frame>=TMM_GetNumPages(tmm))    return(NULL);
  else return(tmm->invPageTable+frame);
}

int TMM_FrameFree(ToyMM *tmm, int frame)
{
  if(TMM_PagingEnabled(tmm)<0)            return(-1);
  else if (frame<0)                       return(-1);
  else if(frame>TMM_GetNumPages(tmm))     return(-1);
  else if(tmm->invPageTable[frame].ID>=0) return(-1);
  else                                    return(0);
}


PageTable *TMM_GetPage(ToyMM *tmm, int process, int page)
{
  Process *proc=TMM_GetProcess(tmm,process);
  if(proc==NULL)                          return(NULL);
  else if(TMM_PagingEnabled(tmm)<0)       return(NULL);
  else if(proc==NULL)                     return(NULL);
  else if(page<0)                         return(NULL);
  else if(page>=TMM_GetNumPages(tmm))     return(NULL);
  else return(proc->pagetable+page);
}
                                        
int TMM_PageFree(ToyMM *tmm, int process, int page)
{
  PageTable *ptable=TMM_GetPage(tmm,process,page);
  if(ptable==NULL)                        return(-1);
  else if(ptable->frame>=0)               return(-1);
  else if(ptable->paged>0)                return(-1);
  else                                    return(0);
}

int TMM_GetNumPages(ToyMM *tmm)
{
  if(TMM_PagingEnabled(tmm)<0)  return(-1);
  else                          return(tmm->memSize/tmm->pageSize);
}

int TMM_FrameRecentlyUsed(ToyMM *tmm, int frame)
{
  if(TMM_FrameFree(tmm,frame)>=0)             return(-1);
  else if(tmm->invPageTable[frame].status==0) return(-1);
  else                                        return(0);
}


int TMM_FindFreeFrame(ToyMM *tmm)
{
  int iterations=-1;
  int maxpages=TMM_GetNumPages(tmm);
  if(maxpages<0)  return(-1);

  /* Avoid infinite loop */
  while(iterations<maxpages)
  {
    int frame=tmm->page;
    iterations++;

    if(TMM_FrameFree(tmm,tmm->page)>=0)
    {
      TMM_IncrementLinearScan(tmm);
      return(frame);
    }
    else if(tmm->invPageTable[tmm->page].status==0)
    {
      int process=tmm->invPageTable[tmm->page].ID;
      int page=tmm->invPageTable[tmm->page].page;

      if(TMM_SwapOut(tmm,process,page)<0)
      {
        printf("Swapping error in linear scan!\n");
        printf("Email me at monttyle@heavyspace.ca and tell me how you caused this\n");
        abort();
      }

      TMM_IncrementLinearScan(tmm);
      return(frame);
    }
    else
    {
      TMM_ClearFrameStatus(tmm,tmm->page);
      TMM_IncrementLinearScan(tmm);
    }
  }
  /* Didn't find any frames, return error */        
  return(-1);
}

int TMM_GetNumFrames(ToyMM *tmm, int length)
{
  if(tmm==NULL)                       return(-1);
  else if(TMM_PagingEnabled(tmm)<0)   return(-1);
  else if(length<0)                   return(-1);
  else if(length<tmm->pageSize)       return(1);
  else if((length%tmm->pageSize)!=0)  return((length/tmm->pageSize)+1);
  else                                return(length/tmm->pageSize);  
}

int TMM_GetFramedSize(ToyMM *tmm, int size)
{
  int frames=TMM_GetNumFrames(tmm,size);

  if(frames<0)  return(-1);
  else          return(frames*tmm->pageSize);
}

int TMM_GetFrameNum(ToyMM *tmm, int process, int page)
{
  Process *proc=TMM_GetProcess(tmm,process);
  
  if(proc==NULL)                              return(-1);
  else if(page>=(tmm->memSize/tmm->pageSize)) return(-1);
  else return(proc->pagetable[page].frame);
}

int TMM_GetRealAddress(ToyMM *tmm, int process, int vaddr)
{
  int page=-1;
  int offset=-1;
  int frame=-1;
  int raddr=-1;

  /* Paging not enabled?  It **is** a real address. */
  if(TMM_PagingEnabled(tmm)<0)  return(vaddr);

  offset=vaddr%tmm->pageSize;    
  page=vaddr/tmm->pageSize;

  /* If the current page is swapped out, we gotta swap it back in */
  if(TMM_PageSwappedOut(tmm,process,page)>=0)
  {
    frame=TMM_FindFreeFrame(tmm);
    if(frame<0) return(-1);
    if(TMM_SwapIn(tmm,process,page,frame)<0)  return(-1);
  }
    
  frame=TMM_GetFrameNum(tmm,process,page);

  if(frame<0)   return(-1);
  TMM_SetFrameStatus(tmm,frame);
    
  raddr=(frame*tmm->pageSize)+offset;
  return(raddr);
}

void TMM_EmptyFrame(ToyMM *tmm, int frame)
{
  int n=-1;
  int addr=frame*tmm->pageSize;

  /* Mark every mem element in the frame as empty */
  for(n=0; n<tmm->pageSize; n++)
  {
    /* Mark type as empty */
    tmm->mem[addr+n].type=DATA_ERROR;
  }
}

void TMM_AssignFrame(ToyMM *tmm, int process, int frame, int page)
{
  Process *proc=TMM_GetProcess(tmm,process);
  if(proc==NULL)  return;
  
  /* Set all memory in frame to empty */
  TMM_EmptyFrame(tmm,frame);

  /* Update the Inverted Page Table */
  tmm->invPageTable[frame].ID=process;
  tmm->invPageTable[frame].page=page;
  tmm->invPageTable[frame].status=1;

  /* Update the Page Table */
  proc->pagetable[page].frame=frame;  
  proc->pagetable[page].paged=0;
}

void TMM_FreeFrame(ToyMM *tmm, int process, int page)
{
  Process *proc=TMM_GetProcess(tmm,process);
  if(proc==NULL)  return;

  if(proc->pagetable[page].frame!=-1)
  {
    TMM_EmptyFrame(tmm,proc->pagetable[page].frame);
    tmm->invPageTable[proc->pagetable[page].frame].ID=-1;
    proc->pagetable[page].frame=-1;
    proc->pagetable[page].paged=0;
  }
}

---