Equalizer  2.0.0
Parallel Rendering Framework
pipe.h
1 
2 /* Copyright (c) 2005-2015, Stefan Eilemann <eile@equalizergraphics.com>
3  * Cedric Stalder <cedric.stalder@gmail.com>
4  * Daniel Nachbaur <danielnachbaur@gmail.com>
5  *
6  * This library is free software; you can redistribute it and/or modify it under
7  * the terms of the GNU Lesser General Public License version 2.1 as published
8  * by the Free Software Foundation.
9  *
10  * This library is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
13  * details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with this library; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19 
20 #ifndef EQ_PIPE_H
21 #define EQ_PIPE_H
22 
23 #include <eq/api.h>
24 #include <eq/eye.h> // Eye enum
25 #include <eq/types.h>
26 #include <eq/visitorResult.h> // enum
27 
28 #include <eq/fabric/pipe.h> // base class
29 #include <co/objectVersion.h>
30 
31 namespace eq
32 {
33 namespace detail
34 {
35 class Pipe;
36 class RenderThread;
37 class ThreadAffinityVisitor;
38 }
39 
50 class Pipe : public fabric::Pipe< Node, Pipe, eq::Window, PipeVisitor >
51 {
52 public:
54  EQ_API explicit Pipe( Node* parent );
55 
57  EQ_API virtual ~Pipe();
58 
61  EQ_API co::CommandQueue* getPipeThreadQueue();
62  co::CommandQueue* getMainThreadQueue();
63  co::CommandQueue* getCommandThreadQueue();
64  co::CommandQueue* getTransferThreadQueue();
65 
67  EQ_API Config* getConfig();
69  EQ_API const Config* getConfig() const;
70 
72  EQ_API ClientPtr getClient();
73 
75  EQ_API ServerPtr getServer();
76 
81  bool isRunning() const;
82 
87  EQ_API bool isStopped() const;
88 
96  EQ_API uint32_t getCurrentFrame() const;
97  EQ_API uint32_t getFinishedFrame() const;
98 
109  EQ_API WindowSystem getWindowSystem() const;
111 
124  Frame* getFrame( const co::ObjectVersion& frameVersion,
125  const Eye eye, const bool output );
126 
128  co::QueueSlave* getQueue( const uint128_t& queueID );
129 
131  void flushFrames( util::ObjectManager& om );
132 
134  const View* getView( const co::ObjectVersion& viewVersion ) const;
135 
137  View* getView( const co::ObjectVersion& viewVersion );
139 
140  void waitExited() const;
141  void notifyMapped();
142 
150  EQ_API void waitFrameFinished( const uint32_t frameNumber );
151 
158  EQ_API EventOCommand sendError( const uint32_t error );
159 
167  EQ_API void waitFrameLocal( const uint32_t frameNumber ) const;
168 
169  EQ_API bool processEvent( Statistic& event );
170 
172  void startThread();
173 
175  void exitThread();
176 
177  void cancelThread();
178 
180  bool startTransferThread();
181 
183  QThread* getTransferQThread();
184 
186  bool hasTransferThread() const;
187 
200  EQ_API void setSystemPipe( SystemPipe* pipe );
201 
203  EQ_API SystemPipe* getSystemPipe();
204 
206  EQ_API const SystemPipe* getSystemPipe() const;
208 
223  EQ_API virtual MessagePump* createMessagePump();
224 
226  MessagePump* getMessagePump();
228 
230  EQ_API virtual void setDirty( const uint64_t bits );
231 
232 protected:
240  EQ_API bool isWindowSystemAvailable( const std::string& name ) const;
242 
251  EQ_API void startFrame( const uint32_t frameNumber );
252 
259  EQ_API void releaseFrame( const uint32_t frameNumber );
260 
267  EQ_API void releaseFrameLocal( const uint32_t frameNumber );
269 
286  EQ_API virtual WindowSystem selectWindowSystem() const;
287 
294  EQ_API virtual bool configInit( const uint128_t& initID );
295 
302  EQ_API virtual bool configInitSystemPipe( const uint128_t& initID );
303 
308  EQ_API virtual bool configExit();
309 
326  EQ_API virtual void frameStart( const uint128_t& frameID,
327  const uint32_t frameNumber );
328 
343  EQ_API virtual void frameFinish( const uint128_t& frameID,
344  const uint32_t frameNumber );
345 
356  EQ_API virtual void frameDrawFinish( const uint128_t& frameID,
357  const uint32_t frameNumber );
358 
360  EQ_API virtual void attach( const uint128_t& id, const uint32_t instanceID );
361 
362 private:
363  detail::Pipe* const _impl;
364  friend class detail::RenderThread;
365 
366  //-------------------- Methods --------------------
367  void _setupCommandQueue();
368  void _setupAffinity();
369  void _exitCommandQueue();
370 
372  EQ_API int32_t _getAutoAffinity() const;
373  friend class detail::ThreadAffinityVisitor;
374 
375  //friend class Window;
376 
377  void _stopTransferThread();
378 
380  void _releaseViews();
381 
383  void _flushViews();
384 
386  void _flushQueues();
387 
388  /* The command functions. */
389  bool _cmdCreateWindow( co::ICommand& command );
390  bool _cmdDestroyWindow( co::ICommand& command );
391  bool _cmdConfigInit( co::ICommand& command );
392  bool _cmdConfigExit( co::ICommand& command );
393  bool _cmdFrameStartClock( co::ICommand& command );
394  bool _cmdFrameStart( co::ICommand& command );
395  bool _cmdFrameFinish( co::ICommand& command );
396  bool _cmdFrameDrawFinish( co::ICommand& command );
397  bool _cmdExitThread( co::ICommand& command );
398  bool _cmdDetachView( co::ICommand& command );
399  bool _cmdExitTransferThread( co::ICommand& command );
400 
401  LB_TS_VAR( _pipeThread );
402 };
403 }
404 
405 #endif // EQ_PIPE_H
A configuration is a visualization session driven by an application.
Definition: config.h:55
A Pipe represents a graphics card (GPU) on a Node.
Definition: pipe.h:50
A Node represents a single computer in the cluster.
Definition: node.h:49
EQ_API Config * getConfig(const int argc, char **argv)
Convenience function to retrieve a configuration.
lunchbox::RefPtr< Server > ServerPtr
A reference-counted pointer to an eq::Server.
Definition: eq/types.h:215
Base data transport class for pipes.
Definition: fabric/pipe.h:31
An interface to process system messages or events.
Definition: messagePump.h:27
The interface definition for system-specific GPU handling.
Definition: systemPipe.h:38
lunchbox::RefPtr< Client > ClientPtr
A reference-counted pointer to an eq::Client.
Definition: eq/types.h:211
The Equalizer client library.
Definition: eq/agl/types.h:23
A View is a 2D area of a Layout.
Definition: view.h:42
A facility class to manage OpenGL objects across shared contexts.
Definition: objectManager.h:53
A holder for a frame data and related parameters.
Definition: frame.h:43