Folks, 
     I don't mean to be holding anyone up, but I was up front about not being able to get much on this 
done until the week following spring break.  I have two midterms and some work due in the next few 
days, so I am going to get a lot more done later this week.  However, I would LOVE it if someone else 
would like to start coding these algorithms.  I did say before the break that if anyone felt the desire to 
work on this, they were welcome to.  All I'm doing is trying to lay out the basic algorithms so that 
someone else can implement them (this is not complete code by any stretch). 
 
     In the interest of time, here is the remaining thinking I've done on this project.  If I don't hear that 
anyone else has done this work yet by Weds I'll flesh it out, but that's no reason to stop anyone else 
from starting in on coding. 
 
 
1)  The Priority and SJF algorithms will be pretty much identical.  We'll just have to either put them in a 
TreeMap and set the Comparator, or just make the Process class implement Comparable.  The only 
difference between the two algorithms will be that in Priority the comparison is based on a pre-
determined (perhaps randomly generated) priority value, and in SJF it's based on the remaining CPU 
burst time (can be calculated) 
 
2) The Code Generation function shouldn't be that hard to write, honestly.  The first thing you might do 
is decide what the range of burst lengths ought to be (try 5-20 maybe?).  Then decide what the ratio of 
CPU burst time to I/O burst time ought to be (let's say it's 4:1).  Then decide how long the "code" ought 
to be.  Start a loop that first generates a number and makes that many 1's (in our example, between 5 
and 20).  Next it multiplies that number by the appropriate value to make a relative amount of 0's (in 
our case, multiply it by .25).  Then do it again with a new number.  Keep this up until you fill the 
required amount of space.   
[Example:  We generate the number 13.  So we make 13 1's and put them in our code vector.  Then 
we multiply 13 by .25 to get 3 so we append 3 0's to the end of our vector.  We repeat until we reach 
the desired length] 
 
3) I was wondering what the best way in implement these algorithms might be.  I think instead of my 
classes with their "run()" methods, it might be better to give them an "advance()" method that 
advances that queue by one time unit.  That way if we decide to implement the Multilevel and 
Multilevel Feedback Queue algorithms, it will be easier to do so 
 
4) If we do implement the Multilevel and MFQ algorithms as I said in number 3, we'll just need to add 
some kind of traversal that each time unit checks to make sure that no process has been executing or 
waiting too long (if it has, then it should be moved up or down a queue.  I would suggest that both of 
these algorithms use a FCFS in the background queue and a RR algorithm in the front.  I don't know if 
we really need to give them more than two levels.  It wouldn't be much harder, but it might be 
needlessly complex, and we'd still get the point across with two. 
 
-Dave