Orders Processor (Concurrency)

Overview

For this project you will implement a program that processes files that represents purchase orders. The program can complete the processing by using a single thread or multiple threads.

IMPORTANT: For this project, there are no public or release tests. All tests are secret. You will submit your project as usual, but no testing information will be provided by the submit server. We have provided a simple example to illustrate the input and output format associated with the project. The provided example is not considered a public test.

If you cannot check out the project from your CVS repository, then use the following link to download your project: Project Distribution

Objectives

Practice the design and implementation of concurrent systems.

Grading

(20%) Correct results for single-threaded computation.
(35%) Correct results for multiple threads computation.
(20%) Correct utilization of locks to avoid data races.
(5%) Avoiding code duplication.
(10%) Design
(10%) Report

Clarifications

Any clarifications or corrections associated with this project will be available at Clarifications.

Code Distribution

The project's code distribution is available by checking out the project named OrdersProcessor. The project distribution has the following files/folders:

example1.txt → A sample order.
example2.txt → A sample order.
itemsData.txt → Information about the items that can be purchased.
resultsExample.txt → Results of processing the above example1.txt and example2.txt orders. Notice this does not represent a public test.
processor package → This is where all the files associated with your implementation will reside.

Specifications

Data Manager

Your program will process a set of files, each representing a purchase order. Each file has information about items associated with a purchase order. The possible items that can be purchased can be found in the file itemsData.txt. The program will compute a summary for each order (file) that provides the client id, and a sorted list (by item's name) of each item bought. The list will include the cost per item, the quantity of items bought, and the total cost associated with the item's purchase. After the sorted list, a grand total will be displayed. See the resultsExample.txt file for an example of the data format. In addition to the above report, the program will generate a summary of all orders. The summary will display a sorted list (by item's name) providing information about the total number of items sold, and total revenue (see resultsExample.txt.)

Your program will allow users to process all the orders using a single thread or one thread per order (file). For simplicity, all the orders will use the same base filename (e.g., example in the files above.) The user will provide a filename for the results.

In order to see the advantages of threading, your program needs to print (to standard output) the time (in msec) it took to process orders. You can compute the time as follows:

long startTime = System.currentTimeMillis();
/* TASK YOU WANT TO TIME */
long endTime = System.currentTimeMillis();
System.out.println("Processing time (msec): " + (endTime - startTime));

Your program will ask users about how to configure a particular program run using standard input and output. The following represents a run that computed the results you see in resultsExample.txt. Code in italics represents user's input.

Enter 'y' for multiple threads, any other character otherwise: y
Enter number of orders to process: 2
Enter order's base filename: example
Enter result's filename: resultsExample.txt
Reading order for client with id: 1
Reading order for client with id: 2
Processing time (msec): 106
Results can be found in the file: resultsExample.txt

Requirements

Your program will print (to standard output, NOT to the results file) the message "Reading order for client with id: " followed by the client id, before reading a particular order file.
Notice that the reports appear sorted by client id, but the processing of each order (when using multiple threads) is up to the Java scheduler.
You will start the timing process right after reading the name of the results file and will stop the timing process before printing the processing time and the message indicating where results can be found. Make sure you close the file output stream for the results file before you stop the timing process.
For the single thread option, your program will process orders without creating any explicity threads (like we have done in class examples.) For the multiple thread option, one thread will be created for each order (file) to be processed.
You must avoid data races by using java locks. Do not use any synchronized class Java provides.
Feel free to define as many classes and/or interfaces you understand are necessary. This is part of your design credit. Using more classes do not necessarily means more credit.
Your code must be efficient and you must avoid code duplication.
Notice we plan to modify the contents of the itemsData.txt file while grading your program. That means we plan to use items other than the ones you see in the file.
Your program must be able to process any number of orders (not just 2 or 20.)
You can assume all order files will be placed in the same folder where example1.txt, example2.txt reside.
To run your program, we will execute the main method associated with a class you need to provide called OrdersProcessor.java. Make sure that class is under the processor package.
We have provided extra files you can use to run experiments with your program. The data can be found at data.zip.
Using the data.zip file, create a table that illustrates the time it takes to process data using a single thread and multiple threads. For example, the table can have three columns, where the first indicates the number of orders, the second the time it took using a single thread, and the third the time is took using multiple threads. Provide a brief explanation (no more than a paragraph) of your results. Put your table and explanation in a file named Report.doc and place that file in your project (just drag the file to the same folder where you find the example1.txt file.)
See Style Guidelines for information regarding style.

Additional Requirements for Students in CMSC 132H (Honors)

Students in the honors section may need to complete this part. Talk to your instructor to verify if this is the case.

In addition to the above requirements, you must define a program that generates files with random data (similar to example1.txt.) We should be able to provide a number of files, a maximum number of entries per file and your program should generate files with a random number of entries (not exceeding the specified maximum.) Call your program DataFilesGenerator.java.