Sequel
Sequel provides an abstraction to the Equalizer parallel rendering framework which allows rapid development of clustered multi-GPU applications. The central interface of Sequel is provided by the two classes Application and Renderer which provide a streamlined interface for parallel rendering applications.
Equalizer
Equalizer provides a distributed, scalable, multipipe, multithreaded GLUT-like programming interface.
Equalizer abstracts the application code from the actual configuration of the execution environment. Compared to other cluster-rendering software, it does not replace the OpenGL library but parallelizes and distributes the application's rendering code for optimal performance.
The API is minimally invasive and allows to retain nearly all of the application's rendering code. Equalizer provides the natural execution framework for any multi-GPU application and does not impose any specific rendering framework, such as a scenegraph or graphics library, to the application. It follows the natural execution model of any multi-GPU application, thus making it as easy as possible to modify existing applications for parallel rendering on visualization clusters.
Equalizer uses a callback-driven interface. Applications provide their rendering methods, which are called by the Equalizer framework according to the current configuration and system load. Process and thread creation, task synchronization and network connections are externalized from the application and handled by the Equalizer framework.
To port an application to run in a multi-GPU environment, the rendering code is separated from the core application logic. The Equalizer framework will then take care of the multiprocessing and synchronization and calls the application-provided rendering methods in parallel. The basic execution flow of a singlepipe and a multi-GPU application is show on the right (click on picture to enlarge).
Equalizer abstracts common graphic entities into C++ classes, for example:
- Node - a single computer in the cluster
- Pipe - a graphics card and rendering thread
- Window - an OpenGL drawable
- Channel - a viewport within a window
The application subclasses these entities, and overrides task methods to provide the application's rendering code. Each method corresponds to a task, and for all of them Equalizer provides a default method which implements the typical use case. This allows a quick start for the developer, which can replace the defaults gradually with his own code. The full list of task methods is part of the developer documentation. Some of the most important methods are:
- Channel::frameDraw - render using the provided frustum, viewport and range
- Window::configInit - initialize OpenGL drawable and state
- Pipe::frameStart - update frame-specific data
- Node::configInit - initialize per node application data
Collage
Collage is the network backend library used by Equalizer. It is used to build network-distributed applications. In contrast to other cluster API's, such as MPI or PVM, this API is designed for the development of interactive applications. Certain characteristics of visualization software, e.g. the frame-driven rendering, are exploited for better performance and simpler programming interface.
Lunchbox
Lunchbox is the foundation for both Collage and Equalizer. It provides common functionality for the development of high-performance multi-threaded applications. It has the same scope as Boost, but goes beyond in the support for multi-threaded applications by providing utilities tuned for for common concurrency use cases.
