MultiLayeredQueue algorithm implemented.

Author: mahdighiasi79

defs.h

@@ -129,7 +129,7 @@ int             exec_process(struct proc* p, struct cpu* c);                // (
 struct proc*    checkQueues(int *lastIndex, int *curPriority, char mode);   // (Added)
 void            increase_time(void);                                        // (Added)
 int             wait2(Times *times);                                        // (Added)
-int             enQueue(int pid);                                           // (Added)
+int             enQueue(int queue);                                         // (Added)
 
 // swtch.S
 void            swtch(struct context**, struct context*);

proc.c

@@ -12,46 +12,10 @@ struct {
   struct proc proc[NPROC];
 } ptable;
 
-                    ///  // added structs/////
-typedef struct rr
-{
-  /* data */
-  struct proc queu[NPROC];
-  int size;
-
-} RoundRobin;
-
-RoundRobin RoundRobinQ;
-
-typedef struct d
-{
-  /* data */
-  struct proc queu[NPROC];
-  int size;
-
-} Default;
-
-Default DefaultQ;
-
-typedef struct prio
-{
-  /* data */
-  struct proc queu[NPROC];
-  int size;
-
-} PrioritySchedualing;
-
-PrioritySchedualing priSchedQ;
-
-typedef struct reversePrio
-{
-  /* data */
-  struct proc queu[NPROC];
-  int size;
-
-} ReversePrioritySchedualing;
-
-ReversePrioritySchedualing RpriSchedQ;
+RoundRobin RoundRobinQ;                     // (Added)
+Default DefaultQ;                           // (Added)
+PrioritySchedualing priSchedQ;              // (Added)
+ReversePrioritySchedualing RpriSchedQ;      // (Added)
 
 static struct proc *initproc;
 
@@ -370,13 +334,21 @@ wait(void)
 //  - swtch to start running that process
 //  - eventually that process transfers control
 //      via swtch back to the scheduler.
+int b = 1;
 void                                          // (Modified)
 scheduler(void)
 {
-  DefaultQ.size = 0;                          // (Added)
-  priSchedQ.size = 0;                         // (Added)
-  RpriSchedQ.size = 0;                       // (Added)
-  RoundRobinQ.size = 0;                       // (Added)
+  if (b == 1){
+    DefaultQ.size = 0;                          // (Added)
+    priSchedQ.size = 0;                         // (Added)
+    RpriSchedQ.size = 0;                       // (Added)
+    RoundRobinQ.size = 0;                       // (Added)
+    q = 0;
+    b = 0;
+  }
+
+  multilayer = 0;                             //(Added)
+  
   struct proc *p = 0;                         // (Modified)
   struct cpu *c = mycpu();
   c->proc = 0;
@@ -421,6 +393,38 @@ scheduler(void)
       break;
 
     case 4:       // Multy layer Queue
+      multilayer = 1;
+      if (q == 1){
+
+        curPolicy = 3;
+        for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
+        if(p->state != RUNNABLE)
+          continue;
+        exec_process(p, c); 
+        }
+      } else if (q == 2){
+
+        curPolicy = 1;
+        p = checkQueues(lastIndex, &lastPriority, 'f');
+         if(p != 0)
+        exec_process(p, c);
+
+      } else if (q == 3){
+
+        curPolicy = 2;
+        p = checkQueues(lastIndex, &lastPriority, 'r');
+        if(p != 0)
+          exec_process(p, c);
+
+      } else {
+
+        curPolicy = 0;
+        for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
+        if(p->state != RUNNABLE)
+          continue;
+        exec_process(p, c);
+        }
+      }
       break;
     }
 
@@ -810,10 +814,10 @@ wait2(Times *times)
         // Found one.
 
         // writing the related times (Added)
+        times->sleepingTime = times->sleepingTime;
         times->creationTime = p->creationTime;
         times->readyTime = p->readyTime;
         times->runningTime = p->runningTime;
-        times->sleepingTime = times->sleepingTime;
         // done writing
 
         pid = p->pid;
@@ -841,34 +845,35 @@ wait2(Times *times)
   }
 }
 
+// this function add current process to given queue (Added)
 int
-enQueue(int pid)
+enQueue(int queue)
 {
-  struct proc p;
-
-  for (int i = 0; i < NPROC; i++){
-    if (ptable.proc[i].pid == pid){
-      p = ptable.proc[i];
-    }
-  }
+  struct proc *curproc = myproc();
 
-  if (p.queue == 1){
-    RoundRobinQ.queu[RoundRobinQ.size] = p;
+  if (queue == 1)
+  {
+    RoundRobinQ.queu[RoundRobinQ.size] = curproc;
+    curproc->queue = queue;
     RoundRobinQ.size++;
-
-  } else if (p.queue == 2){
-    priSchedQ.queu[priSchedQ.size] = p;
+  }
+  else if (queue == 2)
+  {
+    priSchedQ.queu[priSchedQ.size] = curproc;
+    curproc->queue = queue;
     priSchedQ.size++;
-
-  } else if (p.queue == 3){
-    RpriSchedQ.queu[RpriSchedQ.size] = p;
+  }
+  else if (queue == 3)
+  {
+    RpriSchedQ.queu[RpriSchedQ.size] = curproc;
+    curproc->queue = queue;
     RpriSchedQ.size++;
-
-  } else {
-    DefaultQ.queu[DefaultQ.size] = p;
+  }
+  else 
+  {
+    DefaultQ.queu[DefaultQ.size] = curproc;
+    curproc->queue = queue;
     DefaultQ.size++;
-
   }
-
   return 1;
 }

proc.h

@@ -13,6 +13,8 @@ struct cpu {
 int curPolicy;                  // shows that current scheduling policy (Added)
 extern struct cpu cpus[NCPU];
 extern int ncpu;
+int multilayer;
+int q;
 
 //PAGEBREAK: 17
 // Saved registers for kernel context switches.
@@ -52,15 +54,44 @@ struct proc {
   char name[16];               // Process name (debugging)
   int syscall_occurrence[24];  // save occurrence of each syscall (Added)
   int priority;                // priority of a process (Added)
-  int creationTime;            // allocation time
-  int runningTime;             // RUNNING state
-  int readyTime;               // RUNNABLE state
-  int sleepingTime;            // SLEEPING state
-  int queue;                   // number of queue that the process belons to
+  int creationTime;            // allocation time (Added)
+  int runningTime;             // RUNNING state (Added)
+  int readyTime;               // RUNNABLE state (Added)
+  int sleepingTime;            // SLEEPING state (Added)
+  int queue;                   // number of queue that the process belongs to it (Added)
 };
 
 // Process memory is laid out contiguously, low addresses first:
 //   text
 //   original data and bss
 //   fixed-size stack
 //   expandable heap
+
+// structs for multilevel queue (Added)
+typedef struct rr 
+{
+  struct proc* queu[NPROC];
+  int size;
+
+} RoundRobin;
+
+typedef struct d
+{
+  struct proc* queu[NPROC];
+  int size;
+
+} Default;
+
+typedef struct prio
+{
+  struct proc* queu[NPROC];
+  int size;
+
+} PrioritySchedualing;
+
+typedef struct reversePrio
+{
+  struct proc* queu[NPROC];
+  int size;
+
+} ReversePrioritySchedualing;

sysproc.c

@@ -8,6 +8,8 @@
 #include "proc.h"
 
 extern int curPolicy;                  // shows that current scheduling policy (Added)
+extern int multilayer;
+extern int q;
 
 int
 sys_fork(void)
@@ -175,11 +177,12 @@ sys_wait2(void)
   return wait2(times);
 }
 
+// this function add current process to given queue (Added)
 int
 sys_enQueue(void)
 {
-  int pid;
-  if(argint(0, &pid) < 0)
+  int queue;
+  if(argint(0, &queue) < 0)
     return -1;
-  return enQueue(pid);
+  return enQueue(queue);
 }

trap.c

@@ -107,11 +107,27 @@ trap(struct trapframe *tf)
      tf->trapno == T_IRQ0+IRQ_TIMER)
   {                                                         // (Modified)
     if (curPolicy == 0 || curPolicy == 1 || curPolicy == 2) 
-    {                                                         
+    { 
+      if (multilayer == 1){
+        curPolicy = 4;
+        if (q == 3){
+          q = 0;
+        } else {
+          q++;
+        }
+      }                                                        
       yield();
     }
     else if (curPolicy == 3 && ticks % QUANTUM == 0)        // for Round-Robin (Added)
     {
+      if (multilayer == 1){
+        curPolicy = 4;
+        if (q == 3){
+          q = 0;
+        } else {
+          q++;
+        }
+      }
       yield();
     }
   }

types.h

@@ -2,11 +2,12 @@ typedef unsigned int   uint;
 typedef unsigned short ushort;
 typedef unsigned char  uchar;
 typedef uint pde_t;
+
+// Struct (Added)
 typedef struct times
 {
-    /* data */
-  int creationTime;            // allocation time
-  int runningTime;             // RUNNING state
-  int readyTime;               // RUNNABLE state
-  int sleepingTime;            // SLEEPING state
-} Times;
+  int creationTime;            // allocation time (Added)
+  int runningTime;             // RUNNING state (Added)
+  int readyTime;               // RUNNABLE state (Added)
+  int sleepingTime;            // SLEEPING state (Added)
+} Times;

user.h

@@ -31,7 +31,7 @@ int getPriority(void);                   // (Added)
 int changePolicy(int policy);            // (Added)
 int getPolicy(void);                     // (Added)
 int wait2(Times *times);                 // (Added)
-int enQueue(int pid);                    // (Added)
+int enQueue(int queue);                  // (Added)
 
 // ulib.c
 int stat(const char*, struct stat*);