Processo è ora un oggetto. Aggiunti percorsi di esecuzione diversi dall'esecuzione sequenziale di tutte le pagine. Inizio lavoro su gestione CPU (Processo.esecuzioneCicloSingolo)

index.html

@@ -18,39 +18,67 @@
             istanteAllocazione: -1,
             numeroPagina: -1
         }
-		var processo = {
-			pid: 1,
-			tempoDiCompletamento: 0,
-			nPagine: 0,
-            pagine: 0, //vettore contenente gli indirizzi di tutte le pagine in ordine
-            paginaDaAllocare: 0
-		}
         var processi = new Array();
-		function generaProcesso(){
+        var processiTerminati = new Array();
-			var nuovo=clone(processo);
+		function Processo(){
-            processi.push(nuovo);
+            var pidNuovo=1;
-			nuovo.tempoDiCompletamento=Math.floor(Math.random()*10)+3;
+            processi.push(this);
-			nuovo.nPagine=Math.floor(Math.random()*10)+3;
+            this.pid=pidNuovo;
-            nuovo.pagine=new Array(nuovo.nPagine);
+            this.pagine=new Array(Math.floor(Math.random()*10)+3);  //vettore contenente gli indirizzi di tutte le pagine in ordine
-            for(var i=0; i<nuovo.nPagine; i++){
+            for(var i=0; i<this.pagine.length; i++){
-                nuovo.pagine[i]=-1;
+                this.pagine[i]=-1;
             }
-            processo.pid++;
+            this.percorsoAllocazione=new Array(Math.floor(Math.random()*10)+this.pagine.length);
-            scriviLog("Nuovo processo: pid="+nuovo.pid+" memoria="+nuovo.nPagine+" tempo="+nuovo.tempoDiCompletamento);
+            for(var i=0; i<this.percorsoAllocazione.length; i++){
-			return nuovo;
+                this.percorsoAllocazione[i]=Math.floor(Math.random()*this.pagine.length);
             }
-		function allocaSegmento(proc){
+            for(var i=0; i<this.pagine.length; i++){
-			//ricerca memoria libera tramite first-fit
+                if(this.percorsoAllocazione.indexOf(i)==-1){
-            if(proc.paginaDaAllocare>=proc.nPagine){
+                    this.percorsoAllocazione.push(i);
-                scriviLog("Processo "+proc.pid+": tutte le pagine sono allocate");
+                }
+            }
+            this.stato="disponibile";
+            this.contatorePercorso=0;
+            scriviLog("Nuovo processo: pid="+this.pid+" pagine="+this.pagine.length+" lunghezzaPercorso="+this.percorsoAllocazione.length);
+            pidNuovo++;
+		}
+        Processo.prototype.cambiaStato = function (str) {
+            this.stato=str;
+            scriviLog("Processo "+this.pid+": "+this.stato);
+        };
+        Processo.prototype.termina = function (){
+            this.cambiaStato("terminazione");
+            (this.pagine).forEach(function(item, index){
+                resettaPagina(item);
+            });
+            this.cambiaStato("terminato");
+            var i = processi.indexOf(this);
+            processiTerminati.push(processi.splice(i, 1)[0]);
+        };
+        Processo.prototype.esecuzioneCicloSingolo = function(){
+            if(this.contatorePercorso>=this.percorsoAllocazione.length){
+                this.termina();
                 return false;
             }
+            scriviLog("Processo "+this.pid+": esecuzione pagina " + this.percorsoAllocazione[this.contatorePercorso]);
+            if(paginaDaCaricareGiaAllocata(this)){
+                this.contatorePercorso++;
+                return true;
+            }
+            else {
+                return allocaSegmento(this);
+            }
+        };
+
+		function allocaSegmento(proc){
+			//ricerca memoria libera tramite first-fit
             for(var i=0; i<100; i++){
 				if(risorse.mem[i].pid==0) break;
 			}
+
             if(i==100){
                 //allocazione fallita
-                scriviLog("Allocazione fallita. Gestione del page fault...");
+                scriviLog("Allocazione fallita. Gestione della memoria piena...");
 
                 //si applica least recently used
                 var min=0;
@@ -59,19 +87,24 @@
                         min = i;
                 }
                 if(!resettaPagina(min)){
-                    scriviLog("Gestione del page fault fallita.");
+                    scriviLog("Gestione della memoria piena fallita.");
                     return false;
                 };
                 i=min;
             }
             risorse.mem[i].pid=proc.pid;
-            risorse.mem[i].numeroPagina=proc.paginaDaAllocare;
+            risorse.mem[i].numeroPagina=proc.percorsoAllocazione[proc.contatorePercorso];
             risorse.mem[i].istanteAllocazione=Date.now();
-            proc.pagine[proc.paginaDaAllocare]=i;
+            proc.pagine[proc.percorsoAllocazione[proc.contatorePercorso]]=i;
-            scriviLog("Allocata pagina "+proc.paginaDaAllocare+" in locazione di memoria "+i);
+            scriviLog("Allocata pagina "+proc.percorsoAllocazione[proc.contatorePercorso]+" in locazione di memoria "+i);
-            proc.paginaDaAllocare++;
+            proc.contatorePercorso++;
             return true;
 		}
+        function paginaDaCaricareGiaAllocata(proc){
+            if(proc.contatorePercorso>=proc.percorsoAllocazione.length) return false;
+            if(proc.pagine[proc.percorsoAllocazione[proc.contatorePercorso]]!=-1) return true;
+            return false;
+        }
         function resettaPagina(pagina){
             scriviLog("Libero locazione di memoria "+pagina);
             for(var i=0; i<processi.length; i++){
@@ -106,10 +139,11 @@
         for(var i=0; i<100; i++){
             risorse.mem[i]=clone(memoria);
         }
+
         function testAllocazione(){
             //test di allocazione
-            var provaProc = generaProcesso();
+            var provaProc = new Processo();
-            while(allocaSegmento(provaProc));
+            while(provaProc.esecuzioneCicloSingolo());
         }
         testAllocazione();
 	</script>