Multicore and GPU Programming for Video Games (2012)

Multicore and GPU Programming for Video Games (2012)

Fall 2012

Many thanks to NVIDIA and ATI
for donating graphics cards for our Klaus 1446


  • HW #4 and HW #5 posted.
  • Slides for Session 19-20 (for lectures on 11/8 and 11/13)
    and Session 21 (for lecture on 11/5) posted.
    That will be the end of the lecture material.

Course Description

This webpage constitutes the class syllabus.

Aaron Lanterman (office Van Leer W431);
Fall 2012, TuTh 1:35-2:55;
Where: CoC 52

Old webpages, including old lecture videos (some have
errors; viewer beware!):
Fall 2007,
Fall 2008,
Fall 2009
(didn’t get around to posting all the videos, but still some good stuff),
Fall 2010,
Fall 2011 (didn’t record
video that year)

Course description: 3-D graphics pipelines. Real-time simulation
concerns. GPU architectures. Graphics APIs. Shader programming.
Multicore programming.

Any one of the following is sufficient:
ECE3035-Mechanisms for Computation
or ECE3090-Software
Fundamentals for Engineering Systems
or CS2110-Computer Organization and Programming
or CS2261-Media Device Architecture.
Students must be comfortable with C-like programming.
To be widely accessible to ECE students, no background in computer
graphics will be required.
A lot of the course will use C#, but
we will not assume that you’ve seen C# before, and hence will do an
introductory lecture on C#. (If you’ve seen Java, C++, or
any other “curly-brace” language, you’ve pretty much seen them all.)

Course objective:
This class provides the multicore and GPU programming skills
needed to meet timely demands of the multimedia, visualization,
and gaming industries. The course also bridges the gap between
our current generic computer architecture courses and the video
game design courses offered by CoC and LMC.
The class covers
state-of-the-art GPU and multicore
architectures from
application and hardware design perspectives. The course considers
programming models using examples from the algorithmic needs of
modern 3-D games (e.g. geometry processing, shading algorithms,
physical modeling, collision detection, and artificial intelligence).

Note that the course does not currently cover CUDA or OpenCL; I want
to say that up front since this has disappointed students in the past.
My reasoning is that such technologies are not available on the Xbox 360
and the Playstation 3, which dominate AAA game sales figures, and
even on the PC, the market has not gotten to the point where game developers
can generally assume that there is enough of a critical mass of PCs
equipped with such technologies to make it worth putting significant
effort into developing for them. (Also, there are several other classes
at Tech that cover things like CUDA, OpenCL, etc., particularly in
a scientific computing context where they are quite useful; for this
class to stand out, I want to specifically focus on the GPU’s “native
context” of video games.)



See previous years’ websites, particularly 2011, if you want to get a sense
of what sorts of things we’ll be getting into later in the semester.
Everything is subject change
as we work to inject additional awesomeness into the class.

Credit to where it’s due: much of the material below (particularly the lectures
on computer graphics and basic GPU programming, as well as the XNA code)
was created by (or in collaboration with)
Prof. Sean Lee.

Topics: Introduction; Introduction to Gaming Hardware; 3D Coordinates & Transformations;
3D to 2D Projection; Lighting & Rasterization; Texturing & Blending;
GPUs – Under the Hood; Introduction to XNA; Game Loops; Introduction to C#;
Walkthrough of an XNA 2D Game; XNA 3-D API Basics; Rendering 3-D Content;
Programmable Shaders; Environment & Bump Mapping; Postprocessing; Architectural
Comparison: Xbox 360 vs. Playstation 3; Introduction to Multithreading; Multicore
Strategies for Games


  • 9/13: Session 7 – GPUs – Under the Hood
    (PDF slides,
    PDF slides 4-up)

  • 9/22: Zynga Visit
  • 9/27: No lecture – work on HW #1
  • 10/25: No lecture – work on HW #2
  • Optional material – Projective Textures & Shadow Maps
    (PDF slides,
    PDF slides 4-up)

  • Optional material – Animation on the GPU
    (PDF slides,
    PDF slides 4-up)

  • Optional material – “Classic” GPGPU
    (PDF slides,
    PDF slides 4-up)

  • Optional material – PlayStation 2 Architecture
    (PDF slides,
    PDF slides 4-up)

  • 11/17, 11/22: No lecture – work on HW #4


  • Added 11/18 Some generally useful XNA/Xbox 360 links:


    Further information


    On-line discussions: We will use
    to facilitate class discussions. I will try
    to check Piazza at least
    once a day. You are welcome to post questions about anything
    related to
    the course material, and also answer other student’s questions, as long as
    you don’t
    “give away the answer” or post chunks of code that are more than a few lines.

    Software used in this class: Here are links
    to programs (SDKs, etc.)
    you want to get if you want to work on your own machine (which
    is strongly encouraged).

    Students will be expected to
    undertake several assignments to gain real programming experience on PCs with GPUs such
    as those designed by NVIDIA and ATI, and the Xbox 360. (“Integrated graphics” chips,
    such as those by Intel, have gotten powerful enough in recent years that some of them
    may be usable as well.)
    and ATI have made donations of several boards to support our class projects.
    There may also be a few short essay-type (around 1/2 page) questions and
    “pencil and paper” exercises.
    The final letter grade will be based on performance on these projects and
    exercises. Various assignments may have different weights in the final grade
    these weights will be noted on each assignment. Most of the
    assignments will be individual assignments; however,
    a few of them may provide the
    option to work in groups of two (such assignments may still be completed
    individually if you prefer to work alone).

    This is a class on programming, so even
    on team assignments, you
    should feel confident that you could complete an assignment on
    your own if you needed to.

    There will be no traditional paper-and-pencil exams, either midterms or
    finals. This is a class about programming; my philosophy is that any
    time you would spend taking or studying for such exams is better spent
    in front of a computer actually programming!

    Office hours:
    Shortly before assignments are due,
    I will post an announcement on Piazza describing when and
    where I will be sure to be available for questions.
    This will tend to change slightly from week to week,
    so look for that announcement.
    (Also, if you walk by my office and happen to see my
    VL431 office door open,
    you are welcome to pop in with questions about the class and/or life in general.)

    Of course you are always welcome
    to e-mail me and we can set up a specific time to meet. Again, put “MPG” in your subject.

    Honor code:
    This course
    will be conducted under the rules and guidelines of the Georgia Tech Honor Code;
    infractions will be reported to the Dean of Students.
    The “ground rules” for each assignment,
    which may vary from assignment to assignment, will be given in each
    assignment description. Please ask if any aspects of the given “ground
    rules” seem unclear.

    Backfile policy:
    Use of homework
    solutions and from previous versions of this class is forbidden.
    The material is highly complex,
    so it is extremely difficult to come up with 100% new project descriptions on each offering.
    Please be fair to students who may not have access to the same old materials.
    Detection of the use of backfiles will result in significant wrath.
    I have substantial experience
    with this matter on recycled lab reports in ECE2025.

    Major emergencies:
    If you have some sort of major life emergency – serious illness or injury,
    death in the family, house burns down or is flooded, etc. – that seriously
    impedes your progress in the class, please let me know as soon as possible
    so we can work something out.
    You will find professors can be quite reasonable if you keep us in the loop.
    Please don’t disappear with no warning half way through,
    making me think that you dropped the class, and then reappear out of
    nowhere the week before finals asking what you can do to make things up.
    (Yes, this has happened quite a bit, in both undergrad and grad classes.)

    On things that beep and blink:
    Please silence all cell phones and pagers
    before entering class. If you forget to do so and receive
    a call, please shut the noisemaking device down as quickly as possible,
    and return the person’s call after class. (Of course, there
    are reasonable
    exceptions, i.e. if your wife is in the 9th month of her pregnancy and may
    give birth at any moment or your
    kid isn’t feeling well but he or she
    went to school anyway and their school nurse
    may need to call you, leave your
    phone on vibrate, and answer it as quickly as possible and
    immediately step out
    of the room to handle the call.)

    In general,
    please do not instant message, websurf, Facebook (can I use it as a verb?),
    play games, etc. during class
    It can be quite distracting.
    Unless I say otherwise, the preferred position for laptops during
    class is in your backpack

    The Twitter exception:
    Lanterman says something particularly brilliant and clever during lecture,
    you are allowed to
    use your phone to Tweet it or post
    it to Facebook.