##
Graphs

####
Introduction

One of the most interesting features of GLperf
is its ability to measure OpenGL rendering
performance as one or more parameters (such as the triangle size or the
number of active lights) are varied. Rather than giving a single point
result (such as 1 million 25 pixel triangles per second), GLperf allows
performance to be characterized over a broad range of possible scenarios
and state combinations. The results from these kind of tests are best visualized
as charts or graphs, and this document demonstrates a selection of graphs
generated automatically from GLperf data using GNUplot.
####
Graph Descriptions

Triangle Fill
The triangle fill graphs show how triangle rendering performance (measured
as triangles per second) varies as a function of triangle size (in pixels),
for a variety of different rendering modes.

The flat part at the start of each curve obviously indicates a range
over which the performance of the system is independent of the triangle
size. In this region we generally assume the system is geometry limited
- i.e. it is the calculations for transforming vertices, performing
lighting and triangle setup (which are all independent of triangle size)
that are holding back the system, not the rate at which the system can
fill pixels (rasterization). Depending on the system and the rendering
mode, this bottleneck may also be caused by CPU or bus bandwidth limitations.
As the triangles get larger, at some point the rasterization becomes the
limiting factor and performance suddenly begins to decrease. The point
at which this occurs, and the rate at which the curve drops off can be
used to infer the fill-rate capabilities of a system.

Line Fill

Similarly, the line fill graphs show how line rendering performance
(in lines per second) varies as a function of line length (in pixels).

Primitive Batching

Primitive batching graphs show how rendering performance varies depending
on how many primitives are put within each glBegin/glEnd pair. Since starting
a new OpenGL primitive has a cost associated with it, performance can vary
depending on how many vertices are in a triangle strip, for example. In
addition, some systems batch up groups of primitives to work on them in
parallel, and the effects of this are also sometimes visible.

Multiple Lights

The multiple light graphs show how the rendering performance of triangles
and quadrilaterals varies as a function of the number of enabled OpenGL
lights. Some systems are optimized for the special case of one or two lights,
and exhibit non-linear performance degradation as more lights are added.