CS 553 -- Winter Quarter 2009

Project #8: Performance Characterization

60 Points

Due: February 18

This page was last updated: February 11, 2009

Requirements:

1. Design and implement an OpenGL performance test of your own choosing. There must be at least 10 versions of the test being run. That is, I want enough data to get an interesting graph of performance as a function of the quantity that you vary.

   Some possibilities are (but are certainly not restricted to):

   • Different pixel areas of quads or triangles
   • Different lengths of quad strips
   • Different lengths of triangle strips
   • Triangles vs. quads vs. triangle strips vs. quad strips for different pixel areas
   • Triangles and quads vs. the general GL_POLYGON
   • Different sizes of points, glPointSize(size)
   • Setting one color per GL_POINT (as you did in Project #3) vs. setting a color and drawing all points with that color

   Many more are possible. Choose something that sounds especially interesting to you. Failing that, choose something that you think will be interesting to me. :-)

2. Follow good scientific experimental practice: hypothesis, design the experiment, conduct the experiment, results, explanation.

3. Make sure you are not varying anything else other than the one parameter you are testing!

4. The turnin will be a paper report detailing:
   1. What you are testing
   2. Your hypothesis
   3. Your experiment, including what hardware you are using (CPU, speed, memory, graphics card)
   4. Your results, including a table and a graph of some sort
   5. Your conclusions and explanation. Why do you think it turned out this way?

5. In your graph, arrange the units so that faster performance goes up the Y axis. That is, give the performance in units such as "triangles per second" or "frames per second", not "milliseconds per triangle" (where fast would point down).
   That makes graphs easier to interpret and compare.

6. I don't need your executable this time.

7. I expect to learn a lot from your work, and will show some of them in class.

Methodology

• In Display( ), put the following around just what you are testing. That is, put this after the glClear( ) and setting the transformations, but before the swapping of the double-buffers.

  glFinish();
  int t0 = glutGet( GLUT_ELAPSED_TIME );
  << All Graphics Calls That You Are Testing The Speed Of >>
  glFinish();
  int t1 = glutGet( GLUT_ELAPSED_TIME );
  glutSwapBuffers();
  fprintf( stderr, "One display frame took %d milliseconds\n", t1 - t0 );
  

• Graphics cards today are really fast. Make your test size really big so that the precision of the system clock is not an issue.

• Be careful about where your coordinates are. For example, coordinates that fall outside the viewing volume will be clipped, and thus will provide no test at all for anything to do with pixel speed.

• Be careful about just putting a for( ) loop around a set of code. Some compilers will optimize that down to just one loop. If the time seems to be independent of the number of loops, fool the compiler by translating the scene based on the loop index.