CS267 Assignment 3: Knapsack

Due Wednesday March 21th, 2007 at 11:59PM

[ Background | Code and Ideas | Requirements | UPC | Titanium | Submission | Resources ]

This assignment's goal is to expose you to a global address space language UPC and its programming paradigm. This problem highlights challenges of more irregular load balancing and communication. You will write UPC code to solve a 0-1 knapsack problem by dynamic programming.

Background

Imagine that you have N old textbooks with integer weights W[i], for i from 1 to N. You also have backpack with an integer weight capacity of C. There is a used book store down the street that will give you P[i] dollars for book i. How much money can you make in one trip?

That's the 0-1 knapsack problem in a nutshell. The obvious solution of trying every possible combination is silly. A slightly better method is known as branch-and-bound; you run a breadth-first search of the combination space, but prune branches that cannot lead to optimal solutions.

A much, much better solution follows from expressing the problem as a recurrence relation and taking a dynamic programming approach. For the non-CS people (and the CS people who have forgotten), dynamic programming algorithms store common subproblems in a table and fill the table until they reach the solution.

We will construct a C-by-N table T indexed by a capacity and a book number. Entry T[i, j] is the maximum profit that can be obtained with a capacity i using books 1 through j. Suppose we have a backpack of capacity i, and want to know what is the maximum profit using books 1 through j. Well, we can use the book j or not use the book j. In the former case, we decided to use book j, so the profit is P[j] plus the maximum profit T[i-W[j], j-1] that can be attained with the remaining capacity and books. If we decide not to use book j, then the maximum profit is simply T[i, j-1]. We just take the best out of the above two possibilities. Thus we can compute T[i, j] recursively:

You'll have a choice when the above two quantities are the same. The sample code decides not to include book j in that case. It takes constant time per entry in the C-by-N table, so algorithm runs in O(CN) time (which is still linear in the input size).

Figure 1: To decide on packing a book, compare the previous total profit at the current capacity to the book's profit plus the profit at the current capacity minus the book's weight (here, capacity - 3). If the latter is larger, include the book.

There are a few initial cases to think about... What if i-W[j] is negative? What is T[1, j] ? What is T[i, 1]?

After all this, the total profit is in entry T[C, N]. You can find the books that achieve that profit by backtracking over the choices.

Codes and Ideas

A pair of sample programs are provided in C and UPC (also in tar.gz format). You may also choose to use Titanium instead of UPC. If you are planning on using Titanium, you will need to write up your own code from scratch.

The UPC program is horribly inefficient when using a network back-end. The data is distributed as shown by the colors in Figure 1, ensuring too much communication at every step.

The UPC code can be compiled to use various backend communication: SMP (using pthreads), MPI, various network (on top of which MPI is usually implemented), etc. On the CITRIS, you can use the SMP and GM versions, while on Bassi you can use the SMP, MPI, and LAPI versions. On Jacquard, the VAPI version of the code is suggested. See the Makefile for details.

An efficient implementation will likely give each processor a contiguous block of bag capacities and access its columns via local pointers. You may put all the book profits on each processor if that's the most efficient (for large numbers of books). You may also want to investigate pipelining the computation and fetching the necessary total profits in bulk.

Figure 2: Pipelining the computation of totals may increase the computation per communication.

Requirements

You may work in groups of 2 or 3. One person in your group should be a non-CS student if possible. You have the option of using either UPC or Titanium for your knapsack code.
For UPC users:

• The required files are packaged here (tar.gz).
• Profile the initial code on the CITRIS, Jacquard and Bassi clusters. Any bottlenecks? Efficiency? Scalability? How much time is spent in communication? Does the performance depend on input?
• Change the code to address some of the performance problems. Profile the code again, and do some performance analysis. For the backtracking phase, you need to use more than one processor in some way. Do not simply send the entire table to one processor and have it do the backtracking. You dont have to be excessively clever, but think about making the backtrack efficient.
• We also want to know how the languages affect the designs and performance. Since UPC uses a one-sided messaging model, what would you do differently in a MPI/OpenMP code? Which MPI, OpenMP, etc. features do you miss, and which UPC features do you enjoy?

• Profile your code on the CITRIS, Jacquard and Seaborg clusters. How does the Titanium code compare with the given sequential C code (knap.c in the tar.gz file here)? Efficiency? Scalability? How much time is spent in communication? Does the performance depend on input?
• What would you have differently in an MPI/OpenMP code? Which MPI, OpenMP features you miss, and which Titanium features do you enjoy?

UPC Compiler

• For Jacquard (wich supports the SMP, MPI, UDP, and VAPI conduit), in the knapsack directory use the commands:

  $ module load upc
  $ gmake knap knap-smp knap-udp knap-mpi knap-vapi
  

  Make sure to run the "module load upc" command to load the upcrun script when you run your UPC programs
• For Bassi (which supports the SMP, MPI, UDP, and LAPI), use the commands:

  $ module load upc
  $ module load gcc
  $ gmake knap knap-smp knap-udp knap-mpi knap-lapi
  

  Before compiling the sequential code (i.e., knap), make sure to change set the variable CC in the Makefile as gcc -maix64 (otherwise you will get errors in compiling the sequential code on Bassi). You can also change the CC variable in the Makefile to xlc.
• For CITRIS (which supports SMP, and GM) , use the commands:

  $ export PATH="/project/cs/titanium/b/temp/citris-upc/stable/ecc/runtime/inst/bin:$PATH"
  $ gmake knap knap-smp knap-gm
  

Titanium Compiler

• For Jacquard and Seaborg, load the module titanium to be able to use it.
• For CITRIS, the Titanium compiler (tcbuild) can be found in the /project/cs/titanium/b/temp/citris/dist/bin/ directory, so make sure to add it to the PATH environment variable.

Submission

Resources

• This problem was originally from Prof. Culler's CS258 class. You might find other useful tips there. It's a fun little problem.
• The CITRIS Essentials page and Bassi Essentials page has a section on using UPC on each system.
• UPC Homepage, in particular the UPC Users' Guide.
• upcc man page.
• upcrun man page.
• Titanium Homepage. You will also find tutorials to get you started. The reference manual is here.
• Random article on parallel knapsack found on CiteSeer.