Beats me. I only install the stuff and let it do it's thing.
But I do know how to use Google.
START
FIRST METHOD
I started by calling a method I made that had two variables - number of iterations, and buffer size. I used it to launch the number of trials I did,
and to record the total time in seconds. I just added the return from my next method for a few thousand times. (Or however long I ran it)
SECOND METHOD
Next, you want to start simulating the 500-print jobs in a method! When the method started.
I made a "wasted time" variable, an integer, for the sake of tracking how long we sat there, waiting for the printer to finish a job.Right before the start of the loop, I decided to start a "Printer" object, initializing it with my buffer variable as a field. I'll get to it in a moment. It's mainly the meat of the problem!
Finally, we start the main loop! Doing 500 iterations of the loop. This should be fairly easy; you're making a double using a random number generator from 0-4, and adding 0.75 to the value.
On each iteration of the loop, you need to check (before you send the job to the printer) if the printer buffer is full. Again, this is the 'Printer" object that I'll get to. If the printer is full, you need to wait.
Remember the "wasted time" variable I talked about before? This is where it gets used, adding the value remaining in the current printer job to itself. Getting the printer's current job is another step I did in the printer object.
Finally, we now know that the printer has space in the buffer, we've generated a job time, and we're good to go! I, personally, made a "job cycle" method, that I called now using the random time we made. It could be accomplished in two steps, but I chose to just do them in one. We'll get to the printer in a moment, but all that's left in the simulation method is actually adding up the total amount of time and returning; I multiplied 500*3 seconds, for the normal time from each job, and then added the wasted time that iterated over the loop.Then, I made a call to the printer that handled anything left in the buffer.
PRINTER OBJECT - CONSTRUCTOR/INIT
Now, this printer object has one very important feature; the buffer! I chose to represent it using a linked list, more specifically a double-headed queue. This let me push objects on, pop them off, and put them in queue at the end. This did mean I had to use a private int to represent length, to make sure the printer never went over the buffer size, though. Inside the constructor when I called the printer, I set a field "bufferMax", and started a second field, "buffer", which was the linked list.
FIRST METHOD
The first non-constructor inside of the printer is a means to check if the buffer is full. It checks if the size of the linked list is equal to the bufferSize variable plus one. It's plus one, because the current job is part of the queue too! It's a simple boolean return, true (full) or false (space is free)
SECOND METHOD
In case the buffer is full, we need to empty it out. This method cleared a single space, by removing the first item from the queue, and returning the value. This number was the number previously added to my "wasted time" value.
THIRD METHOD
This method was the meat of the printer. I made a variable, and set it equal to 3 seconds. Then, I started a multi-condition while loop. So long as this printer time value was above 0, and the queue was not empty, it would keep going.
Inside this loop, the first value was removed from the queue, and I subtracted it from the "printer time" variable. If printer time was less than 0, I added a job to the front of the queue (that's why it was double ended!) equal to negative printer time (so, it's a positive value. Ex. a 4.5 second job would add 1.5 seconds back to the front)
Finally, once that whole cluster of stuff concerning printing was done, I added a new value to the queue. This was the time we called the method with, the randomly generated time. This was a void/null method, so there's no return. That's it.
FOURTH METHOD
This is a while loop that goes through the rest of the linked list/queue/buffer, adds the times, and returns it. If you've gotten this far, I trust you know how to do it!
END
That's it! So, we have in the end an application that runs 500 printer jobs, making sure an arbitrarily sized buffer is not full, and tallying time all along. Once that time is tallied, it averages it over another arbitrarily defined number of times; I outputted that average to the console, in order to record it.
http://instaedu.com/Computer-Scienc...-the-background-SIMULATE-the-following-scen2/
)
