Multicore and GPU Programming for Video Games (2012)

Fall 2012

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

News

• 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.

Instructor:
Aaron Lanterman (office Van Leer W431);
When:
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.

Prereqs:
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.)

Assignments

• HW #1: “Roll Your Own” 3-D Rendering
  (due date Thursday, Sept. 27 at 23:59:59 via T-square)

 

• HW #2: Adding a Dimension
  (due date Wednesday, Oct. 24 at 23:59:59 via T-square)

 

• HW #3: Now You Are Thinking with Shaders
  (due date Wednesday, Nov. 7 at 23:59:59 via T-square)
• HW #4: Shaded First Person Shooter
  (due Wednesday, Nov. 21 at 4:30 PM via T-square)
• HW #5: Aperture Science Xbox Multicorification
  Center
  (due Tuesday, Dec. 11 at 5:40 PM;
  replaces a traditional written final
  exam)

  Schedule

  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

  • 8/21: Session 1 – Introduction
    (PDF slides,
    PDF slides 4-up)
    • This videos was not shown in lecture, so be sure to check it out:
      Ian Bogost
      on The Colbert Report
  • 8/23: Session 2 – History of gaming hardware
    (PDF slides,
    PDF slides 4-up)
    • Videos: Intellivision TV Commercials –
      Plimpton Sports,
      Major League Baseball,
      Star Strike;
      Colecovision 1980s
      Commercial;
      Atari E.T. Commercial;
      SEGA Commercial –
      Sega vs. Nintendo (“Blast Processing”),
      Genesis
      Does What Nintendon’t; Insomniac’s
      “Disruptor”:
      gameplay,
      cutscene;
      Konami’s “Metal
      Gear Solid”;
      Rare’s
      “Goldeneye 007”
  • 8/28: Session 3 – 3D Coordinates & Transformations
    (PDF slides,
    PDF slides 4-up)
  • Optional material – Arbitrary Rotations
    (PDF slides,
    PDF slides 4-up)
  • 8/30: Session 4 – 3D to 2D Projection
    (PDF slides,
    PDF slides 4-up)
  • 9/4, 9/6: Session 5 – Lighting & Rasterization
    (PDF slides,
    PDF slides 4-up)
  • 9/11: Session 6 – Texturing & Blending
    (PDF slides,
    PDF slides 4-up)
  • 9/13: Session 7 – GPUs – Under the Hood
    (PDF slides,
    PDF slides 4-up)
  • 9/18: Session 8a – Introduction to XNA
    (PDF slides,
    PDF slides 4-up)
  • 9/20: Session 8b – Game Loops
  • 9/25: Session 9 – Introduction to C#
    (PDF slides,
    PDF slides 4-up)
  • 9/27: Session 10 – Walkthrough of an XNA 2D Game
    (PDF slides,
    PDF slides 4-up)
    • “DawgShower” 2-D Shooter Game
  • 10/2: Session 11 – XNA 3-D API Basics
    (PDF slides,
    PDF slides 4-up)
    • XNA graphics demos, part 1
  • 10/4: Session 12 – Rendering 3-D Content
    (PDF slides,
    PDF slides 4-up)
    • XNA graphics demos, part 2
  • 10/9: Session 13 – Programmable Shaders, Part 1
    (PDF slides,
    PDF slides 4-up)
    • HLSL shader demos
  • 10/11: Session 14 – Programmable Shaders, Part 2
  • 10/18: Session 15 – Programmable Shaders, Part 3
  • 10/25: Session 16 – Environment & Bump Mapping
    (PDF slides,
    PDF slides 4-up)
  • 10/30: Session 17 – Postprocessing
    (PDF slides,
    PDF slides 4-up)
  • 11/1: Session 18 – Architectural Comparison: Xbox 360 vs. Playstation 3
    (PDF slides,
    PDF slides 4-up)
  • 11/6: No lecture — go vote if you are eligible and haven’t done
    so already
  • 11/8: Session 19 – Introduction to Multithreading, Part 1
    (PDF slides,
    PDF slides 4-up)
    • Bruce Dawson,
      
      Lockless
      Programming Considerations for Xbox 360 and Microsoft Windows
    • Bruce Dawson,
      
      Lockless Programming in Games
    • Threading in C#
      by Joseph Albahari (hat tip to former MPG student Travis Gockel for
      pointing out the link)
    • Mike
      Gold, Introduction
      to Multithreading in C#
    • Bruce Dawson, Multi-Core
      Memory Coherence – The Hidden Perils of Sharing Data
      (extremely advanced, focused
      on “pro” Xbox 360 C++ development)
  • Optional material – Pulse/Wait and Semaphores
    (PDF slides,
    PDF slides 4-up)
  • 11/13: Session 20 – Introduction to Multithreading, Part 2
  • 11/15: Session 21 – Multicore Strategies for Games
    (PDF slides,
    PDF slides 4-up)
    • Bruce
      Dawson,
      Coding
      for Multiple Cores on Xbox 360 and Microsoft Windows (the
      code examples are C++, not C#, but many of the ideas still apply; just
      remember that XNA/C# programming hides from you some of the more
      difficult aspects of “raw” Xbox 360 C++ programming)
    • Bruce Dawson and Chuck Walbourn, PowerPoint presentation,
      Coding for Multiple Cores
      (same parenthetical comment for the last bullet point applies)
    • Ian Lewis,
      Multicore
      Programming, Two Years Later
      and
      Getting
      More from Multicore (advanced, mostly focused
      on “pro” Xbox 360 C++ development)
    • Blog entries by The Pensive Gamer:
      XNA Game Loop
      and Threading,
      XNA Threading – The Problems,
      XNA Threading – Locks
    • Catalin Zima,
      
      Multi-threading for your XNA Game (zip file of materials)
    • Frozax Games,
      
      Yes, multi-threading in XNA/C# can be that simple!
    • Generic XNA
      – Threading for Windows & Xbox 360
    • Flauschig Dev. Blog,
      <A HREF=”http://dev.flauschig.ch/wordpress/?p=255.Net / XNA 4.0
      Multithreading experiments
    • Running on Empty,
      XNA
      Framework GameEngine Development (Part 8,
      Multi-Threading GameComponents) – focuses on background loading
    • Intel’s
      
      XNA* game examples (seems to be for Windows, not Xbox 360)
    • Jeff Andrews, Threading Basics for Games; also see
      Designing the Framework of a Parallel Game Engine
      (not specific to XNA)

  <!–

• 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)
  • C. Everitt,
    Projective Texture Mapping
  • C. Everitt, A. Rege, C. Cebenoyan,
    
    Hardware Shadow Mapping
• Optional material – Animation on the GPU
  (PDF slides,
  PDF slides 4-up)
• Optional material – “Classic” GPGPU
  (PDF slides,
  PDF slides 4-up)
  • Xbox
    360 System Architecture,
    IEEE Micro, Vol. 26, No. 2,
    March-April 2006, pp. 25-37.
• 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:
  • Added 11/18 Managed
    Code Performance on Xbox 360 for XNA: Part 1 – Intro and CPU
  • Added 11/18 Managed Code Performance on Xbox 360 for XNA: Part 2 – GC and Tools
  • Added 11/18 Shawn Hargreaves, Understanding XNA Framework Performance

  –>

  Further information

  • Aaron
    Lanterman’s notes from GDC 2009
  • 
    ExtremeTech 3D Pipeline Tutorial – absolutely superb!!! This goes very
    well with the 3D Pipeline lectures.
  • Related classes
    (both at GaTech and other schools)
  • Students Explore Video Game Programming and Architecture
    in New Course – article on the class from Volume 4, Issue 4 of the
    ECE Highlights newsletter
  • Video interview
    with Aaron Lanterman about the class,
    conducted by gamezombie.tv at the 2007 Game Developers Conference
  • Original
    course proposal webpage – explains some of
    our original motivations for
    putting the class together (although some of what’s described will be
    out of date)
  • Research by people in the game industry:
    • Valve
      Publications (including papers on shading in
      Half-Life 2 and Team Fortress 2)
    • Insomniac
      R&D – notice how deep they are into
      Cell SPU assembly programming!
  • 
    GPU Gems: Programming Techniques, Tips, and Tricks for Real-Time Graphics
    (complete book online)
  • 
    GPU Gems 2: Programming Techniques for High-Performance Graphics and
    General-Purpose Computation (complete book online)
  • 
    GPU Gems 3 (complete book online)
  • The Cg Tutorial (complete book online)
  • XNA Resources: Nuclex
    Framework (a “set of
    fast and elegant components that take care of the
    grunt work required to implement certain features,
    designed with minimal dependencies, so you can just pick what you really need”,
    which happens to include a multithreaded particle system),
    XSDK2 (XNA 4.0 Resources)

  Administrivia

  On-line discussions: We will use
  Piazza
  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).

  Grading:
  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.)
  NVIDIA
  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
  calculation;
  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?),
  e-mail,
  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:
  If
  Prof.
  Lanterman says something particularly brilliant and clever during lecture,
  you are allowed to
  use your phone to Tweet it or post
  it to Facebook.