CSCI 338

Parallel Processing

Home | Lectures | Programming Assignments | Links | CS@Williams

Final Project

Overview

The previous assignments have given you experience with different parallel programming environments. In this final project, you will have the opportunity to show your skill at either using those existing environments or exploring a new programming environment. Your two options for this final project are:

1. to show your mastery of the programming paradigms you learned about this semester, highlighting use of the unique characteristics of each programming environment. Specifically, you will adapt a new graph algorithm to three parallel programming paradigms and then evaluate and compare your implementations. OR
2. to explore a new programming environment, implementing and evaluating two graph algorithms on that environment.

How the Honor Code Applies to This Assignment

This is a group-eligible assignemnt. Meaning, you should work with your class-approved team of students to produce your code, evaluation, and final reports. You are also encouraged to to ask non-team members questions of clarification, language syntax, and error message interpretation. Please see the syllabus for more details.

Part 0: Proposal

You should create a brief write-up of which project option your group is electing to complete.

1. For the first option, you should indicate the graph algorithm that you intend to implement on the programming environments learned about during this semester. You should describe what the graph algorithm does at a high level, indicate at least one citation that describes the algorithm (which could be a book), and indicate any existing code implmentations that you you will be using as your starting point.
2. For the second option, you should indicate the programming environment that you plan to explore and the two graph algorithms you plan to implement and evaluate on that system. You should provide a brief description of the system and algorithms, providing citations, as well as indicating any existing code implementations you will be using. Also indicate what compute resources you will need to use.

Option 1

The graph algorithm you choose should be one that has not been explored by any members of this class previously. You are welcome to use an existing implementation of a graph algorithm as a starting point (e.g., from GAP or GMS) as long as you cite where the code is coming from or write a graph algorithm from scratch.

You will implement the graph algorithm for three different environments.

1. MPI
2. OpenMP or pthreads - if a current implementation exists for one of these programming environments, you must implement the other option
   • Evaluate two different data/work distribution choices
3. CUDA
   • Explore multiple thread organizations to find the best performing option
   • Use shared memory

You do not have to create optimal versions of the code, but you want to create reasonably efficient implementations.

Option 2

The environment that you choose should not be one that has already been explored in assignments for this course. However, you are welcome to implement graph algorithms that you have already worked with on this new environment (i.e., you do not have to choose new graph algorithms if you do not wan to, but you can if you want to). Some example environments you might consider are MapReduce, Spark, or PIM.

Graph Inputs for Evaluation

Whichever option you choose, you should evaluate each of your graph algorithms on 2 different input files. These 2 different input files should have different characteristics (e.g., degrees of connectivity), which you will describe in your write-up. Make sure to cite where these graph inputs come from in your write-up. The runtime for your sequential algorithm should be in the minute(s) range on these inputs.

Part 3: Writeup and Final Code

To submit your code and final writuep, submit via gitlab by Saturday, May 24 at 5pm. No extensions will be allowed as this is a college-wide deadline.

Please include the following

1. Final paper
   • Option 1: Your final write-up should start with a complete description of your chosen algorithm (including citations) and your input graphs (including their distinct characteristics). You should have a section that explains your different parallelization approaches, describes why you chose those approaches, presents performance numbers for the different parallelization approaches in figures across the different programming environments, and provides an explanation for the differences in performance for the different approaches on the different input files. Writing in LaTex is preferred but not required.
   • Option 2: Your final write-up should start with a description of the sytem and the graph algorithms implemented as well as the two graph input files (including their distinct characteristics). You should have a section that describes the unique features of the system. You should also describe how you had to adapt each of the graph algorithms for this new environment. You should present performance numbers showing the benefits obtained from using this system for each graph algorithm and then also discuss any aspects of the graph algorithms that aren't well-suited to this system, resulting in limited performance benefits. Writing in LaTex is preferred but not required.
2. Code - All the files for your source code only. Please do not include any executables.
3. Makefile and README - Your Makefile and a README file that contains any other information that I need to compile and run your code.