VirtualBox

Changeset 52451 in vbox for trunk/src


Ignore:
Timestamp:
Aug 21, 2014 7:20:27 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
95662
Message:

crOpenGL: command blocks flushing

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/src/VBox

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

    r52329 r52451  
    565565    }
    566566
    567 #ifdef DEBUG_misha
    568     if (pCurState->lists.currentIndex)
    569     {
    570         WARN(("GetError called in DisplayList"));
    571     }
    572 #endif
    573 
    574     if (!pCurState->lists.currentIndex || !(g_u32VBoxHostCaps & CR_VBOX_CAP_CMDBLOCKS))
    575     {
    576         packspuFlush( (void *) thread );
    577         CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
    578         if (pack_spu.swap)
    579         {
    580             return_val = (GLenum) SWAP32(return_val);
    581         }
    582     }
    583     else
    584     {
    585         return_val = GL_NO_ERROR;
     567    packspuFlush( (void *) thread );
     568    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
     569
     570    if (pack_spu.swap)
     571    {
     572        return_val = (GLenum) SWAP32(return_val);
    586573    }
    587574

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_net.c

    r51319 r52451  
    250250    {
    251251        g_u32VBoxHostCaps = crNetHostCapsGet();
    252         if (g_u32VBoxHostCaps & CR_VBOX_CAP_CMDBLOCKS)
    253             crPackCmdBlocksEnable();
     252        crPackCapsSet(g_u32VBoxHostCaps);
    254253    }
    255254}

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_pack.h

    r52260 r52451  
    191191extern DECLEXPORT(void) crPackExpandMultiDrawElementsEXTSWAP( GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount, CRClientState *c, const GLfloat *pZva );
    192192
    193 extern DECLEXPORT(void) crPackCmdBlocksEnable();
    194 
     193extern DECLEXPORT(void) crPackCapsSet(uint32_t u32Caps);
    195194
    196195/**
    … …  
    311310  } while (0)
    312311
     312#define CR_CMDBLOCK_CHECK_FLUSH( pc )                               \
     313  do {                                                              \
     314    if (!(cr_packer_cmd_blocks_enabled & CR_VBOX_CAP_CMDBLOCKS_FLUSH)) break; \
     315    if(!CRPACKBLOCKSTATE_IS_OP_STARTED((pc)->u32CmdBlockState, CRPACKBLOCKSTATE_OP_NEWLIST)) break; \
     316    THREADASSERT( pc );                                             \
     317    CRASSERT( (pc)->currentBuffer );                                \
     318    if ( !crPackCanHoldOpcode( pc, 1, 4 ) ) {                       \
     319      (pc)->Flush( (pc)->flush_arg );                               \
     320      Assert(crPackCanHoldOpcode( pc, 1, 4 ) );                     \
     321    }                                                               \
     322    CR_CMDBLOCK_OP( pc, CR_CMDBLOCKFLUSH_OPCODE );                  \
     323    (pc)->Flush( (pc)->flush_arg );                                 \
     324  } while (0)
     325
    313326/**
    314327 * Alloc space for a message of 'len' bytes (plus 1 opcode).

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_protocol.h

    r51330 r52451  
    5151/* GetAttribsLocations support */
    5252#define CR_VBOX_CAP_GETATTRIBSLOCATIONS  0x00000008
    53 
    54 #define CR_VBOX_CAPS_ALL                 0x0000000f
     53/* flush command blocks for execution  */
     54#define CR_VBOX_CAP_CMDBLOCKS_FLUSH      0x00000010
     55
     56#define CR_VBOX_CAPS_ALL                 0x0000001f
    5557
    5658

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_unpack.h

    r50975 r52451  
    3434    CR_UNPACK_BUFFER_TYPE_GENERIC = 0,
    3535    CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN,
     36    CR_UNPACK_BUFFER_TYPE_CMDBLOCK_FLUSH,
    3637    CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END
    3738} CR_UNPACK_BUFFER_TYPE;

  • trunk/src/VBox/GuestHost/OpenGL/packer/opcodes.py

    r50973 r52451  
    3939enum_index = enum_index + 1
    4040print "\tCR_CMDBLOCKEND_OPCODE=%d," % enum_index
     41enum_index = enum_index + 1
     42print "\tCR_CMDBLOCKFLUSH_OPCODE=%d," % enum_index
    4143print "\tCR_NOP_OPCODE=255"
    4244if enum_index > 254:

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_beginend.c

    r52260 r52451  
    8585    CR_UNLOCK_PACKER_CONTEXT(pc);
    8686}
    87 

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_bufferobject.c

    r33475 r52451  
    100100        WRITE_NETWORK_POINTER( 28, (void *) writeback );
    101101        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     102        CR_CMDBLOCK_CHECK_FLUSH(pc);
    102103    CR_UNLOCK_PACKER_CONTEXT(pc);
    103104}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_context.c

    r33475 r52451  
    4646        WRITE_NETWORK_POINTER( DISPLAY_NAME_LEN + 24, (void *) writeback );
    4747        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     48        CR_CMDBLOCK_CHECK_FLUSH(pc);
    4849    CR_UNLOCK_PACKER_CONTEXT(pc);
    4950}
    … …  
    7879        WRITE_NETWORK_POINTER( DISPLAY_NAME_LEN + 24, (void *) writeback );
    7980        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     81        CR_CMDBLOCK_CHECK_FLUSH(pc);
    8082    CR_UNLOCK_PACKER_CONTEXT(pc);
    8183}
    … …  
    107109        WRITE_NETWORK_POINTER( DISPLAY_NAME_LEN + 20, (void *) writeback );
    108110        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     111        CR_CMDBLOCK_CHECK_FLUSH(pc);
    109112    CR_UNLOCK_PACKER_CONTEXT(pc);
    110113}
    … …  
    135138        WRITE_NETWORK_POINTER( DISPLAY_NAME_LEN + 20, (void *) writeback );
    136139        WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     140        CR_CMDBLOCK_CHECK_FLUSH(pc);
    137141    CR_UNLOCK_PACKER_CONTEXT(pc);
    138142}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_init.c

    r50984 r52451  
    1818#endif
    1919
    20 int cr_packer_cmd_blocks_enabled = 0;
     20uint32_t cr_packer_cmd_blocks_enabled = 0;
    2121
    2222CRPackContext *crPackNewContext( int swapping )
    … …  
    6969}
    7070
    71 void crPackCmdBlocksEnable()
     71void crPackCapsSet(uint32_t u32Caps)
    7272{
    73     cr_packer_cmd_blocks_enabled = 1;
     73    cr_packer_cmd_blocks_enabled = (u32Caps & (CR_VBOX_CAP_CMDBLOCKS_FLUSH | CR_VBOX_CAP_CMDBLOCKS));
    7474}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_pixels.c

    r50666 r52451  
    104104    WRITE_NETWORK_POINTER( 48, (char *) pixels );
    105105    WRITE_OPCODE( pc, CR_READPIXELS_OPCODE );
     106    CR_CMDBLOCK_CHECK_FLUSH(pc);
    106107    CR_UNLOCK_PACKER_CONTEXT(pc);
    107108}
    … …  
    220221    WRITE_NETWORK_POINTER( 32, (void *) writeback );
    221222    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     223    CR_CMDBLOCK_CHECK_FLUSH(pc);
    222224    CR_UNLOCK_PACKER_CONTEXT(pc);
    223225}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_program.c

    r51313 r52451  
    282282    WRITE_NETWORK_POINTER(20 + n * sizeof(*programs), (void *) writeback);
    283283    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     284    CR_CMDBLOCK_CHECK_FLUSH(pc);
    284285    CR_UNLOCK_PACKER_CONTEXT(pc);
    285286}
    … …  
    300301    WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
    301302    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     303    CR_CMDBLOCK_CHECK_FLUSH(pc);
    302304    CR_UNLOCK_PACKER_CONTEXT(pc);
    303305}
    … …  
    317319    WRITE_NETWORK_POINTER( 16 + len + 8, (void *) writeback );
    318320    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     321    CR_CMDBLOCK_CHECK_FLUSH(pc);
    319322    CR_UNLOCK_PACKER_CONTEXT(pc);
    320323}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_shaders.c

    r51200 r52451  
    429429    WRITE_NETWORK_POINTER(28, (void *) writeback);
    430430    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     431    CR_CMDBLOCK_CHECK_FLUSH(pc);
    431432    CR_UNLOCK_PACKER_CONTEXT(pc);
    432433}
    … …  
    449450    WRITE_NETWORK_POINTER(28, (void *) writeback);
    450451    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     452    CR_CMDBLOCK_CHECK_FLUSH(pc);
    451453    CR_UNLOCK_PACKER_CONTEXT(pc);
    452454}
    … …  
    466468    WRITE_NETWORK_POINTER(24, (void *) writeback);
    467469    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     470    CR_CMDBLOCK_CHECK_FLUSH(pc);
    468471    CR_UNLOCK_PACKER_CONTEXT(pc);
    469472}
    … …  
    482485        WRITE_NETWORK_POINTER(24, (void *) writeback);
    483486        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     487        CR_CMDBLOCK_CHECK_FLUSH(pc);
    484488    CR_UNLOCK_PACKER_CONTEXT(pc);
    485489}
    … …  
    498502        WRITE_NETWORK_POINTER(24, (void *) writeback);
    499503        WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     504        CR_CMDBLOCK_CHECK_FLUSH(pc);
    500505    CR_UNLOCK_PACKER_CONTEXT(pc);
    501506}
    … …  
    515520    WRITE_NETWORK_POINTER(24, (void *) writeback);
    516521    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     522    CR_CMDBLOCK_CHECK_FLUSH(pc);
    517523    CR_UNLOCK_PACKER_CONTEXT(pc);
    518524}
    … …  
    532538    WRITE_NETWORK_POINTER(24, (void *) writeback);
    533539    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     540    CR_CMDBLOCK_CHECK_FLUSH(pc);
    534541    CR_UNLOCK_PACKER_CONTEXT(pc);
    535542}
    … …  
    549556    WRITE_NETWORK_POINTER(24, (void *) writeback);
    550557    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     558    CR_CMDBLOCK_CHECK_FLUSH(pc);
    551559    CR_UNLOCK_PACKER_CONTEXT(pc);
    552560}
    … …  
    565573    WRITE_NETWORK_POINTER(24, (void *) writeback);
    566574    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     575    CR_CMDBLOCK_CHECK_FLUSH(pc);
    567576    CR_UNLOCK_PACKER_CONTEXT(pc);
    568577}
    … …  
    581590    WRITE_NETWORK_POINTER(24, (void *) writeback);
    582591    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     592    CR_CMDBLOCK_CHECK_FLUSH(pc);
    583593    CR_UNLOCK_PACKER_CONTEXT(pc);
    584594}
    … …  
    600610    WRITE_NETWORK_POINTER(8, (void *) writeback);
    601611    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     612    CR_CMDBLOCK_CHECK_FLUSH(pc);
    602613    CR_UNLOCK_PACKER_CONTEXT(pc);
    603614}
    … …  
    619630    WRITE_NETWORK_POINTER(8, (void *) writeback);
    620631    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     632    CR_CMDBLOCK_CHECK_FLUSH(pc);
    621633    CR_UNLOCK_PACKER_CONTEXT(pc);
    622634}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_swap_texture.c

    r33475 r52451  
    685685    WRITE_NETWORK_POINTER( sizeof( int ) + 24 + n*sizeof( *textures ), (void *) writeback );
    686686    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     687    CR_CMDBLOCK_CHECK_FLUSH(pc);
    687688    CR_UNLOCK_PACKER_CONTEXT(pc);
    688689}

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_texture.c

    r35919 r52451  
    719719    WRITE_NETWORK_POINTER(20 + n * sizeof(*textures), (void *) writeback);
    720720    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
     721    CR_CMDBLOCK_CHECK_FLUSH(pc);
    721722    CR_UNLOCK_PACKER_CONTEXT(pc);
    722723}

  • trunk/src/VBox/GuestHost/OpenGL/packer/packer.py

    r52329 r52451  
    211211        print "\tWRITE_OPCODE( pc, %s );" % apiutil.OpcodeName( func_name )
    212212
     213    if "get" in apiutil.Properties(func_name):
     214        print '\tCR_CMDBLOCK_CHECK_FLUSH(pc);'
     215
    213216    print '\tCR_UNLOCK_PACKER_CONTEXT(pc);'
    214217    print '}\n'

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r51670 r52451  
    420420int CrPMgrLoadState(PSSMHANDLE pSSM, uint32_t version);
    421421HCR_FRAMEBUFFER CrPMgrFbGet(uint32_t idScreen);
     422int CrPMgrClearRegionsGlobal();
    422423/*cleanup stuff*/
    423424

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_config.c

    r51655 r52451  
    178178                | CR_VBOX_CAP_CMDBLOCKS
    179179                | CR_VBOX_CAP_GETATTRIBSLOCATIONS
     180                | CR_VBOX_CAP_CMDBLOCKS_FLUSH
    180181                ;
    181182    }
    … …  
    328329                | CR_VBOX_CAP_CMDBLOCKS
    329330                | CR_VBOX_CAP_GETATTRIBSLOCATIONS
     331                | CR_VBOX_CAP_CMDBLOCKS_FLUSH
    330332                ;
    331333    }

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp

    r52429 r52451  
    48904890}
    48914891
     4892int CrPMgrClearRegionsGlobal()
     4893{
     4894    for (HCR_FRAMEBUFFER hFb = CrPMgrFbGetFirstEnabled();
     4895            hFb;
     4896            hFb = CrPMgrFbGetNextEnabled(hFb))
     4897    {
     4898        int rc = CrFbUpdateBegin(hFb);
     4899        if (RT_SUCCESS(rc))
     4900        {
     4901            rc = CrFbRegionsClear(hFb);
     4902            if (RT_FAILURE(rc))
     4903            {
     4904                WARN(("CrFbRegionsClear failed %d", rc));
     4905            }
     4906
     4907            CrFbUpdateEnd(hFb);
     4908        }
     4909    }
     4910
     4911    return VINF_SUCCESS;
     4912}
     4913
    48924914int CrPMgrModeVrdp(bool fEnable)
    48934915{

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_stream.c

    r52260 r52451  
    655655            break;
    656656        }
     657        case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_FLUSH: /* just flush for now */
     658        {
     659            CrPMgrClearRegionsGlobal(); /* clear regions to ensure we don't do MakeCurrent and friends */
     660            crServerPendProcess(conn);
     661            Assert(RTListIsEmpty(&conn->PendingMsgList));
     662            break;
     663        }
    657664        case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END:
    658665        {
    659             CRASSERT(!RTListIsEmpty(&conn->PendingMsgList));
     666//            CRASSERT(!RTListIsEmpty(&conn->PendingMsgList));
    660667            crServerPendProcess(conn);
    661668            Assert(RTListIsEmpty(&conn->PendingMsgList));

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack.py

    r50975 r52451  
    211211    const uint8_t *pu8Codes = (const uint8_t *)opcodes;
    212212
    213     CR_UNPACK_BUFFER_TYPE enmType;
    214213    uint8_t first;
    215214    uint8_t last;
    … …  
    220219    first = pu8Codes[0];
    221220    last = pu8Codes[1-(int)num_opcodes];
    222 
    223     enmType = (first != CR_CMDBLOCKBEGIN_OPCODE) ? CR_UNPACK_BUFFER_TYPE_GENERIC : CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN;
    224 
    225     if (last != CR_CMDBLOCKEND_OPCODE)
    226         return enmType;
    227 
    228     /* last is CMDBLOCKEND*/
    229     return (enmType == CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN) ? CR_UNPACK_BUFFER_TYPE_GENERIC : CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END;
     221   
     222    switch (last)
     223    {
     224        case CR_CMDBLOCKFLUSH_OPCODE:
     225            return CR_UNPACK_BUFFER_TYPE_CMDBLOCK_FLUSH;
     226        case CR_CMDBLOCKEND_OPCODE:
     227            return (first == CR_CMDBLOCKBEGIN_OPCODE) ? CR_UNPACK_BUFFER_TYPE_GENERIC : CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END;
     228        default:
     229            return (first != CR_CMDBLOCKBEGIN_OPCODE) ? CR_UNPACK_BUFFER_TYPE_GENERIC : CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN;
     230    }
    230231}
    231232
    … …  
    288289            case CR_CMDBLOCKBEGIN_OPCODE:
    289290            case CR_CMDBLOCKEND_OPCODE:
     291            case CR_CMDBLOCKFLUSH_OPCODE:
    290292            case CR_NOP_OPCODE:
    291293                INCR_DATA_PTR_NO_ARGS( );
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette