jsos

disk.js

(5278B)

 /* ------------  
    disk.js
 
    Requires global.js.
    
    Routines for the host CPU simulation, NOT for the OS itself.  
    In this manner, it's A LITTLE BIT like a hypervisor,
    in that the Document envorinment inside a browser is the "bare metal" (so to speak) for which we write code
    that hosts our client OS. But that analogy only goes so far, and the lines are blurred, because we are using
    JavaScript in both the host and client environments.
 
    This code references page numbers in the text book: 
    Operating System Concepts 8th editiion by Silberschatz, Galvin, and Gagne.  ISBN 978-0-470-12872-5
    ------------ */
 
 /* 
  * The disk stores data.
  *
  * Total storage available is 16,384 bytes with 
  * 4 tracks with 8 sectors with 4 blocks with 64 bytes.
  *
  * Write and Read functions handle data as array, not string.
  */
 function disk() { 
 
   this.TRACKS = 4;
   this.SECTORS = 8;
   this.BLOCKS = 8;
   this.BYTES = 64;
 
   this.init = function() {
     this.output();
   };
 
   /*
    * Reads a single byte from a byte.
    */
   this.readByte = function(tsb,byte) {
     if(this.invalidTSB(tsb) || this.invalidDiskByte(byte)) 
       return undefined;
     
     var data = this.read(tsb);
     if(data == undefined)
       return data;
     return data[byte-1];
   };
 
   /*
    * Reads data from a block.
    */
   this.read = function(tsb) {
     if(this.invalidTSB(tsb)) 
       return []; 
 
     var data = localStorage.getItem(tsb.toString());
     if(data == undefined) return [];
     return data.split(",");
   };
 
   /*
    * Writes a single byte into a block.
    */
   this.writeByte = function(tsb, byte, data) {
     if(this.invalidTSB(tsb) || !isByte(data)) 
       return false; 
 
     var read = this.read(tsb);
     read[byte-1] = data;
     localStorage.setItem(tsb.toString(), read);
     this.output();
     return true;
   };
 
   /*
    * Writes a sequence of bytes into a block and returns
    * any data that didn't fit.
    * @param clear erase everything in the block before writing.
    */ 
   this.write = function(tsb, data, clear) {
     if(this.invalidTSB(tsb) || this.invalidDiskData(data)) 
       return false; 
 
     if(clear) {
       localStorage.setItem(tsb.toString(), "");
       localStorage.setItem(tsb.toString(), data.slice(0,this.BYTES));
     } else {
       localStorage.setItem(tsb.toString(), this.read(tsb.toString()).concat(data.slice(0,this.BYTES)));
     }
     this.output();
 
     if(data.length > this.BYTES)
       return data.slice(this.BYTES, data.length);
     else
       return [];
   };
 
   /*
    * Checks if byte is a valid location in storage.
    */
   this.invalidDiskByte = function(byte) {
     return !isByte(byte) || byte > this.BYTES;
   };
 
   /*
    * Checks if data is valid and can be stored.
    */
   this.invalidDiskData = function(data) {
     for(i=0; i<data.length; i++) {
       var dataHex = parseInt(data[i], 16);
       if(!isByte(dataHex)) { return true; }
     }
     return false;
   };
 
   /*
    * Checks if tsb object has invalid 
    * track, sector, block values.
    */
   this.invalidTSB = function(tsb) {
     if(tsb == undefined) return true;
 
     var t = tsb.track;
     var s = tsb.sector;
     var b = tsb.block;
 
     if(t > this.TRACKS  || t < 1 ||
        s > this.SECTORS || s < 1 ||
        b > this.BLOCKS  || b < 1) return true;
 
     return false;
   };
 
   this.emptyBlock = function() {
     var data = [];
     for(i=0; i<this.BYTES; i++)
       data.push(0);
     return data;
   };
 
   this.output = function() {
     var total = this.BYTES * this.BLOCKS * this.SECTORS * this.TRACKS;
     var available = 0;
     var used = 0;
 
     for(t=1; t<=this.TRACKS; t++)
       for(s=1; s<=this.SECTORS; s++)
         for(b=1; b<=this.BLOCKS; b++) {
           var file = new File(new tsb(t,s,b));
           if(file.available())
             available += this.BYTES;
           else
             used += this.BYTES;
         }
 
     document.getElementById("diskTotal").innerHTML = Math.round((total/1000)*10)/10+" KB";
     document.getElementById("diskUsed").innerHTML = Math.round((used/1000)*10)/10+" KB";
     document.getElementById("diskAvailable").innerHTML = Math.round((available/1000)*10)/10+" KB";
 
     var canvas = document.getElementById("diskChart");
     var ctx = canvas.getContext('2d');
 
     var myColor = ["#ffb78e","#8ED6FF"];
     var myData = [used,available];
 
     function getTotal(){
       var myTotal = 0;
       for (var j = 0; j < myData.length; j++) {
         myTotal += (typeof myData[j] == 'number') ? myData[j] : 0;
       }
       return myTotal;
     }
 
     function plotData() {
       var lastend = 0;
       var myTotal = getTotal();
 
       ctx.clearRect(0, 0, canvas.width, canvas.height);
 
       for (var i = 0; i < myData.length; i++) {
         ctx.fillStyle = myColor[i];
         ctx.beginPath();
         ctx.moveTo(200,150);
         ctx.arc(200,150,150,lastend,lastend+
             (Math.PI*2*(myData[i]/myTotal)),false);
         ctx.lineTo(200,150);
         ctx.fill();
         lastend += Math.PI*2*(myData[i]/myTotal);
       }
     }
 
     plotData();
 
   };
 };
 
 /*
  * Holds a track, sector, block value.
  */
 function tsb(t,s,b) {
   this.track = t;
   this.sector = s;
   this.block = b;
 
   this.toString = function() {
     return this.track.toString()+ 
       this.sector.toString()+ 
       this.block.toString();
   };
 };