Esempio n. 1
0
void EventHandler::_dispatch()
{
    Display* display = _window->getXDisplay();
    LBASSERT( display );
    if( !display )
        return;

    while( XPending( display ))
    {
        WindowEvent event;
        XEvent& xEvent = event.xEvent;

        XNextEvent( display, &xEvent );
        event.time = _window->getConfig()->getTime();

        for( EventHandlers::const_iterator i = _eventHandlers->begin();
             i != _eventHandlers->end(); ++i )
        {
            EventHandler* handler = *i;
            handler->_processEvent( event );
        }
    }
}
Esempio n. 2
0
bool Window::configInitGL( const eq::uint128_t& initID )
{
    if( !eq::Window::configInitGL( initID ))
        return false;

    glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, 1 );
    glEnable( GL_CULL_FACE ); // OPT - produces sparser images in DB mode
    glCullFace( GL_BACK );

    LBASSERT( !_state );
    _state = new VertexBufferState( getObjectManager( ));

    const Config*   config   = static_cast< const Config* >( getConfig( ));
    const InitData& initData = config->getInitData();

    if( initData.showLogo( ))
        _loadLogo();

    if( initData.useGLSL() )
        _loadShaders();

    return true;
}
Esempio n. 3
0
GPUCacheManager::GPUCacheManager( constGPUCacheIndexSPtr cacheIndex, RAMPoolSPtr ramPool, const byte bytesNum,
                                  Window* wnd )
    :_iteration( 1 )
    ,_cacheIndex( cacheIndex )
    ,_gpuLoader(  new GPUAsyncLoader( wnd ))
    ,_nodeIdBeingLoaded( 0 )
    ,_cachePosBeingLoaded( 0 )
{
    LBASSERT( _cacheIndex );

    _gpuLoader->start();

    const GPULoadRespond respond = _gpuLoader->readLoadRespond();
    if( respond.status.value != GPULoadStatus::INITIALIZED )
        LBERROR << "Incorrect respond from GPU Async Loader" << std::endl;

    _gpuLoader->postCommand( GPUCommand::PAUSE );
    _gpuLoader->initialize( ramPool, cacheIndex, bytesNum );
    _resize();
    LBWARN << " new GPUCacheManager, updating GPU Cache" << std::endl;
    _gpuLoader->postCommand( GPUCommand::UPDATE );
    _gpuLoader->postCommand( GPUCommand::RESUME );
}
Esempio n. 4
0
uint128_t FullMasterCM::commit( const uint32_t incarnation )
{
    LBASSERT( _version != VERSION_NONE );

    if( !_object->isDirty( ))
    {
        Mutex mutex( _slaves );
        _updateCommitCount( incarnation );
        _obsolete();
        return _version;
    }

    _maxVersion.waitGE( _version.low() + 1 );
    Mutex mutex( _slaves );
#if 0
    LBLOG( LOG_OBJECTS ) << "commit v" << _version << " " << command
                         << std::endl;
#endif
    _updateCommitCount( incarnation );
    _commit();
    _obsolete();
    return _version;
}
Esempio n. 5
0
//===========================================================================
// ICommand handling methods
//===========================================================================
void Server::handleCommands()
{
    _running = true;
    while( _running ) // set to false in _cmdShutdown()
    {
        const co::ICommands& commands = _mainThreadQueue.popAll();
        LBASSERT( !commands.empty( ));

        for( co::ICommandsCIter i = commands.begin(); i != commands.end(); ++i )
        {
            // We want to avoid a non-const copy of commands, hence the cast...
            co::ICommand& command = const_cast< co::ICommand& >( *i );

            if( !command( ))
            {
                LBABORT( "Error handling " << command );
            }
            if( !_running )
                break;
        }
    }
    _mainThreadQueue.flush();
}
Esempio n. 6
0
bool Window::configInitSystemWindow( const uint128_t& )
{
    const Pipe* pipe = getPipe();
    WindowSettings settings = getSettings();
    const SystemWindow* sysWindow = _sharedContextWindow ?
                                    _sharedContextWindow->getSystemWindow() : 0;
    settings.setSharedContextWindow( sysWindow );
    SystemWindow* systemWindow =
        pipe->getWindowSystem().createWindow( this, settings );

    LBASSERT( systemWindow );
    if( !systemWindow->configInit( ))
    {
        LBWARN << "System window initialization failed" << std::endl;
        systemWindow->configExit();
        delete systemWindow;
        return false;
    }

    setPixelViewport( systemWindow->getPixelViewport( ));
    setSystemWindow( systemWindow );
    return true;
}
Esempio n. 7
0
bool GLSLShaders::loadShaders(const std::string &vShader,
                              const std::string &fShader,
                              const GLEWContext *glewContext)
{
    if (_shadersLoaded)
        return true;

    LBASSERT(glewContext);
    _glewContext = glewContext;

    _program = glCreateProgramObjectARB();

    GLhandleARB vertexShader = _loadShader(vShader, GL_VERTEX_SHADER_ARB);
    if (!vertexShader)
        return _cleanupOnError();

    glAttachObjectARB(_program, vertexShader);

    GLhandleARB fragmentShader = _loadShader(fShader, GL_FRAGMENT_SHADER_ARB);
    if (!fragmentShader)
        return _cleanupOnError(vertexShader);

    glAttachObjectARB(_program, fragmentShader);

    glLinkProgramARB(_program);

    GLint status;
    glGetObjectParameterivARB(_program, GL_OBJECT_LINK_STATUS_ARB, &status);
    if (status != GL_FALSE)
    {
        _shadersLoaded = true;
        return true;
    }

    _printLog(_program, "Linking");
    return _cleanupOnError(vertexShader, fragmentShader);
}
Esempio n. 8
0
    bool setup( lunchbox::PluginRegistry& from, const uint32_t name,
                const GLEWContext* gl )
    {
        if( name == info.name )
        {
            LBASSERT( isGood() && instance );
            return true;
        }

        clear();

        if( name <= EQ_COMPRESSOR_NONE )
        {
            LBASSERT( isGood() && instance );
            return true;
        }

        plugin = from.findPlugin( name );
        LBASSERT( plugin );
        if( !plugin )
        {
            LBWARN << "Plugin for downloader 0x" << std::hex << name << std::dec
                   << " not found" << std::endl;
            return false;
        }

        if( !gl )
            LBWARN << "Can't verify plugin compatibility, no GLEWContext given"
                   << std::endl;
        else if( !plugin->isCompatible( name, gl ))
        {
            LBWARN << "Plugin for downloader 0x" << std::hex << name << std::dec
                   << " not compatible with OpenGL implementation" << std::endl;
            return false;
        }

        instance = plugin->newDecompressor( name );
        info = plugin->findInfo( name );
        LBASSERT( isGood( ));
        LBASSERT( instance );
        LBASSERT( info.name == name );
        LBLOG( LOG_PLUGIN ) << "Instantiated downloader " << info << std::endl;
        return instance;
    }
Esempio n. 9
0
bool Client::initLocal( const int argc, char** argv )
{
    bool isClient = false;
    std::string clientOpts;

    if( _impl->name.empty() && argc > 0 && argv )
    {
        const boost::filesystem::path prog = argv[0];
        setName( prog.stem().string( ));
    }

    for( int i=1; i<argc; ++i )
    {
        if( std::string( "--eq-client" ) == argv[i] )
        {
            isClient = true;
            if( i < argc-1 && argv[i+1][0] != '-' ) // server-started client
            {
                clientOpts = argv[++i];

                if( !deserialize( clientOpts ))
                    LBWARN << "Failed to parse client listen port parameters"
                           << std::endl;
                LBASSERT( !clientOpts.empty( ));
            }
        }
        else if( _isParameterOption( "--eq-layout", argc, argv, i ))
            _impl->activeLayouts.push_back( argv[++i] );
        else if( _isParameterOption( "--eq-gpufilter" , argc, argv, i ))
            _impl->gpuFilter = argv[ ++i ];
        else if( _isParameterOption( "--eq-modelunit", argc, argv, i ))
        {
            std::istringstream unitString( argv[++i] );
            unitString >> _impl->modelUnit;
        }
    }
Esempio n. 10
0
bool MasterConfig::init()
{
    LBASSERT( !_objects );
    _objects = new ObjectMap( *this, *getApplication( ));

    co::Object* initData = getInitData();
    if( initData )
        LBCHECK( _objects->register_( initData, OBJECTTYPE_INITDATA ));
    _objects->setInitData( initData );

    LBCHECK( registerObject( _objects ));

    if( !eq::Config::init( _objects->getID( )))
    {
        LBWARN << "Error during initialization: " << getError() << std::endl;
        exit();
        return false;
    }
    if( getError( ))
        LBWARN << "Error during initialization: " << getError() << std::endl;

    _redraw = true;
    return true;
}
Esempio n. 11
0
void DataIStream::_read( void* data, uint64_t size )
{
    if( !_checkBuffer( ))
    {
        LBUNREACHABLE;
        LBERROR << "No more input data" << std::endl;
        return;
    }

    LBASSERT( _impl->input );
    if( size > _impl->inputSize - _impl->position )
    {
        LBERROR << "Not enough data in input buffer: need " << size
                << " bytes, " << _impl->inputSize - _impl->position << " left "
                << std::endl;
        LBUNREACHABLE;
        // TODO: Allow reads which are asymmetric to writes by reading from
        // multiple blocks here?
        return;
    }

    memcpy( data, _impl->input + _impl->position, size );
    _impl->position += size;
}
Esempio n. 12
0
bool DSO::open( const std::string& fileName )
{
    if( _impl->dso )
    {
        LBWARN << "DSO already open, close it first" << std::endl;
        return false;
    }

    if( fileName.empty( ))
    {
#ifdef _WIN32 //_MSC_VER
        _impl->dso = GetModuleHandle( 0 );
        LBASSERT( _impl->dso );
#else
        _impl->dso = RTLD_DEFAULT;
#endif
    }
    else
    {
#ifdef _WIN32 //_MSC_VER
        _impl->dso = LoadLibrary( fileName.c_str() );
#elif defined( RTLD_LOCAL )
        _impl->dso = dlopen( fileName.c_str(), RTLD_LAZY | RTLD_LOCAL );
#else
        _impl->dso = dlopen( fileName.c_str(), RTLD_LAZY );
#endif
        if( !_impl->dso )
        {
            LBINFO << "Can't open library " << fileName << ": " << LB_DL_ERROR
                   << std::endl;
            return false;
        }
    }

    return true;
}
Esempio n. 13
0
bool Connection::send( const Connections& connections, Packet& packet,
                       const void* const* items, const uint64_t* sizes, 
                       const size_t nItems )
{
    if( connections.empty( ))
        return true;

    packet.size -= 8;
    const uint64_t headerSize = packet.size;
    for( size_t i = 0; i < nItems; ++i )
    {
        LBASSERT( sizes[i] > 0 );
        packet.size += sizes[ i ] + sizeof( uint64_t );
    }

    bool success = true;
    for( Connections::const_iterator i = connections.begin(); 
         i < connections.end(); ++i )
    {        
        ConnectionPtr connection = *i;
        connection->lockSend();
            
        if( !connection->send( &packet, headerSize, true ))
            success = false;

        for( size_t j = 0; j < nItems; ++j )
            if( !connection->send( &sizes[j], sizeof(uint64_t), true ) ||
                !connection->send( items[j], sizes[j], true ))
            {
                success = false;
            }

        connection->unlockSend();
    }
    return success;
}
Esempio n. 14
0
    bool setup(const uint32_t name)
    {
        if (plugin && info.name == name)
            return true;

        clear();

        if (name <= EQ_COMPRESSOR_NONE)
            return true;

        plugin = pression::PluginRegistry::getInstance().findPlugin(name);
        LBASSERTINFO(plugin, "Can't find plugin for decompressor " << name);
        if (!plugin)
            return false;

        instance = plugin->newDecompressor(name);
        info = plugin->findInfo(name);
        LBASSERT(info.name == name);

        LBLOG(LOG_PLUGIN) << "Instantiated " << (instance ? "" : "empty ")
                          << "decompressor of type 0x" << std::hex << name
                          << std::dec << std::endl;
        return true;
    }
Esempio n. 15
0
void Config::_switchCanvas()
{
    const eq::Canvases& canvases = getCanvases();
    if( canvases.empty( ))
        return;

    _frameData.setCurrentViewID( eq::UUID( ));

    if( !_currentCanvas )
    {
        _currentCanvas = canvases.front();
        return;
    }

    eq::CanvasesCIter i = stde::find( canvases, _currentCanvas );
    LBASSERT( i != canvases.end( ));

    ++i;
    if( i == canvases.end( ))
        _currentCanvas = canvases.front();
    else
        _currentCanvas = *i;
    _switchView(); // activate first view on canvas
}
Esempio n. 16
0
//---------------------------------------------------------------------------
// exit
//---------------------------------------------------------------------------
bool Config::exit()
{
    if( _state != STATE_RUNNING )
        LBWARN << "Exiting non-initialized config" << std::endl;

    LBASSERT( _state == STATE_RUNNING || _state == STATE_INITIALIZING );
    _state = STATE_EXITING;

    const Canvases& canvases = getCanvases();
    for( Canvases::const_iterator i = canvases.begin();
         i != canvases.end(); ++i )
    {
        Canvas* canvas = *i;
        canvas->exit();
    }

    for( Compounds::const_iterator i = _compounds.begin();
         i != _compounds.end(); ++i )
    {
        Compound* compound = *i;
        compound->exit();
    }

    const bool success = _updateRunning( true );

    // TODO: is this needed? sender of CMD_CONFIG_EXIT is the appNode itself
    // which sets the running state to false anyway. Besides, this event is
    // not handled by the appNode because it is already in exiting procedure
    // and does not call handleEvents anymore
    // eile: May be needed for reliability?
    send( findApplicationNetNode(), fabric::CMD_CONFIG_EVENT ) << Event::EXIT;

    _needsFinish = false;
    _state = STATE_STOPPED;
    return success;
}
Esempio n. 17
0
bool Window::createTransferWindow()
{
    LBASSERT( _systemWindow );

    if( _transferWindow )
        return true;

    // create another (shared) osWindow with no drawable
    WindowSettings settings = getSettings();
    settings.setIAttribute( WindowSettings::IATTR_HINT_DRAWABLE, OFF );
    const SystemWindow* sysWindow = _sharedContextWindow ?
                                    _sharedContextWindow->getSystemWindow() : 0;
    settings.setSharedContextWindow( sysWindow );
    const Pipe* pipe = getPipe();
    _transferWindow = pipe->getWindowSystem().createWindow( this, settings );

    if( _transferWindow )
    {
        if( !_transferWindow->configInit( ))
        {
            LBWARN << "Transfer window initialization failed" << std::endl;
            delete _transferWindow;
            _transferWindow = 0;
        }
        else
            makeCurrentTransfer(); // #177
    }
    else
        LBERROR << "Window system " << pipe->getWindowSystem()
                << " not implemented or supported" << std::endl;

    makeCurrent();

    LBVERB << "Transfer window initialization finished" << std::endl;
    return _transferWindow != 0;
}
Esempio n. 18
0
void StaticSlaveCM::addInstanceDatas( const ObjectDataIStreamDeque& cache,
                                      const uint128_t& /* start */ )
{
    LB_TS_THREAD( _rcvThread );
    LBASSERT( _currentIStream );
    LBASSERT( _currentIStream->getDataSize() == 0 );
    LBASSERT( cache.size() == 1 );
    if( cache.empty( ))
        return;

    ObjectDataIStream* stream = cache.front();
    LBASSERT( stream );
    LBASSERT( stream->isReady( ));
    LBASSERT( stream->getVersion() == VERSION_FIRST );

    if( !stream->isReady() || stream->getVersion() != VERSION_FIRST )
        return;

    LBLOG( LOG_OBJECTS ) << "Adding cached instance data" << std::endl;
    delete _currentIStream;
    _currentIStream = new ObjectDataIStream( *stream );
}
Esempio n. 19
0
PixelViewport ROIFinder::_getObjectPVP( const PixelViewport& pvp,
                                        const uint8_t*       src )
{
    LBASSERT( pvp.x >= 0 && pvp.x+pvp.w <= _wb &&
              pvp.y >= 0 && pvp.y+pvp.h <= _hb );

    // Calculate per-pixel histograms
    const uint8_t* s = src + pvp.y*_wb + pvp.x;

    memset( _histX, 0, pvp.w );
    memset( _histY, 0, pvp.h );
    for( int32_t y = 0; y < pvp.h; y++ )
    {
        for( int32_t x = 0; x < pvp.w; x++ )
        {
            const uint8_t val = s[ x ] & 1;
            _histX[ x ] += val;
            _histY[ y ] += val;
        }
        s += _wb;
    }

    // Find AABB based on X and Y axis historgams
    int32_t xMin = pvp.w;
    for( int32_t x = 0; x < pvp.w; x++ )
        if( _histX[x] != 0 )
        {
            xMin = x;
            break;
        }

    int32_t xMax = 0;
    for( int32_t x = pvp.w-1; x >= 0; x-- )
        if( _histX[x] != 0 )
        {
            xMax = x;
            break;
        }

    if( xMax < xMin )
        return PixelViewport( pvp.x, pvp.y, 0, 0 );

    int32_t yMin = pvp.h;
    for( int32_t y = 0; y < pvp.h; y++ )
        if( _histY[y] != 0 )
        {
            yMin = y;
            break;
        }

    int32_t yMax = 0;
    for( int32_t y = pvp.h-1; y >= 0; y-- )
        if( _histY[y] != 0 )
        {
            yMax = y;
            break;
        }

    if( yMax < yMin )
        return PixelViewport( pvp.x, pvp.y, 0, 0 );

    return PixelViewport( pvp.x+xMin, pvp.y+yMin, xMax-xMin+1, yMax-yMin+1 );
}
Esempio n. 20
0
void ROIFinder::_readbackInfo( util::ObjectManager& glObjects )
{
    LBASSERT( glObjects.supportsEqTexture( ));
    LBASSERT( glObjects.supportsEqFrameBufferObject( ));

    PixelViewport pvp = _pvp;
    pvp.apply( Zoom( GRID_SIZE, GRID_SIZE ));
    pvp.w = LB_MIN( pvp.w+pvp.x, _pvpOriginal.w+_pvpOriginal.x ) - pvp.x;
    pvp.h = LB_MIN( pvp.h+pvp.y, _pvpOriginal.h+_pvpOriginal.y ) - pvp.y;

    LBASSERT( pvp.isValid());

    // copy frame buffer to texture
    const void* bufferKey = _getInfoKey( );
    util::Texture* texture =
        glObjects.obtainEqTexture( bufferKey, GL_TEXTURE_RECTANGLE_ARB );

#ifdef EQ_ROI_USE_DEPTH_TEXTURE
    texture->copyFromFrameBuffer( GL_DEPTH_COMPONENT, pvp );
#else
    texture->copyFromFrameBuffer( GL_RGBA, pvp );
#endif

    // draw zoomed quad into FBO
    const void*     fboKey = _getInfoKey( );
    util::FrameBufferObject* fbo = glObjects.getEqFrameBufferObject( fboKey );

    if( fbo )
    {
        LBCHECK( fbo->resize( _pvp.w, _pvp.h ));
    }
    else
    {
        fbo = glObjects.newEqFrameBufferObject( fboKey );
        LBCHECK( fbo->init( _pvp.w, _pvp.h, GL_RGBA32F, 0, 0 ));
    }
    fbo->bind();

    texture->bind();

    // Enable & download depth texture
    glEnable( GL_TEXTURE_RECTANGLE_ARB );

    texture->applyWrap();
    texture->applyZoomFilter( FILTER_LINEAR );

    // Enable shaders
    GLuint program = glObjects.getProgram( shaderRBInfo );
    if( program == util::ObjectManager::INVALID )
    {
        // Create fragment shader which reads depth values from
        // rectangular textures
        const GLuint shader = glObjects.newShader( shaderRBInfo,
                                                        GL_FRAGMENT_SHADER );
        LBASSERT( shader != util::ObjectManager::INVALID );

#ifdef EQ_ROI_USE_DEPTH_TEXTURE
        const GLchar* fShaderPtr = roiFragmentShader_glsl.c_str();
#else
        const GLchar* fShaderPtr = roiFragmentShaderRGB_glsl.c_str();
#endif
        EQ_GL_CALL( glShaderSource( shader, 1, &fShaderPtr, 0 ));
        EQ_GL_CALL( glCompileShader( shader ));

        GLint status;
        glGetShaderiv( shader, GL_COMPILE_STATUS, &status );
        if( !status )
            LBERROR << "Failed to compile fragment shader for ROI finder"
                    << std::endl;

        program = glObjects.newProgram( shaderRBInfo );

        EQ_GL_CALL( glAttachShader( program, shader ));
        EQ_GL_CALL( glLinkProgram( program ));

        glGetProgramiv( program, GL_LINK_STATUS, &status );
        if( !status )
        {
            LBWARN << "Failed to link shader program for ROI finder"
                   << std::endl;
            return;
        }

        // use fragment shader and setup uniforms
        EQ_GL_CALL( glUseProgram( program ));

        GLint param = glGetUniformLocation( program, "texture" );
        glUniform1i( param, 0 );
    }
    else
    {
        // use fragment shader
        EQ_GL_CALL( glUseProgram( program ));
    }

    // Draw Quad
    glDisable( GL_LIGHTING );
    glColor3f( 1.0f, 1.0f, 1.0f );

    glBegin( GL_QUADS );
        glVertex3i(      0,      0, 0 );
        glVertex3i( _pvp.w,      0, 0 );
        glVertex3i( _pvp.w, _pvp.h, 0 );
        glVertex3i(      0, _pvp.h, 0 );
    glEnd();

    // restore state
    glDisable( GL_TEXTURE_RECTANGLE_ARB );
    EQ_GL_CALL( glUseProgram( 0 ));

    fbo->unbind();

    // finish readback of info
    LBASSERT( static_cast<int32_t>(_perBlockInfo.size()) >= _pvp.w*_pvp.h*4 );

    texture = fbo->getColorTextures()[0];
    LBASSERT( texture->getFormat() == GL_RGBA );
    LBASSERT( texture->getType() == GL_FLOAT );
    texture->download( &_perBlockInfo[0] );
}
Esempio n. 21
0
uint8_t ROIFinder::_splitArea( Area& a )
{
    LBASSERT( a.hole.getArea() > 0 );
#ifndef NDEBUG
    _invalidateAreas( _tmpAreas, 17 );
#endif

    _dim.x1 = a.pvp.x;
    _dim.x2 = a.hole.x;
    _dim.x3 = a.hole.x + a.hole.w;

    _dim.w1 = _dim.x2 - _dim.x1;
    _dim.w2 = a.hole.w;
    _dim.w3 = a.pvp.x + a.pvp.w - _dim.x3;
    _dim.w4 = _dim.w1 + _dim.w2;
    _dim.w5 = _dim.w2 + _dim.w3;
    _dim.w6 = _dim.w4 + _dim.w3;

    _dim.y1 = a.pvp.y;
    _dim.y2 = a.hole.y;
    _dim.y3 = a.hole.y + a.hole.h;

    _dim.h1 = _dim.y2 - _dim.y1;
    _dim.h2 = a.hole.h;
    _dim.h3 = a.pvp.y + a.pvp.h - _dim.y3;
    _dim.h4 = _dim.h1 + _dim.h2;
    _dim.h5 = _dim.h2 + _dim.h3;
    _dim.h6 = _dim.h4 + _dim.h3;

    // other cases
    uint8_t type;
    if( a.pvp.h == a.hole.h ) // hole through the whole block
    {
        LBASSERT( a.pvp.w != a.hole.w );
        type = 8;
    }
    else if( a.pvp.w == a.hole.w ) // hole through the whole block
    {
        type = 9;
    }
    else if( a.pvp.x == a.hole.x ) // left side
    {
        if( a.pvp.y == a.hole.y )
            // in the lower left corner
            type = 0;
        else if( a.pvp.y + a.pvp.h == a.hole.y + a.hole.h )
            // in the upper left corner
            type = 1;
        else
            // in the left middle
            type = 2;
    }
    else if( a.pvp.y == a.hole.y ) // bottom side
    {
        if( a.pvp.x + a.pvp.w == a.hole.x + a.hole.w )
            // in the bottom right corner
            type = 3;
        else
            // in the bottom middle
            type = 4;
    }
    else if( a.pvp.x + a.pvp.w == a.hole.x + a.hole.w ) // right side
    {
        if( a.pvp.y + a.pvp.h == a.hole.y + a.hole.h )
            // in the upper right corner
            type = 5;
        else
            // in the right middle
            type = 6;
    }
    else if( a.pvp.y + a.pvp.h == a.hole.y + a.hole.h ) // top side
        // in the upper middle corner
        type = 7;
    else
        // must be in the center
        type = 10;

    // Calculate areas of interest
    if( type == 10 ) // center hole position
    {
        for( uint8_t i = 1; i <= 16; i++ )
            _updateSubArea( i );
    }
    else
    {
        for( uint8_t i = 0; i < 8; i++ )
            _updateSubArea( _interests[ type ][ i ] );
    }

    // find best combinations of areas of interest
    const uint8_t varaintsNum     = _compilNums[type][0];
    const uint8_t areasPerVariant = _compilNums[type][1];

    int32_t maxSum  = 0;
    int32_t variant = 0;
    if( type == 10 ) // center hole
    {
        for( uint8_t i = 0; i < varaintsNum; i++ )
        {
            int32_t sum = 0;
            for( uint8_t j = 0; j < areasPerVariant; j++ )
            {
                LBASSERT( _tmpAreas[_compilations16[i][j]].valid );
                sum += _tmpAreas[_compilations16[i][j]].emptySize;
            }

            if( sum > maxSum )
            {
                maxSum  = sum;
                variant = i;
            }
        }

        for( uint8_t j = 0; j < areasPerVariant; j++ )
        {
            LBASSERT( _tmpAreas[_compilations16[variant][j]].valid );
            _finalAreas[j] = _tmpAreas[_compilations16[variant][j]];
        }

        return areasPerVariant;
    }
    // else any other hole

    for( uint8_t i = 0; i < varaintsNum; i++ )
    {
        int32_t sum = 0;
        for( uint8_t j = 0; j < areasPerVariant; j++ )
        {
            LBASSERT( _tmpAreas[_compilations[type][i][j]].valid );
            sum += _tmpAreas[_compilations[type][i][j]].emptySize;
        }

        if( sum > maxSum )
        {
            maxSum  = sum;
            variant = i;
        }
    }

    for( uint8_t j = 0; j < areasPerVariant; j++ )
    {
        LBASSERT( _tmpAreas[_compilations[type][variant][j]].valid );
        _finalAreas[j] = _tmpAreas[_compilations[type][variant][j]];
    }

    return areasPerVariant;
}
Esempio n. 22
0
bool ConnectionSet::_setupFDSet()
{
//    if( !_impl->dirty )
//    {
//#ifndef _WIN32
//        // TODO: verify that poll() really modifies _fdSet, and remove the copy
//        // if it doesn't. The man page seems to hint that poll changes fds.
//        _impl->fdSet = _impl->fdSetCopy;
//#endif
//        return true;
//    }

    _impl->dirty = false;
    _impl->fdSet.setSize( 0 );
    _impl->fdSetResult.setSize( 0 );

#ifdef _WIN32
    // add self connection
    HANDLE readHandle = _impl->selfConnection->getNotifier();
    LBASSERT( readHandle );
    _impl->fdSet.append( readHandle );

    Result res;
    res.connection = _impl->selfConnection.get();
    _impl->fdSetResult.append( res );

    // add regular connections
    _impl->lock.set();
    for( ConnectionsCIter i = _impl->connections.begin();
         i != _impl->connections.end(); ++i )
    {
        ConnectionPtr connection = *i;
        if ( connection->isRead() )
            continue;

        readHandle = connection->getNotifier();

        if( !readHandle )
        {
            LBINFO << "Cannot select connection " << connection
                 << ", connection does not provide a read handle" << std::endl;
            _impl->connection = connection;
            _impl->lock.unset();
            return false;
        }

        _impl->fdSet.append( readHandle );

        Result result;
        result.connection = connection.get();
        _impl->fdSetResult.append( result );
    }

    for( ThreadsCIter i=_impl->threads.begin(); i != _impl->threads.end(); ++i )
    {
        Thread* thread = *i;
        readHandle = thread->notifier;
        LBASSERT( readHandle );
        _impl->fdSet.append( readHandle );

        Result result;
        result.thread = thread;
        _impl->fdSetResult.append( result );
    }
    _impl->lock.unset();
#else // _WIN32
    pollfd fd;
    fd.events = POLLIN; // | POLLPRI;

    // add self 'connection'
    fd.fd = _impl->selfConnection->getNotifier();
    LBASSERT( fd.fd > 0 );
    fd.revents = 0;
    _impl->fdSet.append( fd );

    Result result;
    result.connection = _impl->selfConnection.get();
    _impl->fdSetResult.append( result );

    // add regular connections
    _impl->lock.set();
    for( ConnectionsCIter i = _impl->allConnections.begin();
         i != _impl->allConnections.end(); ++i )
    {
        ConnectionPtr connection = *i;
        if ( connection->isRead() )
            continue;

        fd.fd = connection->getNotifier();

        if( fd.fd <= 0 )
        {
            LBINFO << "Cannot select connection " << connection
                   << ", connection " << typeid( *connection.get( )).name()
                   << " doesn't have a file descriptor" << std::endl;
            _impl->connection = connection;
            _impl->lock.unset();
            return false;
        }

        LBVERB << "Listening on " << typeid( *connection.get( )).name()
               << " @" << (void*)connection.get() << std::endl;
        fd.revents = 0;

        _impl->fdSet.append( fd );

        result.connection = connection.get();
        _impl->fdSetResult.append( result );
    }
    _impl->lock.unset();
    _impl->fdSetCopy = _impl->fdSet;
#endif

    return true;
}
Esempio n. 23
0
ConnectionSet::Event ConnectionSet::select( const uint32_t timeout )
{
    LB_TS_SCOPED( _selectThread );
    while( true )
    {
        _impl->connection = 0;
        _impl->error      = 0;
#ifdef _WIN32
        if( _impl->thread )
        {
            _impl->thread->event = EVENT_NONE; // unblock previous thread
            _impl->thread = 0;
        }
#endif

        if( !_setupFDSet( ))
            return EVENT_INVALID_HANDLE;

        // poll for a result
#ifdef _WIN32
        LBASSERT( LB_TIMEOUT_INDEFINITE == INFINITE );
        const DWORD ret = WaitForMultipleObjectsEx( _impl->fdSet.getSize(),
                                                    _impl->fdSet.getData(),
                                                    FALSE, timeout, TRUE );
#else
        const int pollTimeout = timeout == LB_TIMEOUT_INDEFINITE ?
                                -1 : int( timeout );
        const int ret = poll( _impl->fdSet.getData(), _impl->fdSet.getSize(),
                              pollTimeout );
#endif
        switch( ret )
        {
            case SELECT_TIMEOUT:
                return EVENT_TIMEOUT;

            case SELECT_ERROR:
#ifdef _WIN32
                if( !_impl->thread )
                    _impl->error = GetLastError();

                if( _impl->error == WSA_INVALID_HANDLE )
                {
                    _impl->dirty = true;
                    break;
                }
#else
                if( errno == EINTR ) // Interrupted system call (gdb) - ignore
                    break;

                _impl->error = errno;
#endif

                LBERROR << "Error during select: " << lunchbox::sysError
                        << std::endl;
                return EVENT_SELECT_ERROR;

            default: // SUCCESS
                {
                    Event event = _getSelectResult( ret );

                    if( event == EVENT_NONE )
                         break;

                    if( _impl->connection == _impl->selfConnection.get( ))
                    {
                        _impl->connection = 0;
                        _impl->selfConnection->reset();
                        return EVENT_INTERRUPT;
                    }
                    if( event == EVENT_DATA &&_impl->connection->isListening())
                        event = EVENT_CONNECT;
#ifdef _WIN32
                    if ( _isThreadMode && _needRebalance )
                        _rebalanceThreads();
#endif
                    _rotateFDSet();
                    return event;
                }
        }
    }
}
Esempio n. 24
0
Window::~Window()
{
    LBASSERT( getChannels().empty( ));
}
Esempio n. 25
0
void Window::updateFrameBuffer() const
{
    LBASSERT( _systemWindow );
    if( _systemWindow )
        _systemWindow->updateFrameBuffer();
}
Esempio n. 26
0
void Window::bindDrawFrameBuffer() const
{
    LBASSERT( _systemWindow );
    if( _systemWindow )
        _systemWindow->bindDrawFrameBuffer();
}
Esempio n. 27
0
void Window::makeCurrentTransfer( const bool useCache ) const
{
    LBASSERT( _transferWindow );
    if( _transferWindow )
        _transferWindow->makeCurrent( useCache );
}
Esempio n. 28
0
SystemPipe* Window::getSystemPipe()
{
    Pipe* pipe = getPipe();
    LBASSERT( pipe );
    return pipe->getSystemPipe();
}
Esempio n. 29
0
void Window::finish() const
{
    LBASSERT( _systemWindow );
    if( _systemWindow )
        _systemWindow->finish();
}
Esempio n. 30
0
ServerPtr Window::getServer()
{
    Pipe* pipe = getPipe();
    LBASSERT( pipe );
    return ( pipe ? pipe->getServer() : 0 );
}