EECS 675: Multicore and GPU Programming

Administrative

• Date: Friday, April 17, 2020
• Access the exam using the link on the home page. Test the sample that is there now to make sure you can open and read it. The actual exam will be posted at 9:00 a.m. It must be emailed back to me no later than 12:00 noon.

• I will closely monitor my email (especially during the first two hours) to answer any questions you may have.
• You will be on the honor system to:
  • Not communicate in any way with any person other than me.
  • Not to use the book, web site, google, or any other such print or online resource, except to send email to or receive email from me.

Exam Coverage

• Chapters 5.11, 5.12, 6-6.5 of the book.
• Posted web material: Items 3.f – 4.f of In-Class Materials.
• All lecture notes from when the items above were covered in class.

Exam Style

Questions usually consist of short-answer items (a few sentences to a paragraph), or questions that involve reading or writing code. For the latter, I do not expect you to memorize APIs. If a question involves specific APIs, I will give you the necessary prototypes. But given such a prototype, you are expected to know everything relevant to the question about how the function operates and the significance of its parameters. I will not remind you of that during the exam. Moreover, I usually try to make exams a bit more conceptual. For example, while questions certainly may involve writing some small segments of code, it is more common that I would ask questions about how you would design certain algorithms, data structures, and other design-level issues given properties of the platform and/or API than it is that I would ask you to write code to do some operation, particularly if a non-trivial amount of code would be required.

IMPORTANT

We will take time in class to review, including addressing items in this review guide, but there is preparation required on your part. Read this guide, review the book, your lecture notes and the web site, and come prepared to ask questions. The review will be most effective if you do not just pose questions verbatim from this guide.

Topic Review

1. OpenMPI (Chapter 5.11 & 5.12)
   • Know how all the collective communication message passing functions work. As usual, do not try to memorize function prototypes. If necessary for some question, I will provide you with the function prototypes. You will need to know what the meaning of the various parameters are and what the function does. I will not provide any such information to you during the exam.
   • Be able to state which message passing function is most appropriate for a given situation. In addition to the basic type (broadcast, scatter, etc.), this also importantly includes knowing whether the immediate or blocking version should be used. This should be very mechanical, given the description of a particular situation in which data must be communicated between processes.
   • Understand the basics of defining MPI data types. While I won't ask you to write the code to implement such a data type, you should understand the situations under which such a definition is useful. If I give you all or part of the code that defines a data type, you should be able to answer questions about the code.
2. GPU Programming (Chapter 6-6.5)
   • Understand all the terminology and pictures on the GPU Terminology page. Don't worry about the terms in the CAAQA column. Since the CUDA and OpenCL terms for a given concept are not always the same, I will (try to remember to) refer to a given term something like "warp (CUDA) or Wavefront (OpenCL)". If you think I have not been clear in that regard on a test question, ask me during the exam.
   • Understand the major GPU architectural concepts we have covered so far, including:
     • GPU (as a whole)
     • Global memory (and where it is with respect to the components of the GPU)
     • Streaming Multiprocessor (CUDA) or Compute Unit (OpenCL)
     • Shared memory (CUDA) or Local memory (OpenCL) (and where it is with respect to the components of the GPU)
     • Registers and where they are with respect to the components of the GPU.
   • Understand the basic execution model, the structure and significance of the computational grid, and the notion of local and global dimensions and IDs. Don't try to memorize built-in variables (e.g., blockIdx, gridDim, etc.) or built-in functions (get_global_id(int dim), get_local_id(int dim), etc.), but know what they are and how to use them if I give them to you on a question.
   • Understand the significance of Thread Blocks (CUDA) or Work Groups (OpenCL). This includes:
     • the relationship between them and the Streaming Multiprocessors (CUDA) or Compute Units (OpenCL)
     • local IDs
   • Understand all the posted code prior to 4.g and be able to answer questions about various parts of that code or of other code utilizing similar primitives.