jsos

memoryManager.js

(5450B)

 /*
  * Manages the OS memory.
  */
 function MemoryManager() {
   this.processes = new Array(); // array of pcb's
   
   /*
    * Loads a hex program into memory.
    * @param hex an array of bytes
    */
   this.load = function(hex, priority) {
     var pid = this.getAvailablePage();
     var availableSwap = undefined;
 
     // if we get available page
     if (pid > -1) {
       var page = pid % TOTAL_PAGES;
       var bytes = this.hex2Dec(hex);
       var base = page * MAX_MEMORY_PROGRAM;
       var limit = (page+1) * MAX_MEMORY_PROGRAM - 1;
       var process = new pcb(pid, PCB_STATE_RESIDENT, base, limit, base, priority);
       this.processes[page] = process;
       _Memory.allocateBytes(bytes, base);
       this.output();
       return pid;
     } else {
       availableSwap = this.getAvailableSwap();
     }
 
     // if we get available swap
     if (availableSwap.pid > -1) {
       pid = availableSwap.pid;
       var block = availableSwap.tsb;
 
       if(block == undefined) {
         block = krnFilesystemDriver.getAvailableBlock();
         krnFilesystemDriver.initBlockSwap(block);
       }
 
       var page = pid - (((pid - TOTAL_PAGES) % (SWAPPABLE + 1)) + 1); 
       var bytes = this.hex2Dec(hex);
       var base = page * MAX_MEMORY_PROGRAM;
       var limit = (page+1) * MAX_MEMORY_PROGRAM - 1;
       var process = new pcb(pid, PCB_STATE_RESIDENT, base, limit, base, priority);
       process.tsb = block;
 
       this.processes[pid] = process;
       var swap = new Swap(block);
       swap.write(swap.data().slice(0, swap.HEADER_SIZE).concat(this.dec2Hex(hex)), true);
       this.output();
     }
 
     return pid;
   }
 
   /*
    * Gets the next available page in memory. Returns -1 if 
    * there is no page available.
    */
   this.getAvailablePage = function() {
     for(var i=0; i<TOTAL_PAGES; i++) {
       var p = this.processes[i];
       if(p == undefined)
         return i;
       if(p.state == PCB_STATE_TERMINATED)
         return p.PID;
     }
     return -1;
   }
 
   /*
    * Gets the next available swap in disk. Returns -1 if 
    * there is no swap available.
    */
   this.getAvailableSwap = function() {
     for(var i=TOTAL_PAGES; i<TOTAL_PAGES+SWAPPABLE; i++) {
       var p = this.processes[i];
       if(p == undefined) {
         return {pid: i, tsb: undefined};
       }
       if(p.state == PCB_STATE_TERMINATED) {
         return {pid: p.PID, tsb: p.tsb};
       }
     }
     return {pid: -1, tsb: {}};
   }
 
   /*
    * Swaps an entire process by "rolling out" or transfering 
    * a process to swap files in the disk drive. 
    */
   this.rollOut = function(tsb, pid) {
     var pid = TOTAL_PAGES-1 != pid ? TOTAL_PAGES-1 : TOTAL_PAGES; //TODO fixed
     var process = this.processes[pid];
     process.tsb = tsb;
 
     var swap = new Swap(tsb);
     var data = _Memory.deallocateBytes(process.base, process.limit);
     var hex = this.dec2Hex(data);
 
     swap.write(swap.data().slice(0, swap.HEADER_SIZE).concat(hex), true);
   }
 
   /*
    * Swaps an entire process by "rolling in" or transfering 
    * a process to memory from swap files in the disk drive. 
    */
   this.rollIn = function(process) {
     var swap = new Swap(process.tsb);
     var data = swap.payload();
 
     this.rollOut(process.tsb, process.PID);
     process.tsb = undefined;
 
     var bytes = this.hex2Dec(data);
     _Memory.allocateBytes(bytes, process.base);
   }
 
   /*
    * Converts an array of hexadecimals to an array of decimals.
    */
   this.hex2Dec = function(hex) {
     for(var i=0; i<hex.length; i++) 
        hex[i] = parseInt(hex[i], 16);
     return hex;
   }
 
   /*
    * Converts an array of decimals to an array of hexadecimals.
    */
   this.dec2Hex = function(hex) {
     for(var i=0; i<hex.length; i++) {
        if(hex[i] != undefined)
          hex[i] = hex[i].toString(16);
     }
     return hex;
   }
 
   /*
    * Outputs pcb attributes of each process in control of this 
    * OS's memory manager to the interface.
    */
   this.output = function() {
     var div = document.getElementById("processesTable");
     var html = 
           '<tr><th>pid</th><th>state</th><th>base</th>' +
           '<th>limit</th><th>PC</th><th>ACC</th><th>X</th>' +
           '<th>Y</th><th>Z</th><th>P</th></tr>';
 
     for(var i=0; i<this.processes.length; i++) {
       var p = this.processes[i];
       var base=p.base-((p.PID%TOTAL_PAGES)*MAX_MEMORY_PROGRAM);
       var limit=p.limit-((p.PID%TOTAL_PAGES)*MAX_MEMORY_PROGRAM);
       var pc=p.PC-((p.PID%TOTAL_PAGES)*MAX_MEMORY_PROGRAM);
  
       if(p.PID >= TOTAL_PAGES) {
         base=p.base-((p.PID-(((p.PID - TOTAL_PAGES) % (SWAPPABLE + 1)) + 1))*MAX_MEMORY_PROGRAM);
         limit=p.limit-((p.PID-(((p.PID - TOTAL_PAGES) % (SWAPPABLE + 1)) + 1))*MAX_MEMORY_PROGRAM);
         pc=p.PC-((p.PID-(((p.PID - TOTAL_PAGES) % (SWAPPABLE + 1)) + 1))*MAX_MEMORY_PROGRAM);
       }
         
       html += '<tr>';
       html += '<td>'+p.PID+'</td>';
       html += '<td>'+p.state+'</td>';
       html += '<td>'+pad((base).toString(16),4).toUpperCase()+'</td>';
       html += '<td>'+pad((limit).toString(16),4).toUpperCase()+'</td>';
       html += '<td>'+pad((pc).toString(16),4).toUpperCase()+'</td>';
       html += '<td>'+pad(p.ACC.toString(16),2).toUpperCase()+'</td>';
       html += '<td>'+pad(p.X.toString(16),2).toUpperCase()+'</td>';
       html += '<td>'+pad(p.Y.toString(16),2).toUpperCase()+'</td>';
       html += '<td>'+p.Z.toString(16)+'</td>';
       html += '<td>'+p.priority.toString(16)+'</td>';
       html += '</tr>';
     }  
     div.innerHTML = html;
   }
 }