?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / System / Cluster / Window / SortLast / OSGBinarySwapComposer.cpp
blob4bb9de939ab1771c36657706a4dbf1e9c070956b
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2002 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 //---------------------------------------------------------------------------
40 // Includes
41 //---------------------------------------------------------------------------
42
43 #include <stdlib.h>
44 #include <stdio.h>
45
46 #include "OSGConfig.h"
47
48 #include "OSGBinarySwapComposer.h"
49
50 OSG_USING_NAMESPACE
51
52
53 /*! \class OSG::BinarySwapComposer
54
55 This composer implements the binary swap composition.
56 */
57
58 void BinarySwapComposer::initMethod(InitPhase ePhase)
59 {
60 Inherited::initMethod(ePhase);
61 }
62
63
64 /*----------------------- constructors & destructors ----------------------*/
65
66 BinarySwapComposer::BinarySwapComposer(void) :
67 Inherited ( ),
68 _writer (NULL ),
69 _barrier (NULL ),
70 _stopWriter (false ),
71 _swapWith (0 ),
72 _swapConnection(NULL ),
73 _tilesX (0 ),
74 _tilesY (0 ),
75 _tileBufferSize(0 ),
76 _tile ( ),
77 _readTile ( ),
78 _writeLeft (0 ),
79 _writeRight (0 ),
80 _writeBottom (0 ),
81 _writeTop (0 ),
82 _usableServers (0 ),
83 _statistics ( ),
84 _intDepthMax (0xffffffff),
85 _shortDepthMax (0xffff )
86 {
87 }
88
89 BinarySwapComposer::BinarySwapComposer(const BinarySwapComposer &source) :
90 Inherited (source ),
91 _writer (NULL ),
92 _barrier (NULL ),
93 _stopWriter (false ),
94 _swapWith (0 ),
95 _swapConnection(NULL ),
96 _tilesX (0 ),
97 _tilesY (0 ),
98 _tileBufferSize(0 ),
99 _tile ( ),
100 _readTile ( ),
101 _writeLeft (0 ),
102 _writeRight (0 ),
103 _writeBottom (0 ),
104 _writeTop (0 ),
105 _usableServers (0 ),
106 _statistics ( ),
107 _intDepthMax (0xffffffff),
108 _shortDepthMax (0xffff )
109 {
110 }
111
112 BinarySwapComposer::~BinarySwapComposer(void)
113 {
114 }
115
116 /*----------------------------- class specific ----------------------------*/
117
118 void BinarySwapComposer::changed(ConstFieldMaskArg whichField,
119 UInt32 origin,
120 BitVector details)
121 {
122 Inherited::changed(whichField, origin, details);
123 }
124
125 void BinarySwapComposer::dump( UInt32 ,
126 const BitVector ) const
127 {
128 SLOG << "Dump BinarySwapComposer NI" << std::endl;
129 }
130
131 /*----------------------------- features ---------------------------------*/
132
133 /*! Currently it is not possible to do rendering on the client
134 */
135 bool BinarySwapComposer::clientRendering()
136 {
137 return false;
138 }
139
140 /*----------------------------- composition -------------------------------*/
141
142 void BinarySwapComposer::open()
143 {
144 // determine usable servers
145 if(osgIsPower2(serverCount()))
146 _usableServers = serverCount();
147 else
148 _usableServers = osgNextPower2(serverCount()) / 2;
149
150 // _usableServers = 1;
151
152 // create server cross connection
153 _clusterWindow->getNetwork()->connectAllPointToPoint(clusterId(),
154 "StreamSock");
155 // do not buffer any data
156 for(UInt32 i=0 ; i <= serverCount() ; ++i)
157 clusterWindow()->getNetwork()->getConnection(i)->forceDirectIO();
158
159 /*
160 // create barrier
161 _barrier = Barrier::get(NULL);
162 // create writer thread
163 _writer = BaseThread::get(NULL);
164 */
165
166 // read whole buffer
167 if(!_isClient && clusterId() < _usableServers)
168 {
169 // create barrier
170 _barrier = Barrier::get(NULL, false);
171 // create writer thread
172 _writer = BaseThread::get(NULL, false);
173 // start writer thread
174 _writer->runFunction( writeProc, this );
175 }
176 else
177 {
178 _writer = NULL;
179 }
180 }
181
182 void BinarySwapComposer::composeViewport(Viewport *port)
183 {
184 // setup viewport
185 GLint
186 pl=port->calcPixelLeft(),
187 pr=port->calcPixelRight(),
188 pb=port->calcPixelBottom(),
189 pt=port->calcPixelTop();
190 GLint pw=pr-pl+1,ph=pt-pb+1;
191 bool full = port->calcIsFullWindow();
192 glViewport(pl, pb, pw, ph);
193 glScissor(pl, pb, pw, ph);
194 if(! full)
195 glEnable(GL_SCISSOR_TEST);
196
197 GLboolean depth = glIsEnabled(GL_DEPTH_TEST);
198 GLboolean blend = glIsEnabled(GL_BLEND);
199
200 glDisable(GL_DEPTH_TEST);
201 glPushMatrix();
202 glLoadIdentity();
203 glMatrixMode(GL_PROJECTION);
204 glPushMatrix();
205 glLoadIdentity();
206 glOrtho(0, port->calcPixelWidth(),
207 0, port->calcPixelHeight(),-1,1);
208
209 // printf("max %x,%x\n",_intDepthMax,_shortDepthMax);
210
211 if(getAlpha())
212 {
213 glEnable(GL_BLEND);
214 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
215 }
216 _tilesX = port->calcPixelWidth() / getTileSize() + 1;
217 _tilesY = port->calcPixelHeight() / getTileSize() + 1;
218
219 _tileBufferSize = getTileSize()*getTileSize()*8+sizeof(TileBuffer);
220 _readTile.resize(_tileBufferSize);
221
222 _statistics.bytesIn = 0;
223 _statistics.bytesOut = 0;
224
225 if(isClient())
226 {
227 if(getShort())
228 {
229 UInt16 colorDummy;
230 UInt32 depthDummy;
231 recvFromServers(depthDummy,colorDummy,
232 GL_RGB,
233 GL_UNSIGNED_SHORT_5_6_5,
234 port);
235 }
236 else
237 {
238 if(getAlpha())
239 {
240 UInt32 colorDummy;
241 UInt32 depthDummy;
242 recvFromServers(depthDummy,colorDummy,
243 GL_RGBA,
244 GL_UNSIGNED_BYTE,
245 port);
246 }
247 else
248 {
249 RGBValue colorDummy;
250 UInt32 depthDummy;
251 recvFromServers(depthDummy,colorDummy,
252 GL_RGB,
253 GL_UNSIGNED_BYTE,
254 port);
255 }
256 }
257 if(getStatistics())
258 {
259 UInt32 maxIn = _statistics.bytesIn;
260 UInt32 maxOut = _statistics.bytesOut;
261 UInt32 maxIO = maxIn + maxOut;
262 UInt32 sumOut = _statistics.bytesOut;
263 UInt32 missing = _usableServers;
264 double composeTime = 1e32;
265
266 Connection *server;
267 Statistics statistics;
268 for(UInt32 i=0 ; i<_usableServers ;++i)
269 {
270 server = clusterWindow()->getNetwork()->getConnection(i);
271 server->selectChannel();
272 server->get(&statistics,sizeof(Statistics));
273 sumOut += statistics.bytesOut;
274 if(statistics.composeTime < composeTime)
275 composeTime = statistics.composeTime;
276 if(statistics.bytesOut > maxOut)
277 maxOut = statistics.bytesOut;
278 if(statistics.bytesIn > maxIn)
279 maxIn = statistics.bytesIn;
280 if(statistics.bytesIn + statistics.bytesOut > maxIO)
281 maxIO = statistics.bytesIn + statistics.bytesOut;
282 missing--;
283 }
284 printf("compose Time : %1.5lf\n",composeTime);
285 printf("Transfered bytes : %10d\n",sumOut);
286 printf("Max out : %10d\n",maxOut);
287 printf("Max in : %10d\n",maxIn);
288 printf("Max io : %10d\n",maxIO);
289 }
290 }
291 else
292 {
293 if(clusterId() < _usableServers)
294 {
295 _statistics.composeTime = -getSystemTime();
296 _tile.resize(_tileBufferSize * _tilesX * _tilesY);
297 if(getShort())
298 {
299 UInt16 colorDummy;
300 UInt32 depthDummy=_shortDepthMax;
301 // UInt32 depthDummy=_intDepthMax;
302 startReader(depthDummy,colorDummy,
303 // GL_UNSIGNED_SHORT,
304 GL_UNSIGNED_INT,
305 GL_RGB,
306 GL_UNSIGNED_SHORT_5_6_5,
307 port);
308 }
309 else
310 {
311 if(getAlpha())
312 {
313 UInt32 colorDummy;
314 UInt32 depthDummy=_intDepthMax;
315 startReader(depthDummy,colorDummy,
316 GL_UNSIGNED_INT,
317 GL_RGBA,
318 GL_UNSIGNED_BYTE,
319 port);
320 }
321 else
322 {
323 RGBValue colorDummy;
324 UInt32 depthDummy=_intDepthMax;
325 startReader(depthDummy,colorDummy,
326 GL_UNSIGNED_INT,
327 GL_RGB,
328 GL_UNSIGNED_BYTE,
329 port);
330 }
331 }
332 _statistics.composeTime += getSystemTime();
333 if(getStatistics())
334 {
335 Connection *client = clusterWindow()->getNetwork()->getConnection(serverCount());
336 client->put(&_statistics,sizeof(Statistics));
337 client->flush();
338 }
339 }
340 /*
341 // max depth value !! find a better way
342 glClear(GL_DEPTH_BUFFER_BIT);
343 glReadPixels(0, 0, 1, 1,
344 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
345 &_intDepthMax);
346 glReadPixels(0, 0, 1, 1,
347 GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
348 &_shortDepthMax);
349 */
350 }
351
352 glPopMatrix();
353 glMatrixMode(GL_MODELVIEW);
354 glPopMatrix();
355 glEnable(GL_DEPTH_TEST);
356
357 // reset state
358 if(depth && !glIsEnabled(GL_DEPTH_TEST))
359 glEnable(GL_DEPTH_TEST);
360 if(!blend && glIsEnabled(GL_BLEND))
361 glDisable(GL_BLEND);
362 }
363
364 void BinarySwapComposer::close(void)
365 {
366 if(!isClient() && _writer)
367 {
368 _stopWriter = true;
369 _barrier->enter(2);
370 BaseThread::join(_writer);
371 _writer = NULL;
372 _barrier = NULL;
373 }
374 }
375
376 /*----------------------------- features ---------------------------------*/
377
378 /*! it is not possible to do rendering on the client with binary swap
379 currently ;-)
380 */
381 bool BinarySwapComposer::getClientRendering()
382 {
383 return false;
384 }
385
386 /*! use only 2^n servers
387 */
388 UInt32 BinarySwapComposer::getUsableServers()
389 {
390 return _usableServers;
391 }
392
393 /*----------------------------- helper ------------------------------------*/
394
395 BinarySwapComposer::TileBuffer *BinarySwapComposer::getTileBuffer(UInt32 x,UInt32 y)
396 {
397 return reinterpret_cast<TileBuffer*>(
398 &_tile[(y*_tilesX + x)*_tileBufferSize]);
399 }
400
401 BinarySwapComposer::TileBuffer *BinarySwapComposer::getTileReadBuffer(void)
402 {
403 return reinterpret_cast<TileBuffer*>(&_readTile[0]);
404 }
405
406 /*----------------------------- thread proc -------------------------------*/
407
408
409 void BinarySwapComposer::writeProc(void *arg)
410 {
411 BinarySwapComposer *the=static_cast<BinarySwapComposer*>(arg);
412 for(;;)
413 {
414 the->_barrier->enter(2);
415 if(the->_stopWriter)
416 break;
417 if(the->getShort())
418 {
419 UInt16 colorDummy;
420 UInt32 depthDummy;
421 the->writeCombine(depthDummy,colorDummy);
422 }
423 else
424 {
425 if(the->getAlpha())
426 {
427 RGBValue colorDummy;
428 UInt32 depthDummy;
429 the->writeCombine(depthDummy,colorDummy);
430 }
431 else
432 {
433 UInt32 colorDummy;
434 UInt32 depthDummy;
435 the->writeCombine(depthDummy,colorDummy);
436 }
437 }
438 }
439 }
440