WebSVN – programming – Diff – /school/cs431/p1/Scheduler.java

 /*******************************************************************************
- * File: Scheduler.java
+ * Scheduler.java
+ *
  * Holds the Scheduler class, which has a generic scheduler class, from which
  * all schedulers should be derived.
+ *
  * Copyright (c) 2006, Ira W. Snyder (devel@irasnyder.com)
  * IN THE SOFTWARE.
  ******************************************************************************/
 import java.util.Vector;
+/**
+ * Base class for all of the specific Schedulers used in Project #1.
+ *
+ * @class CS431 Fall 2006
+ * @author Ira W. Snyder (devel@irasnyder.com)
+ */
-abstract class Scheduler
+public abstract class Scheduler
+{
+    /** The Processes that can currently be scheduled */
     protected Vector<Process> run_queue;
+    /** A log of important transitions in the Scheduler */
     protected Vector<LogEntry> log;
+    /** The current time in this scheduler */
     protected int cur_time = 0;
+    /** The process that is currently running on the CPU */
     protected Process cur_proc;
+    /**
+     * Constructor of the Scheduler class.
+     */
+    public Scheduler ()
+    {
+        this.run_queue = new Vector<Process> ();
+        this.log = new Vector<LogEntry> ();
+    }
+    /**
+     * This method must be overridden by an implementer of a Scheduler. It
+     * will implement the specific behaivior of the specific Scheduler that
+     * is being implemented.
+     *
+     * @return true if we have more things to do, false if we are done
+     */
     protected abstract boolean step ();
     /**
      * Add a new process to the run queue.
-     *
+     * <p>
      * If you need to support time-delayed processes, then you must override
      * this method, and handle pulling them into the run_queue yourself.
+     *
+     * @param proc the Process to add
+     * @param add_time the time that this process should be added to the run queue
      */
     public void addProcess (Process proc, int add_time)
+    {
         run_queue.add (new Process(proc));
+    }
     /**
      * Expire the currently running process.
-     *
+     * <p>
-     * This removes the current process from the cpu and re-adds it to the
+     * This removes the current process from the CPU and re-adds it to the
-     * run_queue.
+     * run_queue. It also logs the expiration.
      */
     protected void expireCurrent ()
+    {
         assert (cur_proc.time_left > 0);
         run_queue.add (cur_proc);
         log.add (new LogEntry (cur_proc, cur_time, LogEntry.MsgType.EXPIRE));
         cur_proc = null;
+    }
+    /**
+     * Terminate the currently running process.
+     * <p>
+     * This should be called if the process has no time left to run.
+     */
     protected void completeCurrent ()
+    {
         assert (cur_proc.time_left == 0);
         cur_proc.finished_at = cur_time;
         log.add (new LogEntry (cur_proc, cur_time, LogEntry.MsgType.COMPLETE));
         cur_proc = null;
+    }
+    /**
+     * Move a process from the run_queue to the CPU. This removes it from the
+     * run_queue. Then it adds a log entry.
+     *
+     * @param proc move this process from the run_queue to the CPU
+     */
     protected void startProcess (Process proc)
+    {
         cur_proc = proc;
         cur_proc.started_at = cur_time;
         run_queue.remove (cur_proc);
         log.add (new LogEntry (cur_proc, cur_time, LogEntry.MsgType.START));
+    }
+    /**
+     * Run the current process. Also increment the current time.
+     */
     protected void scheduleCurrent ()
+    {
         cur_proc.time_left--;
         cur_time++;
+    }
+    /**
+     * Print a Gantt Chart detailing the results of this scheduler's run.
+     */
     protected void printGanttChart ()
+    {
         Vector<String> t = new Vector<String> ();
         Vector<String> l = new Vector<String> ();
                 add2 += " ";
             if (timeline.length() + add1.length() > 79)
+            {
                 t.add (timeline + "|");
                 templen = labels.length() - String.valueOf(exptime).length();
                 labels = labels.substring (0, templen+1) + String.valueOf(exptime);
                 l.add (labels);
+                /* Clear the current timeline and labels */
                 timeline = new String();
                 labels = new String();
+            }
             timeline += add1;
             labels += add2;
+        }
         /* Done, add the last values of timeline and labels to the Vectors */
         t.add (timeline + "|");
         templen = labels.length() - String.valueOf(exptime).length();
         labels = labels.substring (0, templen+1) + String.valueOf(exptime);
         l.add (labels);
         assert (l.size() == t.size());
             System.out.println (l.elementAt (i));
             System.out.println ();
+        }
+    }
-    public Scheduler ()
-    {
+    /**
-        this.run_queue = new Vector<Process> ();
+     * Run the simulation of the scheduler. Note that this only works once,
-        this.log = new Vector<LogEntry> ();
+     * if you try to run it twice, it is unlikely that it will work.
-    }
+     */
     public void run ()
+    {
         /* Keep step()ing until we're done */
         while (step ())
             ; // do nothing

Subversion Repositories programming

(root)/school/cs431/p1/Scheduler.java – Rev 414 → 415