void ServerManager::ajustServers()
{
if (isRunning()) {
tSystemDebug("serverCount: %d", serverCount());
if (serverCount() < maxServers && serverCount() < minServers) {
startServer();
} else {
if (managerState != Running) {
tSystemInfo("TreeFrog application servers started up.");
managerState = Running;
}
}
}
}
UInt32 PipelineComposer::compressTransInfo(std::vector<TransInfo> &transInfo)
{
TransInfo *src = &transInfo[0];
TransInfo *srcEnd = src + _composeTilesX*_composeTilesY*serverCount();
TransInfo *dst = &transInfo[0];
TransInfo *empty = NULL;
while(src != srcEnd) {
if(src->empty) {
if(!empty) {
empty = dst++;
empty->sendTo=1;
empty->empty=true;
} else {
empty->sendTo++;
if(empty->sendTo == 0) {
empty->sendTo--;
empty = dst++;
empty->sendTo=1;
empty->empty=true;
}
}
} else {
empty = NULL;
*dst=*src;
dst++;
}
src++;
}
// printf("Compress %f\n",(dst - &transInfo[0])*100.0/transInfo.size());
return dst - &transInfo[0];
}
void PipelineComposer::open()
{
setShort(true);
// create server cross connection
_clusterWindow->getNetwork()->connectAllGroupToPoint(clusterId(),
"StreamSock");
// do not buffer any data
for(UInt32 i=0 ; i <= serverCount() ; ++i)
clusterWindow()->getNetwork()->getConnection(i)->forceDirectIO();
if(!_isClient)
{
// create barrier
_lock = Lock::get("PipelineComposer");
// create barrier
_barrier = Barrier::get("PipelineComposer");
_frameEndBarrier = Barrier::get("PipelineComposerFrameEnd");
// create writer thread
_writer = BaseThread::get("PipelineComposer");
// start writer thread
_writer->runFunction( writeProc, this );
}
if(!_isClient && getPipelined())
{
_composeBarrier = Barrier::get("PipelineComposerCompose");
// _composer = BaseThread::get("PipelineComposerCompose");
_composer = dynamic_cast<Thread *>(ThreadManager::the()->getThread(NULL));
_composer->runFunction( composeProc,0, this );
}
#ifdef USE_NV_OCCLUSION
glGenOcclusionQueriesNV(1, &_occlusionQuery);
#endif
}
void ParallelComposer::open(void)
{
#ifdef OSG_WITH_PARALLEL
if(getPcLibPath() != "")
{
pcSysInitialize(getPcLibPath().c_str(), 123458);
}
else
{
char *pc = getenv("PCLIB_PATH");
if(pc!= NULL)
pcSysInitialize(pc, 123458);
else
pcSysInitialize(".", 123458);
}
// Initialize buffers
_bufColor = NULL;
_bufDepth = NULL;
_bufRet = NULL;
_createContext = true;
// determine usable servers
_usableServers = serverCount();
// create server cross connection
_clusterWindow->getNetwork()->connectAllPointToPoint(clusterId(),
"StreamSock");
// do not buffer any data
for(UInt32 i=0 ; i <= serverCount() ; ++i)
clusterWindow()->getNetwork()->getConnection(i)->forceDirectIO();
// populate server list from inherited cluster window
osgGetHostname(_serviceAddr, sizeof(_serviceAddr));
_serverList = new char*[_usableServers+2];
_serverList[0] = _serviceAddr;
int i = 1;
for(; i<_usableServers+1; i++)
{
_serverList[i] = (char*)clusterWindow()->getServers(i-1).c_str();
}
_serverList[i]= NULL;
#endif
}
void PipelineComposer::uncompressTransInfo(std::vector<TransInfo> &transInfo,UInt32 infoCount)
{
transInfo.resize(_composeTilesX*_composeTilesY*serverCount());
TransInfo *src = &transInfo[infoCount-1];
TransInfo *srcEnd = &transInfo[0] - 1;
TransInfo *dst = &transInfo[_composeTilesX*_composeTilesY*serverCount()-1];
while(src != srcEnd) {
if(src->empty) {
while(src->sendTo) {
dst->empty = true;
dst--;
src->sendTo--;
}
} else {
*dst=*src;
dst--;
}
src--;
}
}
void BinarySwapComposer::open()
{
// determine usable servers
if(osgispower2(serverCount()))
_usableServers = serverCount();
else
_usableServers = osgnextpower2(serverCount()) / 2;
// _usableServers = 1;
// create server cross connection
_clusterWindow->getNetwork()->connectAllPointToPoint(clusterId(),
"StreamSock");
// do not buffer any data
for(UInt32 i=0 ; i <= serverCount() ; ++i)
clusterWindow()->getNetwork()->getConnection(i)->forceDirectIO();
/*
// create barrier
_barrier = Barrier::get(NULL);
// create writer thread
_writer = BaseThread::get(NULL);
*/
// read whole buffer
if(!_isClient && clusterId() < _usableServers)
{
// create barrier
_barrier = Barrier::get(NULL);
// create writer thread
_writer = BaseThread::get(NULL);
// start writer thread
_writer->runFunction( writeProc, this );
}
else
{
_writer = NULL;
}
}
void BinarySwapComposer::composeViewport(ViewportPtr port)
{
// setup viewport
GLint
pl=port->getPixelLeft(),
pr=port->getPixelRight(),
pb=port->getPixelBottom(),
pt=port->getPixelTop();
GLint pw=pr-pl+1,ph=pt-pb+1;
bool full = port->isFullWindow();
glViewport(pl, pb, pw, ph);
glScissor(pl, pb, pw, ph);
if(! full)
glEnable(GL_SCISSOR_TEST);
GLboolean depth = glIsEnabled(GL_DEPTH_TEST);
GLboolean blend = glIsEnabled(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, port->getPixelWidth(),
0, port->getPixelHeight(),-1,1);
// printf("max %x,%x\n",_intDepthMax,_shortDepthMax);
if(getAlpha())
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
_tilesX = port->getPixelWidth() / getTileSize() + 1;
_tilesY = port->getPixelHeight() / getTileSize() + 1;
_tileBufferSize = getTileSize()*getTileSize()*8+sizeof(TileBuffer);
_readTile.resize(_tileBufferSize);
_statistics.bytesIn = 0;
_statistics.bytesOut = 0;
if(isClient())
{
if(getShort())
{
UInt16 colorDummy;
UInt32 depthDummy;
recvFromServers(depthDummy,colorDummy,
GL_RGB,
GL_UNSIGNED_SHORT_5_6_5,
port);
}
else
{
if(getAlpha())
{
UInt32 colorDummy;
UInt32 depthDummy;
recvFromServers(depthDummy,colorDummy,
GL_RGBA,
GL_UNSIGNED_BYTE,
port);
}
else
{
RGBValue colorDummy;
UInt32 depthDummy;
recvFromServers(depthDummy,colorDummy,
GL_RGB,
GL_UNSIGNED_BYTE,
port);
}
}
if(getStatistics())
{
UInt32 maxIn = _statistics.bytesIn;
UInt32 maxOut = _statistics.bytesOut;
UInt32 maxIO = maxIn + maxOut;
UInt32 sumOut = _statistics.bytesOut;
UInt32 missing = _usableServers;
double composeTime = 1e32;
Connection *server;
Statistics statistics;
for(UInt32 i=0 ; i<_usableServers ;++i)
{
server = clusterWindow()->getNetwork()->getConnection(i);
server->selectChannel();
server->get(&statistics,sizeof(Statistics));
sumOut += statistics.bytesOut;
if(statistics.composeTime < composeTime)
composeTime = statistics.composeTime;
if(statistics.bytesOut > maxOut)
maxOut = statistics.bytesOut;
if(statistics.bytesIn > maxIn)
maxIn = statistics.bytesIn;
if(statistics.bytesIn + statistics.bytesOut > maxIO)
maxIO = statistics.bytesIn + statistics.bytesOut;
missing--;
}
printf("compose Time : %1.5lf\n",composeTime);
printf("Transfered bytes : %10d\n",sumOut);
printf("Max out : %10d\n",maxOut);
printf("Max in : %10d\n",maxIn);
printf("Max io : %10d\n",maxIO);
}
}
else
{
if(clusterId() < _usableServers)
{
_statistics.composeTime = -getSystemTime();
_tile.resize(_tileBufferSize * _tilesX * _tilesY);
if(getShort())
{
UInt16 colorDummy;
UInt32 depthDummy=_shortDepthMax;
// UInt32 depthDummy=_intDepthMax;
startReader(depthDummy,colorDummy,
// GL_UNSIGNED_SHORT,
GL_UNSIGNED_INT,
GL_RGB,
GL_UNSIGNED_SHORT_5_6_5,
port);
}
else
{
if(getAlpha())
{
UInt32 colorDummy;
UInt32 depthDummy=_intDepthMax;
startReader(depthDummy,colorDummy,
GL_UNSIGNED_INT,
GL_RGBA,
GL_UNSIGNED_BYTE,
port);
}
else
{
RGBValue colorDummy;
UInt32 depthDummy=_intDepthMax;
startReader(depthDummy,colorDummy,
GL_UNSIGNED_INT,
GL_RGB,
GL_UNSIGNED_BYTE,
port);
}
}
_statistics.composeTime += getSystemTime();
if(getStatistics())
{
Connection *client = clusterWindow()->getNetwork()->getConnection(serverCount());
client->put(&_statistics,sizeof(Statistics));
client->flush();
}
}
/*
// max depth value !! find a better way
glClear(GL_DEPTH_BUFFER_BIT);
glReadPixels(0, 0, 1, 1,
GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
&_intDepthMax);
glReadPixels(0, 0, 1, 1,
GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT,
&_shortDepthMax);
*/
}
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
// reset state
if(depth && !glIsEnabled(GL_DEPTH_TEST))
glEnable(GL_DEPTH_TEST);
if(!blend && glIsEnabled(GL_BLEND))
glDisable(GL_BLEND);
}
// --------------------------------------------------------------------------
// CMSStoreServersSetting::CreateSelectionItemListL
// Creates selection item list
// --------------------------------------------------------------------------
//
void CMSStoreServersSetting::CreateSelectionItemListL()
{
if ( iItemArray )
{
iItemArray->ResetAndDestroy();
delete iItemArray;
iItemArray = NULL;
}
iItemArray =
new ( ELeave ) CSelectionItemList( KItemArrayGranularity );
TBuf8<KMaxFileName> itemText;
TInt serverCount(0);
if ( iServers )
{
serverCount = iServers->Count();
}
// Cycle trough all servers
for ( TInt idx = 0; idx < serverCount; idx++ )
{
// get server
CCmMediaServerFull* server = (*iServers)[idx];
// show only copy capable devices
if ( server->StoreUsage() )
{
HBufC* devName =
UpnpString::ToUnicodeL( server->MediaServerName() );
CleanupStack::PushL( devName );
CSelectableItem* item = new ( ELeave ) CSelectableItem(
*devName, EFalse);
CleanupStack::PushL( item );
// item must be constructed
item->ConstructL();
// count of servers set to rule
TInt ruleServerCount = iRule->MediaServerCount();
// Cycle trough all servers
for (TInt index = 0; index < ruleServerCount; index++ )
{
const TDesC8& ruleServerUDN = iRule->MediaServerL( index );
if (ruleServerUDN == server->MediaServer()) // compare UDNs
{
// found - break this loop
index = ruleServerCount;
// found - mark selected
item->SetSelectionStatus( ETrue );
iSelectedItemCount++;
}
}
// append item to list
iItemArray->AppendL(item);
CleanupStack::Pop( item );
CleanupStack::PopAndDestroy( devName );
}
else // we don't need this kind of servers anymore so remove it
{
delete server;
iServers->Remove( idx );
idx--; // remove transfers next item to current index
serverCount--; // servers on the list were reduced
}
}
}
void PipelineComposer::composeViewport(Viewport *port)
{
// setup viewport
GLint
pl=port->calcPixelLeft(),
pr=port->calcPixelRight(),
pb=port->calcPixelBottom(),
pt=port->calcPixelTop();
GLint pw=pr-pl+1,ph=pt-pb+1;
bool full = port->calcIsFullWindow();
glViewport(pl, pb, pw, ph);
glScissor(pl, pb, pw, ph);
if(! full)
glEnable(GL_SCISSOR_TEST);
GLboolean depth = glIsEnabled(GL_DEPTH_TEST);
GLboolean blend = glIsEnabled(GL_BLEND);
// glDisable(GL_DEPTH_TEST);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, port->calcPixelWidth(),
0, port->calcPixelHeight(),-1,1);
if(getAlpha())
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
// only one buffer for the client
if(isClient())
_composeTilePtr = _readTilePtr;
_readTilesX = (port->calcPixelWidth() - 1) / getTileSize() + 1;
_readTilesY = (port->calcPixelHeight() - 1) / getTileSize() + 1;
_tileBufferSize = getTileSize()*getTileSize()*8+sizeof(TileBuffer);
_workingTile.resize(_tileBufferSize);
// resize
_readTilePtr->resize(_tileBufferSize * _readTilesX * _readTilesY);
if(isClient())
{
while(_groupInfo.size() < serverCount())
{
_groupInfoPool.push_back(GroupInfo());
_groupInfo.push_back(&(*_groupInfoPool.rbegin()));
}
_groupInfo.resize(serverCount());
}
_statistics.bytesIn = 0;
_statistics.bytesOut = 0;
_statistics.occluded = 0;
_statistics.noDepth = 0;
_statistics.noGeo = 0;
_statistics.clipped = 0;
if(!getPipelined())
{
_composeTilesX = _readTilesX;
_composeTilesY = _readTilesY;
}
if(getShort())
{
UInt16 colorDummy;
// UInt16 depthDummy;
UInt32 depthDummy;
// _depthType = GL_UNSIGNED_SHORT;
_depthType = GL_UNSIGNED_INT;
_colorFormat = GL_RGB;
_colorType = GL_UNSIGNED_SHORT_5_6_5;
readBuffer(depthDummy,colorDummy,port);
if(!getPipelined() || isClient())
composeBuffer(depthDummy,colorDummy);
}
else
{
if(getAlpha())
{
UInt32 colorDummy;
UInt32 depthDummy;
_depthType = GL_UNSIGNED_INT;
_colorFormat = GL_RGBA;
_colorType = GL_UNSIGNED_BYTE;
readBuffer(depthDummy,colorDummy,port);
if(!getPipelined() || isClient())
composeBuffer(depthDummy,colorDummy);
}
else
{
RGBValue colorDummy;
UInt32 depthDummy;
_depthType = GL_UNSIGNED_INT;
_colorFormat = GL_RGB;
_colorType = GL_UNSIGNED_BYTE;
readBuffer(depthDummy,colorDummy,port);
if(!getPipelined() || isClient())
composeBuffer(depthDummy,colorDummy);
}
}
if(getStatistics())
{
if(isClient())
{
double pixelReadTime = 0;
double sortTime = 0;
UInt32 maxIn = _statistics.bytesIn;
UInt32 maxOut = _statistics.bytesOut;
UInt32 maxIO = maxIn + maxOut;
UInt32 sumOut = _statistics.bytesOut;
UInt32 clipped = 0;
Connection::Channel channel;
GroupConnection *server;
Statistics statistics;
server = clusterWindow()->getNetwork()->getMainGroupConnection();
for(UInt32 i=0 ; i<serverCount() ;++i)
{
channel = server->selectChannel();
server->subSelection(channel);
server->get(&statistics,sizeof(Statistics));
sumOut += statistics.bytesOut;
if(statistics.pixelReadTime > pixelReadTime) {
pixelReadTime = statistics.pixelReadTime;
sortTime = statistics.sortTime;
}
if(statistics.bytesOut > maxOut)
maxOut = statistics.bytesOut;
if(statistics.bytesIn > maxIn)
maxIn = statistics.bytesIn;
if(statistics.bytesIn + statistics.bytesOut > maxIO)
maxIO = statistics.bytesIn + statistics.bytesOut;
clipped += statistics.clipped;
}
server->resetSelection();
printf("pixel read time : %1.5lf\n",pixelReadTime);
printf("sort Time : %1.5lf\n",sortTime);
printf("compose Time : %1.5lf\n",_statistics.composeTime);
printf("Transfered bytes : %10d\n",sumOut);
printf("Max out : %10d\n",maxOut);
printf("Max in : %10d\n",maxIn);
printf("Max io : %10d\n",maxIO);
printf("occluded : %10d\n",_statistics.occluded);
printf("Layerd : %10d\n",_statistics.noDepth);
printf("Empty : %10d\n",_statistics.noGeo-clipped);
printf("Clipped : %10d\n",clipped);
printf("DepthAndColor : %10d\n",serverCount()*_composeTilesX*_composeTilesY-
_statistics.occluded-
_statistics.noDepth-
_statistics.noGeo);
}
else
{
Connection *client = clusterWindow()->getNetwork()->getMainConnection();
client->put(&_statistics,sizeof(Statistics));
client->flush();
}
}
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
// reset state
if(depth && !glIsEnabled(GL_DEPTH_TEST))
glEnable(GL_DEPTH_TEST);
if(!blend && glIsEnabled(GL_BLEND))
glDisable(GL_BLEND);
}
