Quick links

Depth Complexity in Object-Parallel Graphics Architectures

Report ID:
August 1992
Download Formats:


We consider a multiprocessor graphics architecture object--parallel if
graphics primitives are assigned to processors without regard to
screen location, and if each processor completely renders the
primitives it is assigned. Such an approach leads to the following
problem: the images rendered by all processors must be merged, or
composited, before they can be displayed. At worst, the number of
pixels that must be merged is a frame per processor. Perhaps there is
a more parsimonious approach to pixel merging in object--parallel
architectures than merging a full frame from each processor. In this
paper, we analyze the number of pixels that must be merged in
object--parallel architectures. Our analysis is from the perspective
that the number of pixels to be merged is a function of the depth
complexity of the graphics scene to be rendered, and a function of the
depth complexity of each processor's subset of the scene to be
rendered. We derive a model of depth complexity of graphics scenes
rendered on object--parallel architectures. The model is based
strictly on the graphics primitive size distribution, and on number of
processors. We validate the model with trace data from a number of
graphics applications, and with trace--driven simulations of rendering
on object--parallel architectures. The results of our analysis
suggest some directions in design of object--parallel architectures,
and suggest that our model can be used in future analysis of design
trade--offs in these architectures.

Follow us: Facebook Twitter Linkedin