CSCI 1321 (Principles of Algorithm Design II), Spring 2010:
Homework 7

Credit

Design 20 points; code 40 points.

Overview

By now your game should be playable, with all the major functionality implemented. This homework is something of a tangent; the goal is to write a second, more efficient priority queue and compare its performance with your first version. The needed code breaks down into two categories:

First, you are to write a second priority queue class that uses a heap (as discussed in class) to store elements rather than a sorted linked list.

Second, you are to add code to your game that will allow you to compare the performance of the two implementations as the number of game entities in the queue varies. To do this, you need to do several things: create a ``dummy'' game entity class so you can put arbitrarily many entities in the priority queue, change your main class to accept two command-line arguments that specify which implementation to use and how many of these dummy entities to add, and change your player class to print out some information that will allow you to see how performance varies based on the choice of priority queue implementation and the number of dummy entities.

Once you do all of this, you can run your game with different values of the two command-line arguments and see how performance changes. The final part of this assignment is to do this and plot the results.

Design

The design for this assignment will likely be simpler for this assignment than for previous assignments, since the number of new classes is smaller, and there will not be many changes to the descriptions of other classes.

Step-by-step instructions

• As with previous assignments, create a new Eclipse project for this assignment and copy into it the package from the previous assignment.

• Create the classes described below in ``Classes for this assignment'', and edit the classes you wrote for previous assignments as needed to describe changes you will make.

• When you're happy with your design, generate HTML documentation for your project as described in the Project Description and check that it's okay using a browser. Notice that this time your documentation goes in a directory named HW7/Design.

• Turn in your design by sending me mail telling me it's ready to be graded. Please use a subject line such as ``csci 1321 design 7''.

Code

The class you need to add and/or modify are described in the next section (``Classes for this assignment''). This section describes the overall procedure.

Step-by-step instructions

• In the project you created in the design phase, fill in code for the classes you created or revised in the design phase.

  NOTE: I do not recommend that you make other changes to your code in this assignment, unless it's to fix critical bugs. The changes you make for this assignment do not need to be included in the final version of the game you will turn in for Homework 8, and if you avoid making other changes, you can use Homework 6 as your starting point for Homework 8 and not worry about backing out Homework 7 changes.

• Revise and debug until you're happy with how your code compiles and executes.

• Collect performance data, as described in ``Performance experiments'' below.

• Generate HTML documentation for your project as described in the Project Description.

• Turn in your code by sending me mail with all of the files I need to compile and run your game as attachments. This includes all (.java files), any file(s) created using the screen editor, and any file(s) containing images. All of these files will probably be in the same directory containing your Eclipse project (same name as the project, in your Eclipse workspace directory), unless you put them somewhere else. You don't need to send me .class files or the JAR file, but if it's simplest for you just to send me all the files in the directory for your Eclipse project, do that. It's better to send a bit too much than not enough!

  The ``General requirements'' section of the Project description has more suggestions about how to send me the needed files.

  Please use a subject line such as ``csci 1321 code 7''.

• Also turn in your plots. If they're in electronic form, you can just turn them in with your code. If you use pencil and paper, turn in hardcopy, in the mailbox outside my office.

Classes for this assignment

For this assignment the coding job consists of three main pieces -- writing a second PriorityQueue class, writing a class for dummy entities, and making changes to other classes to let you conduct the performance experiments described earlier.

Priority queue class

Like the priority queue class you wrote for Homework 5, the one for this assignment should implement the framework's PriorityQueue interface. You could call it HeapBasedQueue, or something else that distinguishes it from the previous class. It will store elements using a heap (as discussed in class) rather than a linked list. NOTE that you should not implement the heap using a tree-like representation. Instead, use an array (as discussed in class) or one of the Java library classes that can represent a resizable array (Vector or ArrayList). If you use a plain array your code is likely to be simpler, but you will have to include code to make it bigger if it fills up (by creating a bigger array and copying elements). A good strategy for that is to start out with some reasonable-seeming size, and double it if it fills up.

Dummy entity class

You also need a ``dummy'' game entity class you can use to put lots of entries in the priority queue. It will need all the methods of the GameEntity interface, but the only ones that have to do anything are update (store the time passed in) and getUpdateTime (return the time previously passed to update plus something nonzero). To fully test your priority queue, the time between updates should not be the same for all dummy entities. A simple way to make this happen is for each entity to have a timeBetweenUpdates variable, passed in via a constructor; its getUpdateTime method then returns the time of the last update plus timeBetweenUpdates.

Changes to other classes

Finally, you have to make some smaller changes to other classes to allow you to conduct performance experiments:

• Add code to your main class so that it accepts two command-line arguments. The first selects which of your priority queue classes to use (``list'' or ``heap''). The second specifies how many dummy entities to add to the queue. Recall that command-line arguments are passed to the main method of your main class in the form of an array of Strings.

• Add code to your game setup class that does the right thing with these arguments: creates the game's priority queue as an instance of your linked-list priority queue or as an instance of your heap priority queue depending on the first argument and then adds to it the specified number of dummy entities. You can generate values for the entities' timeBetweenUpdates using a random number generator: Create an instance of the Java library class Random and repeateadly call its nextInt(int) method to generate a sequence of numbers in some reasonable range (say 1 through 10). Notice that the dummy entities need to be added only to the priority queue, not to any screens.

  Probably the right place to add this code is in the constructor for the class. There are various options for passing in the two command-line arguments. One is to make them parameters to the class's constructor, write a method makeInstance that takes two parameters and uses them to create the class's one instance, and call makeInstance from your game's main class. Or you may think of a better approach!

• Add code to your player class's update method that prints out timing information, specifically how much time it takes for every 100 calls to the method. System.currentTimeMillis() returns a long with the current time in milliseconds. Every 100-th call to update (when time % 100 is 0), you can call this method to get the current time, subtract the previous current time, and print the resulting difference.

Performance experiments

Once you have written and tested the above code, I want you to collect and plot timing information that shows how, for each version of the priority queue, performance (time for 100 calls to player's update method) changes as the number of dummy entities increases. You will have to experiment a little to see what number of entities is needed to get meaningful results. Start with a small number (say 10), and then increase it by factors of 2 or 10 until you see performance differences. Then collect timing results for at least six different numbers of dummy entities. (You might start with the value at which you first notice an increase, and then double that repeatedly, or multiply by 10. What you should see is that for $n$ entities the time for the linked-list version is roughly proportional to $n^2$ , while for the heap version time is roughly proportional to $n \log n$ .) I also suggest letting the game run long enough to print several values (at least three or four) for the ``time for 100 updates'' measurement, and then averaging them.

Plot your performance data in whatever way is easiest for you -- using whatever tool you prefer for making plots, or with pencil and paper if that's easier. I usually use gnuplot (that's what I've used in class), but it does take a bit of learning to use. Details on request.

Files and links

• The JAR file for this assignment, PAD2S10Assn7.jar. (This JAR file is essentially the same as the one for Homework 5, included again here for completeness.)

• Project Description.

• Project API (Lewis game framework).

• Java library API.