C++ (Cpp) releaseFrameLocal示例

示例#1

文件： node.cpp 项目： aoighost/Equalizer

void Node::frameTasksFinish( const uint128_t&, const uint32_t frameNumber )
{
    switch( getIAttribute( IATTR_THREAD_MODEL ))
    {
        case ASYNC:      // No sync, release in frameStart
        case DRAW_SYNC:  // Sync and release in frameDrawFinish
            break;

        case LOCAL_SYNC:
        {
            const Pipes& pipes = getPipes();
            for( Pipes::const_iterator i = pipes.begin(); i != pipes.end(); ++i)
            {
                const Pipe* pipe = *i;
                if( pipe->getTasks() != fabric::TASK_NONE )
                    pipe->waitFrameLocal( frameNumber );
            }
            
            releaseFrameLocal( frameNumber );
            break;
        }
        default:
            LBUNIMPLEMENTED;
    }
}

示例#2

文件： window.cpp 项目： gitter-badger/Equalizer

void Window::frameDrawFinish( const uint128_t&, const uint32_t frameNumber )
{
    releaseFrameLocal( frameNumber );

    // https://github.com/Eyescale/Equalizer/issues/95
    if( getNode()->getPipes().size() > 1 )
        finish();
}

示例#3

文件： config.cpp 项目： yarda/Equalizer

bool Config::_cmdReleaseFrameLocal( co::Command& command )
{
    const ConfigReleaseFrameLocalPacket* packet =
        command.get< ConfigReleaseFrameLocalPacket >();

    _frameStart(); // never happened from node
    releaseFrameLocal( packet->frameNumber );
    return true;
}

示例#4

文件： node.cpp 项目： aoighost/Equalizer

void Node::frameStart( const uint128_t&, const uint32_t frameNumber )
{
    startFrame( frameNumber ); // unlock pipe threads
    
    switch( getIAttribute( IATTR_THREAD_MODEL ))
    {
        case ASYNC:
            // Don't wait for pipes to release frame locally, sync not needed
            releaseFrameLocal( frameNumber );
            break;

        case DRAW_SYNC:  // Sync and release in frameDrawFinish
        case LOCAL_SYNC: // Sync and release in frameTasksFinish
            break;

        default:
            LBUNIMPLEMENTED;
    }
}

示例#5

文件： pipe.cpp 项目： niujunpenghn/Equalizer

void Pipe::frameDrawFinish( const uint128_t&, const uint32_t frameNumber )
{
    const Node* node = getNode();
    switch( node->getIAttribute( Node::IATTR_THREAD_MODEL ))
    {
        case ASYNC:      // released in frameStart
            break;

        case DRAW_SYNC:  // release
            releaseFrameLocal( frameNumber );
            break;

        case LOCAL_SYNC: // release in frameFinish
            break;

        default:
            LBUNIMPLEMENTED;
    }
}

示例#6

文件： pipe.cpp 项目： niujunpenghn/Equalizer

bool Pipe::_cmdFrameFinish( co::ICommand& cmd )
{
    LB_TS_THREAD( _pipeThread );

    co::ObjectICommand command( cmd );
    const uint128_t frameID = command.get< uint128_t >();
    const uint32_t frameNumber = command.get< uint32_t >();

    LBLOG( LOG_TASKS ) << "---- TASK finish frame --- " << command << " frame "
                       << frameNumber << " id " << frameID << std::endl;

    LBASSERTINFO( _impl->currentFrame >= frameNumber,
                  "current " <<_impl->currentFrame << " finish " <<frameNumber);

    frameFinish( frameID, frameNumber );

    LBASSERTINFO( _impl->finishedFrame >= frameNumber,
                  "Pipe::frameFinish() did not release frame " << frameNumber );

    if( _impl->unlockedFrame < frameNumber )
    {
        LBWARN << "Finished frame was not locally unlocked, enforcing unlock"
               << std::endl << "    unlocked " << _impl->unlockedFrame.get()
               << " done " << frameNumber << std::endl;
        releaseFrameLocal( frameNumber );
    }

    if( _impl->finishedFrame < frameNumber )
    {
        LBWARN << "Finished frame was not released, enforcing unlock"
               << std::endl;
        releaseFrame( frameNumber );
    }

    _releaseViews();

    const uint128_t version = commit();
    if( version != co::VERSION_NONE )
        send( command.getNode(), fabric::CMD_OBJECT_SYNC );
    return true;
}

示例#7

文件： node.cpp 项目： aoighost/Equalizer

void Node::_frameFinish( const uint128_t& frameID, 
                         const uint32_t frameNumber )
{
    frameFinish( frameID, frameNumber );
    LBLOG( LOG_TASKS ) << "---- Finished Frame --- " << frameNumber
                       << std::endl;

    if( _unlockedFrame < frameNumber )
    {
        LBWARN << "Finished frame was not locally unlocked, enforcing unlock" 
               << std::endl;
        releaseFrameLocal( frameNumber );
    }

    if( _finishedFrame < frameNumber )
    {
        LBWARN << "Finished frame was not released, enforcing unlock"
               << std::endl;
        releaseFrame( frameNumber );
    }
}

示例#8

文件： pipe.cpp 项目： niujunpenghn/Equalizer

void Pipe::frameStart( const uint128_t&, const uint32_t frameNumber )
{
    LB_TS_THREAD( _pipeThread );

    const Node* node = getNode();
    switch( node->getIAttribute( Node::IATTR_THREAD_MODEL ))
    {
        case ASYNC:      // No sync, release immediately
            releaseFrameLocal( frameNumber );
            break;

        case DRAW_SYNC:  // Sync, release in frameDrawFinish
        case LOCAL_SYNC: // Sync, release in frameFinish
            node->waitFrameStarted( frameNumber );
            break;

        default:
            LBUNIMPLEMENTED;
    }

    startFrame( frameNumber );
}