api.shtml

#define S_HOME
#define S_HOME_API
#define PAGE About
#define SUBPAGE Parallel Programming Interface

#define KEYWORDS "Parallel Programming Interface, multithreaded GLUT, parallel OpenGL"

#include "header.shtml"

<h2>Sequel</h2>
<p>
  <a href="http://eyescale.github.io/Equalizer-1.10/namespaceseq.html#details">Sequel</a>
  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 <a href="http://eyescale.github.io/Equalizer-1.10/classseq_1_1_application.html">Application</a>
  and <a href="http://eyescale.github.io/Equalizer-1.10/classseq_1_1_renderer.html">Renderer</a>
  which provide a streamlined interface for parallel rendering applications.
</p>

<h2>Equalizer</h2>
<p>
  Equalizer provides a distributed, scalable, multipipe,
  multithreaded <a href="/equalizergraphics.com/documents/Howtos/glutToEqualizer.html">GLUT-like</a>
  <a href="http://eyescale.github.io/Equalizer-1.10/namespaceeq.html#details">programming
  interface</a>.
</p>
<p>
  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.
</p>
<p>
  The API is <em>minimally invasive</em> 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.
</p>
<div class="float_right"><a href="/equalizergraphics.com/images/executionFlow.png">
    <img src="images/executionFlow-small.jpg"
         alt="Execution flow of a single-threaded and a multi-GPU application">
</a></div>
<p>
  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.
</p>
<p>
  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).
</p>
<p>
  Equalizer abstracts common graphic entities into C++ classes, for example:
</p>
<ul>
  <li><b>Node</b> - a single computer in the cluster</li>
  <li><b>Pipe</b> - a graphics card and rendering thread</li>
  <li><b>Window</b> - an OpenGL drawable</li>
  <li><b>Channel</b> - a viewport within a window</li>
</ul>
<p>
  The application subclasses these entities, and
  overrides <a href="/equalizergraphics.com/documents/design/taskMethods.html">task methods</a> 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 <a href="/equalizergraphics.com/documents/design/taskMethods.html">full list of task
  methods</a> is part of the <a href="/equalizergraphics.com/doc_developer.html">developer
  documentation</a>.  Some of the most important methods are:
  <ul>
    <li><a href="/equalizergraphics.com/documents/design/taskMethods.html#channeldraw">
        <b>Channel::frameDraw</b></a> - render using the provided frustum,
      viewport and range</li>
    <li><a href="/equalizergraphics.com/documents/design/taskMethods.html#windowinit">
        <b>Window::configInit</b></a> - initialize OpenGL drawable and
      state</li>
    <li><a href="/equalizergraphics.com/documents/design/taskMethods.html#pipestartframe">
        <b>Pipe::frameStart</b></a> - update frame-specific data</li>
    <li><a href="/equalizergraphics.com/documents/design/taskMethods.html#nodeinit">
        <b>Node::configInit</b></a> - initialize per node application data</li>
  </ul>
</p>

<h2>Collage</h2>
<p>
<a href="http://www.libcollage.net">Collage</a> 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.
</p>

<h2>Lunchbox</h2>
<p>
  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.
</p>

#include "footer.shtml"
<!-- $Id$ -->