Assignment
In this lab, you will create a rudimentary "job simulator". This will be a time-based simulator which means each "step" in the simulation will represent a single time unit. A job is modeled simply by a number of instructions to be processed. A provided Processor class is used to "process" jobs. A Processor has a speed field; this field determines how many instructions it can process in a single time unit. A Job Simulator will maintain a Job queue and will have a set of Processor objects to process Jobs.
There are two primary methods used by clients of the Simulator. The enqueueJob method allows a new Job to be added to the Simulator's Job queue. The other primary method is the step which simulates job processing.
When the step method is called, the Simulator must do the following tasks, in order.
1. For each Processor it has, dequeue a Job. Assign the first dequeued Job to the first Processor, and so-on.
2. For each dequeued Job, use the assigned Processor to process the Job. This means reducing the number of remaining Job instructions by the Processor speed.
3. Add all Jobs that have no more instructions to be processed to the list of finished Job, in order that they were dequeued.
4. Enqueue the other Jobs back into the Job queue, in the order that they were dequeued.
A client may call enqueueJob on a Simulator whenever it likes; assume that that call does not take up any time units. Your Simulator must maintain the proper state of remaining Job instructions, queued Jobs, and finished Jobs, knowing that a series of calls to enqueueJob and step can be made in any order and any number of times.
Part 1 - Implementation
1. Create a class that extends the lab.Simulator abstract class.
2. Create a factory class that implements the lab.SimulatorFactory interface and that constructs new instances of your Simulator implementation.
Part 2 - Testing
1. Enable assertions in your Java execution environment.
2. Create a tester class in this package:
lab.test
3. In the main method of your tester class, pass an instance of your SimulatorFactory class to one of the static test methods in lab.test.SimulatorTester.
PROVIDED CLASSES:
*Simulator Class*
import java.util.Deque;
import java.util.LinkedHashSet;
/**
* Provides methods that support modeling simulations of {@link Job}s
* being processed with {@link Processor} objects, in an round-robin
* fashion controlled with a queue implemented with a {@link Deque}.
*
*
*/
public abstract class Simulator {
/**
* The set of Processors that will process {@link Job}s.
*/
protected final LinkedHashSet processors;
/**
* Initializes the set of Processors.
* @param processors the set of Processors.
*/
public Simulator(final LinkedHashSet processors) {
this.processors = processors;
}
/**
* Returns the set of processors.
* @return the set of processors.
*/
public LinkedHashSet getProcessors() {
return processors;
}
/**
* Returns the {@link Job} queue.
* @return the {@link Job} queue.
*/
public abstract Deque getJobQueue();
/**
* Returns the set of {@link Job}s that have been
* fully processed.
* @return the set of {@link Job}s that have been
* fully processed.
*/
public abstract LinkedHashSet getFinishedJobs();
/**
* Enqueues a {@link Job} to the job queue. The new job must
* have a {@link Job#getId()} equal to {@code getJobQueue.size() + 1}.
* If that condition is not met, then this method must throw a
* {@link RuntimeException}.
* @param newJob the Job to enqueue.
* @throws RuntimeException If the new job does not have the proper
* job number.
*/
public abstract void enqueueJob(Job newJob);
/**
* Simulates a processing step.
*
*
- Dequeues a Job per Processor.
*
- Assigns the dequeued Jobs to Processors in iterator order. In other
* words, the first dequeued Job gets assigned to the first Processor.
*
- Uses each assigned Process to process the assigned Job, updating
* the number of instructions remaining to be processed in the Job
* according to the Processor speed.
*
- Add finished Jobs to {@link #getFinishedJobs()}.
*
- Enqueues the unfinished Jobs to {@link #getJobQueue()} in the order
* that they were dequeued.
*
*/
public abstract void step();
}
-------
*SimulatorFactory class*
import java.util.LinkedHashSet;
/**
* A factory for constructing {@link Simulator} objects.
*
*
*/
public interface SimulatorFactory {
/**
* Constructs a new Simulator object.
* @param processors the set of processors the Simulator will be
* initialized with.
* @return a newly constructed Simulator object.
*/
Simulator createSimulator(LinkedHashSet processors);
}