ICS 643 Spring 2022 Assessment/Grading

The approach to assignments, exams, and relative weighting is intended to assess multiple aspects of your developing expertise in design and analysis of parallel algorithms. In summary, the components and their default weights (percentage of the overall grade) include:

  • Class Participation: 10%

  • Homework Problems: 40%

  • Midterm Exam: 20%

  • Research paper presentation: 30%

We reserve the right to adjust the total number of points depending on circumstances.

Points, Percents and Letter Grades

To determine letter grades, we use a 4-percent spread per grade increment, i.e., 100-97=A+, 96-93=A, 92-89=A–, 88-85=B+, 84-81=B, 80-77=B–, 76-73=C+, 72-69=C, 68-65=C–, 64-61=D+, 60-57=D, 56-53=D–, 52-0=F. To adjust for variability in the exam difficulty between the semesters, the exams will be graded on a curve with a B average. If upon inspection of the distribution of grades we feel that too many students who understand the material are not getting the grades they deserve, we may then make adjustments in favor of students (especially for those who did well on exams).

Components

Class Participation and in-class quizzes (10%):

The lectures will be fairly interactive: throughout the lecture I will ask questions that will test your understanding of the material being presented. Students are also encouraged to ask questions about anything that is not clear. Student answers and actively asking questions will contribute to the participation grade.

Homework Problems (40%):

There will be 4 to 8 homeworks throughout the semester. You are encouraged to work on the homework problems with other classmates. However, the final write up must be performed individually, in own words, that means copying solution from each other is NOT permitted. Using internet to find solutions to homework problems is also NOT permitted and will be treated as plagiarism (see Class Policies for more details). Exam questions often are similar to homework problems, so this is your chance to make sure that you understand concepts and can work out problems on your own within the time pressures of the exam, not just in a group context.

The homework must be typed up - handwritten homeworks will receive no credit. You should use a good typesetting software that has high-quality equation editor and pseudocode typesetting. I highly recommend Latex and using algpseudocode package. If you use other typesetting software, make sure you use proper indentation in your pseudocode and don't rely on brackets to define your code blocks. Avoid using ASCII symbols when a more natural mathematical symbols exist, e.g., use ≠ intead of !=, or properly typeset exponentiation instead of using ^ symbol. Using such simple changes significantly improves readability of your pseudocode by humans.

Start each problem on a separate page. Any problem that does not start on a separate page will be given 0 points. Write down your name on every page, as the problems will be separated for grading and if a page does not have your name we will not know who wrote the solution.

Homework submission: Homeworks should be submitted in Laulima in PDF format. They will be due before the corresponding class period. Since homework solutions will be discussed during the lecture, no late homeworks will be accepted.

Take-home Midterm Exam (20%):

The midterm exam will cover the first half of the course. The exam will be a take-home exam, open book, open notes, but no internet resources except the reading materials listed on the course website are allowed. The midterm exam must be an individual effort with no collaborations allowed. Just like the homeworks, the exam solutions must be typed up.

Research paper presentation (30%):

By the end of the semester, the students will be expected to read a research paper on the topic of parallel algorithms, understand the presented algorithm, prepare a 30-minute presentation and present the paper to the rest of the class, with the goal of teaching your classmates a new algorithm. You will be graded on the quality of the prepared slides, the clarity of the presented details of the algorithm, and your ability to answer questions about the presented algorithm. The rest of the students will be expected to give feedback on each presentation, which will contribute to their class participation grade.

The list of potential papers to choose from is presented below. However, if you have a paper you'd like to present, talk to me to make sure the paper has enough algorithmic novelty to be appropriate for the class.

Suggested Research Papers for Final Presentation

[ASZ20] Alexandr Andoni, Clifford Stein, and Peilin Zhong: Parallel approximate undirected shortest paths via low hop emulators. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing (STOC’20), pages 322–335, 2020.

[BCH+18] Kyle Berney, Henri Casanova, Alyssa Higuchi, Ben Karsin, Nodari Sitchinava: Beyond binary search: parallel in-place construction of implicit search tree layouts. IEEE Transactions on Computers, (Early Access): (2021).

[BFG+20] Guy E. Blelloch, Jeremy T. Fineman, Yan Gu, Yihan Sun: Optimal parallel algorithms in the Binary-Forking model. In Proceedings of the 32nd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’20), pages 89–102, 2020.

[BGS+20a] Guy E. Blelloch, Yan Gu, Julian Shun, Yihan Sun: Randomized incremental convex hull is highly parallel. In Proceedings of the 32nd ACM Symposium on Parallelism in Algorithms and Architectures (SPAA’20), pages 103–115, 2020.

[BGS+20b] Guy E. Blelloch, Yan Gu, Julian Shun, Yihan Sun: Parallelism in randomized incremental algorithms. J. ACM 67, 5, Article 27 (2020).

[BGS+16] Guy E. Blelloch, Yan Gu, Yihan Sun, and Kanat Tangwongsan: Parallel shortest paths using radius stepping. In Proceedings of the 28th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’16), pages 443–454, 2016.

[BS11] Guy E. Blelloch, Julian Shun: A simple parallel cartesian tree algorithm and its application to suffix tree construction, In Proceedings of the Workshop on Algorithm Engineering and Experiments (ALENEX’11), pages 48–58, 2011.

[BTZ98] Gerth Stølting Brodal, Jesper Larsson Träff, Christos D. Zaroliagis: A parallel priority queue with constant time operations. Journal of Parallel and Distributed Computing, 49(1): 4–21 (1998).

[CFR20] Nairen Cao, Jeremy T. Fineman, and Katina Russell: Efficient construction of directed hopsets and parallel approximate shortest paths. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing (STOC’20), pages 336–349, 2020.

[CR10] Richard Cole, Vijaya Ramachandran: Resource oblivious sorting on multicores. In International Colloquium on Automata, Languages and Programming (ICALP’10), pages 226–237, 2010.

[EFS20] Jonas Ellert, Johannes Fischer, Nodari Sitchinava: LCP-aware parallel string sorting. In Proceedings of the 26th International European Conference on Parallel and Distributed Computing (Euro-Par ’20), pages 329–342, 2020.

[GGB96] Michael T. Goodrich, Mujtaba R. Ghouse, J. Bright. Sweep methods for parallel computational geometry. Algorithmica 15: 126–153 (1996).

[GJS21] Michael T. Goodrich, Riko Jacob, Nodari Sitchinava: Atomic power in forks: a super-logarithmic lower bound for implementing butterfly networks in the Nonatomic Binary Fork-Join model. In Proceedings of the 32nd ACM-SIAM Symposium on Discrete Algorithms (SODA ’21), pages 2141–2153, 2021.

[GOS21] Yan Gu, Omar Obeya, Julian Shun: Parallel in-place algorithms: theory and practice. In Proceedings of the Symposium on Algorithmic Principles of Computer Systems (APOCS’21), pages 114–128, 2021.

[L86] Michael Luby: A simple parallel algorithm for the maximal independent set problem. /SIAM J. Comp 15(4): 1036–1053 (1986).

[MS03] U. Meyer, P. Sanders: Δ-stepping: a parallelizable shortest path algorithm. Journal of Algorithms 49(1): 114–152 (2003).

[TV91] Robert Tamassia, Jeffrey S. Vitter: Parallel transitive closure and point location in planar sturctures. SIAM J. Comput. 20(4): 708-725 (1991).