VirtualBox

Ignore:
Timestamp:
Oct 21, 2010 12:52:37 PM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: scrolling with aero 8x speedup, bugfixing + profiling

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/util/vboxhgsmi.c

    r33241 r33306  
    6060#endif
    6161
     62#define VBOX_WITH_CRHGSMIPROFILE
     63#ifdef VBOX_WITH_CRHGSMIPROFILE
     64#include <iprt/time.h>
     65#include <stdio.h>
     66
     67typedef struct VBOXCRHGSMIPROFILE
     68{
     69    uint64_t cStartTime;
     70    uint64_t cStepsTime;
     71    uint64_t cSteps;
     72} VBOXCRHGSMIPROFILE, *PVBOXCRHGSMIPROFILE;
     73
     74#define VBOXCRHGSMIPROFILE_GET_TIME_NANO() RTTimeNanoTS()
     75#define VBOXCRHGSMIPROFILE_GET_TIME_MILLI() RTTimeMilliTS()
     76
     77/* 10 sec */
     78#define VBOXCRHGSMIPROFILE_LOG_STEP_TIME (10000000000.)
     79
     80DECLINLINE(void) vboxCrHgsmiProfileStart(PVBOXCRHGSMIPROFILE pProfile)
     81{
     82    pProfile->cStepsTime = 0;
     83    pProfile->cSteps = 0;
     84    pProfile->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
     85}
     86
     87DECLINLINE(void) vboxCrHgsmiProfileStep(PVBOXCRHGSMIPROFILE pProfile, uint64_t cStepTime)
     88{
     89    pProfile->cStepsTime += cStepTime;
     90    ++pProfile->cSteps;
     91}
     92
     93typedef struct VBOXCRHGSMIPROFILE_SCOPE
     94{
     95    uint64_t cStartTime;
     96//    bool bDisable;
     97} VBOXCRHGSMIPROFILE_SCOPE, *PVBOXCRHGSMIPROFILE_SCOPE;
     98
     99static VBOXCRHGSMIPROFILE g_VBoxProfile;
     100
     101static void vboxCrHgsmiLog(char * szString, ...)
     102{
     103    char szBuffer[4096] = {0};
     104     va_list pArgList;
     105     va_start(pArgList, szString);
     106     _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
     107     va_end(pArgList);
     108
     109     VBoxCrHgsmiLog(szBuffer);
     110}
     111
     112DECLINLINE(void) vboxCrHgsmiProfileLog(PVBOXCRHGSMIPROFILE pProfile, uint64_t cTime)
     113{
     114    uint64_t profileTime = cTime - pProfile->cStartTime;
     115    double percent = ((double)100.0) * pProfile->cStepsTime / profileTime;
     116    double cps = ((double)1000000000.) * pProfile->cSteps / profileTime;
     117    vboxCrHgsmiLog("hgsmi: cps: %.1f, host %.1f%%\n", cps, percent);
     118}
     119
     120DECLINLINE(void) vboxCrHgsmiProfileScopeEnter(PVBOXCRHGSMIPROFILE_SCOPE pScope)
     121{
     122//    pScope->bDisable = false;
     123    pScope->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
     124}
     125
     126DECLINLINE(void) vboxCrHgsmiProfileScopeExit(PVBOXCRHGSMIPROFILE_SCOPE pScope)
     127{
     128//    if (!pScope->bDisable)
     129    {
     130        uint64_t cTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
     131        vboxCrHgsmiProfileStep(&g_VBoxProfile, cTime - pScope->cStartTime);
     132        if (VBOXCRHGSMIPROFILE_LOG_STEP_TIME < cTime - g_VBoxProfile.cStartTime)
     133        {
     134            vboxCrHgsmiProfileLog(&g_VBoxProfile, cTime);
     135            vboxCrHgsmiProfileStart(&g_VBoxProfile);
     136        }
     137    }
     138}
     139
     140
     141#define VBOXCRHGSMIPROFILE_INIT() vboxCrHgsmiProfileStart(&g_VBoxProfile)
     142#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
     143
     144#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() \
     145        VBOXCRHGSMIPROFILE_SCOPE __vboxCrHgsmiProfileScope; \
     146        vboxCrHgsmiProfileScopeEnter(&__vboxCrHgsmiProfileScope);
     147
     148#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() \
     149        vboxCrHgsmiProfileScopeExit(&__vboxCrHgsmiProfileScope); \
     150
     151
     152#else
     153#define VBOXCRHGSMIPROFILE_INIT() do {} while (0)
     154#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
     155#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() do {} while (0)
     156#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() do {} while (0)
     157#endif
     158
     159
    62160typedef struct {
    63161    int                  initialized;
    … …  
    443541static void *crVBoxHGSMIAlloc(CRConnection *conn)
    444542{
    445     PCRVBOXHGSMI_CLIENT pClient = _crVBoxHGSMIClientGet();
    446     void *pvBuf = _crVBoxHGSMIDoAlloc(pClient, conn->buffer_size);
     543    PCRVBOXHGSMI_CLIENT pClient;
     544    void *pvBuf;
     545
     546    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     547
     548    pClient = _crVBoxHGSMIClientGet();
     549    pvBuf = _crVBoxHGSMIDoAlloc(pClient, conn->buffer_size);
    447550    Assert(pvBuf);
     551
     552    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     553
    448554    return pvBuf;
    449555}
    … …  
    456562    pSubm->fFlags.Value = 0;
    457563    pSubm->fFlags.bDoNotRetire = 1;
    458     pSubm->fFlags.bDoNotSignalCompletion = 1; /* <- we do not need that actually since
    459                                                        * in case we want completion,
    460                                                        * we will block in _crVBoxHGSMICmdBufferGetRc (when locking the buffer)
    461                                                        * which is needed for getting the result */
     564//    pSubm->fFlags.bDoNotSignalCompletion = 1; /* <- we do not need that actually since
     565//                                                       * in case we want completion,
     566//                                                       * we will block in _crVBoxHGSMICmdBufferGetRc (when locking the buffer)
     567//                                                       * which is needed for getting the result */
    462568}
    463569
    … …  
    467573# error "Port Me!!"
    468574#endif
     575
     576DECLINLINE(void) _crVBoxHGSMIWaitCmd(PCRVBOXHGSMI_CLIENT pClient)
     577{
     578    int rc = CRVBOXHGSMI_BUF_WAIT(pClient->pCmdBuffer);
     579    Assert(rc == 0);
     580}
    469581
    470582static void _crVBoxHGSMIWriteExact(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI_BUFFER pBuf, uint32_t offStart, unsigned int len)
    … …  
    506618        if (RT_SUCCESS(rc))
    507619        {
     620            _crVBoxHGSMIWaitCmd(pClient);
    508621                /* @todo: do we need to wait for completion actually?
    509622                 * NOTE: in case we do not need completion,
    … …  
    539652        if (RT_SUCCESS(rc))
    540653        {
     654            _crVBoxHGSMIWaitCmd(pClient);
    541655                /* @todo: do we need to wait for completion actually?
    542656                 * NOTE: in case we do not need completion,
    … …  
    556670static void crVBoxHGSMIWriteExact(CRConnection *conn, const void *buf, unsigned int len)
    557671{
     672    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    558673    Assert(0);
    559674
    … …  
    566681//    _crVBoxHGSMIWriteExact(conn, pClient, pBuf, 0, len);
    567682//    _crVBoxHGSMIBufFree(pClient, pBuf);
     683    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    568684}
    569685
    … …  
    609725        return;
    610726    }
     727
     728    _crVBoxHGSMIWaitCmd(pClient);
    611729
    612730    parms = (CRVBOXHGSMIREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
    … …  
    733851            break;
    734852        }
     853
     854        _crVBoxHGSMIWaitCmd(pClient);
    735855
    736856        parms = (CRVBOXHGSMIWRITEREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
    … …  
    799919    PVBOXUHGSMI_BUFFER pBuf;
    800920
     921    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     922
    801923    if (!bufp) /* We're sending a user-allocated buffer. */
    802924    {
    … …  
    811933        _crVBoxHGSMIWriteReadExact(conn, pClient, (void*)start, 0, len, false);
    812934#endif
     935        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    813936        return;
    814937    }
    … …  
    822945    Assert(pBuf);
    823946    if (!pBuf)
     947    {
     948        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    824949        return;
     950    }
    825951
    826952    pClient = (PCRVBOXHGSMI_CLIENT)pBuf->pvUserData;
    … …  
    847973     */
    848974    *bufp = NULL;
     975
     976    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    849977}
    850978
    … …  
    852980{
    853981    PCRVBOXHGSMI_CLIENT pClient;
    854     PVBOXUHGSMI_BUFFER pBuf = _crVBoxHGSMIBufFromMemPtr(buf);
     982    PVBOXUHGSMI_BUFFER pBuf;
     983    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     984    pBuf = _crVBoxHGSMIBufFromMemPtr(buf);
    855985    Assert(pBuf);
    856986    Assert(0);
    857987    CRASSERT(0);
    858988    if (!pBuf)
     989    {
     990        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    859991        return;
     992    }
    860993    pClient = (PCRVBOXHGSMI_CLIENT)pBuf->pvUserData;
    861994    _crVBoxHGSMIReadExact(conn, pClient);
    862 }
    863 
    864 static void crVBoxHGSMIFree(CRConnection *conn, void *buf)
     995    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     996}
     997
     998static void _crVBoxHGSMIFree(CRConnection *conn, void *buf)
    865999{
    8661000    CRVBOXHGSMIBUFFER *hgsmi_buffer = (CRVBOXHGSMIBUFFER *) buf - 1;
    … …  
    8881022#endif
    8891023    }
     1024}
     1025static void crVBoxHGSMIFree(CRConnection *conn, void *buf)
     1026{
     1027    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     1028    _crVBoxHGSMIFree(conn, buf);
     1029    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    8901030}
    8911031
    … …  
    9671107        && cached_type != CR_MESSAGE_GATHER)
    9681108    {
    969         crVBoxHGSMIFree(conn, msg);
     1109        _crVBoxHGSMIFree(conn, msg);
    9701110    }
    9711111}
    … …  
    9731113static void crVBoxHGSMIReceiveMessage(CRConnection *conn)
    9741114{
    975     PCRVBOXHGSMI_CLIENT pClient = _crVBoxHGSMIClientGet();
     1115    PCRVBOXHGSMI_CLIENT pClient;
     1116    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     1117
     1118    pClient = _crVBoxHGSMIClientGet();
    9761119
    9771120    Assert(pClient);
    … …  
    9791122
    9801123    _crVBoxHGSMIReceiveMessage(conn, pClient);
     1124    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    9811125}
    9821126/*
    … …  
    9851129static void crVBoxHGSMIAccept( CRConnection *conn, const char *hostname, unsigned short port )
    9861130{
     1131    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    9871132    Assert(0);
    9881133
    … …  
    9911136    CRASSERT(FALSE);
    9921137#endif
     1138    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    9931139}
    9941140
    … …  
    10381184#ifdef RT_OS_WINDOWS
    10391185    DWORD cbReturned;
     1186    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    10401187
    10411188    if (g_crvboxhgsmi.hGuestDrv == INVALID_HANDLE_VALUE)
    … …  
    10551202            Assert(0);
    10561203            crDebug("could not open VBox Guest Additions driver! rc = %d\n", GetLastError());
     1204            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    10571205            return FALSE;
    10581206        }
    10591207    }
    10601208#else
     1209    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     1210
    10611211    if (g_crvboxhgsmi.iGuestDrv == INVALID_HANDLE_VALUE)
    10621212    {
    … …  
    10651215        {
    10661216            crDebug("could not open Guest Additions kernel module! rc = %d\n", errno);
     1217            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    10671218            return FALSE;
    10681219        }
    … …  
    10971248        if (info.result == VINF_SUCCESS)
    10981249        {
     1250            int rc;
    10991251            conn->u32ClientID = info.u32ClientID;
    11001252            crDebug("HGCM connect was successful: client id =0x%x\n", conn->u32ClientID);
    11011253
    1102             return crVBoxHGSMISetVersion(conn, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR);
     1254            rc = crVBoxHGSMISetVersion(conn, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR);
     1255            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     1256            return rc;
    11031257        }
    11041258        else
    … …  
    11161270#endif
    11171271    }
     1272
     1273    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    11181274
    11191275    return FALSE;
    … …  
    11351291    int i;
    11361292#endif
     1293    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    11371294
    11381295    if (conn->pHostBuffer)
    … …  
    12141371# endif
    12151372    }
     1373    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    12161374#endif /* IN_GUEST */
    12171375}
    … …  
    12191377static void crVBoxHGSMIInstantReclaim(CRConnection *conn, CRMessage *mess)
    12201378{
     1379    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    12211380    Assert(0);
    12221381
    1223     crVBoxHGSMIFree(conn, mess);
     1382    _crVBoxHGSMIFree(conn, mess);
    12241383    CRASSERT(FALSE);
     1384
     1385    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    12251386}
    12261387
    12271388static void crVBoxHGSMIHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len )
    12281389{
     1390    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    12291391    Assert(0);
    12301392
    12311393    CRASSERT(FALSE);
     1394    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    12321395}
    12331396
    … …  
    12411404        pClient->pHgsmi = pHgsmi;
    12421405        rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1),
    1243                                 VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE, NULL,
     1406                                VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
     1407                                NULL,
    12441408                                &pClient->pCmdBuffer);
    12451409        AssertRC(rc);
    … …  
    12471411        {
    12481412            rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(0x800000),
    1249                                             VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE, NULL,
     1413                                            VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
     1414                                            NULL,
    12501415                                            &pClient->pHGBuffer);
    12511416            AssertRC(rc);
Note: See TracChangeset for help on using the changeset viewer.

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