Equalizer  2.1.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 <co/objectVersion.h>
29 #include <eq/fabric/pipe.h> // base class
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, const Eye eye,
125  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
lunchbox::RefPtr< Server > ServerPtr
A reference-counted pointer to an eq::Server.
Definition: eq/types.h:215
A configuration is a visualization session driven by an application.
Definition: config.h:58
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:52
EQ_API Config * getConfig(const int argc, char **argv)
Convenience function to retrieve a configuration.
Base data transport class for pipes.
Definition: fabric/pipe.h:32
An interface to process system messages or events.
Definition: messagePump.h:27
The interface definition for system-specific GPU handling.
Definition: systemPipe.h:38
The Equalizer client library.
Definition: eq/agl/types.h:23
lunchbox::RefPtr< Client > ClientPtr
A reference-counted pointer to an eq::Client.
Definition: eq/types.h:211
A View is a 2D area of a Layout.
Definition: view.h:46
A facility class to manage OpenGL objects across shared contexts.
Definition: objectManager.h:56
A holder for a frame data and related parameters.
Definition: frame.h:46