VirtualBox

Changeset 33365 in vbox


Ignore:
Timestamp:
Oct 22, 2010 4:28:07 PM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: chromium hgsmi fixes, profiling

Location:
trunk/src/VBox
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

    r33306 r33365  
    56655665        hr = pDevice->RtCallbacks.pfnSetDisplayModeCb(pDevice->hDevice, &DdiDm);
    56665666        Assert(hr == S_OK);
     5667#if 0
     5668        if (hr == S_OK)
     5669        {
     5670            D3DDDICB_LOCK DdiLock = {0};
     5671            DdiLock.hAllocation = pAlloc->hAllocation;
     5672            DdiLock.Flags.LockEntire = 1;
     5673            DdiLock.Flags.ReadOnly = 1;
     5674            hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &DdiLock);
     5675            Assert(hr == S_OK);
     5676            if (hr == S_OK)
     5677            {
     5678                D3DLOCKED_RECT LockRect;
     5679                IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pAlloc->pD3DIf;
     5680                hr = pD3DIfSurf->LockRect(&LockRect, NULL /* RECT*/, D3DLOCK_DISCARD);
     5681                Assert(hr == S_OK);
     5682                if (hr == S_OK)
     5683                {
     5684                    /** @todo: take pitch into account */
     5685                    Assert(pAlloc->SurfDesc.pitch == LockRect.Pitch);
     5686                    memcpy(LockRect.pBits, DdiLock.pData, LockRect.Pitch * pAlloc->SurfDesc.height);
     5687                    hr = pD3DIfSurf->UnlockRect();
     5688                    Assert(hr == S_OK);
     5689                }
     5690
     5691                D3DDDICB_UNLOCK DdiUnlock = {0};
     5692                DdiUnlock.NumAllocations = 1;
     5693                DdiUnlock.phAllocations = &pAlloc->hAllocation;
     5694                hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &DdiUnlock);
     5695                Assert(hr == S_OK);
     5696            }
     5697            hr = S_OK;
     5698#endif
     5699        }
    56675700    }
    56685701
    … …  
    76527685                        }
    76537686    #else
    7654     //# define VBOXDISP_TEST_SWAPCHAIN
     7687    # define VBOXDISP_TEST_SWAPCHAIN
    76557688    # ifdef VBOXDISP_TEST_SWAPCHAIN
    76567689                        VBOXDISP_D3DEV(pDevice);

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r33306 r33365  
    17611761    DXGKARG_DESCRIBEALLOCATION*  pDescribeAllocation)
    17621762{
    1763     dfprintf(("==> "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
     1763//    dfprintf(("==> "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
    17641764
    17651765    vboxVDbgBreakFv();
    … …  
    17741774    pDescribeAllocation->PrivateDriverFormatAttribute = 0;
    17751775
    1776     dfprintf(("<== "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
     1776//    dfprintf(("<== "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
    17771777
    17781778    return STATUS_SUCCESS;

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

    r32909 r33365  
    4646#include <VBox/HostServices/VBoxCrOpenGLSvc.h>
    4747
     48//#if defined(IN_GUEST)
     49//#define VBOX_WITH_CRHGSMIPROFILE
     50//#endif
     51#ifdef VBOX_WITH_CRHGSMIPROFILE
     52#include <iprt/time.h>
     53#include <stdio.h>
     54
     55#ifdef VBOX_WITH_CRHGSMI
     56#include <VBox/VBoxCrHgsmi.h>
     57#endif
     58
     59typedef struct VBOXCRHGSMIPROFILE
     60{
     61    uint64_t cStartTime;
     62    uint64_t cStepsTime;
     63    uint64_t cSteps;
     64} VBOXCRHGSMIPROFILE, *PVBOXCRHGSMIPROFILE;
     65
     66#define VBOXCRHGSMIPROFILE_GET_TIME_NANO() RTTimeNanoTS()
     67#define VBOXCRHGSMIPROFILE_GET_TIME_MILLI() RTTimeMilliTS()
     68
     69/* 10 sec */
     70#define VBOXCRHGSMIPROFILE_LOG_STEP_TIME (10000000000.)
     71
     72DECLINLINE(void) vboxCrHgsmiProfileStart(PVBOXCRHGSMIPROFILE pProfile)
     73{
     74    pProfile->cStepsTime = 0;
     75    pProfile->cSteps = 0;
     76    pProfile->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
     77}
     78
     79DECLINLINE(void) vboxCrHgsmiProfileStep(PVBOXCRHGSMIPROFILE pProfile, uint64_t cStepTime)
     80{
     81    pProfile->cStepsTime += cStepTime;
     82    ++pProfile->cSteps;
     83}
     84
     85typedef struct VBOXCRHGSMIPROFILE_SCOPE
     86{
     87    uint64_t cStartTime;
     88//    bool bDisable;
     89} VBOXCRHGSMIPROFILE_SCOPE, *PVBOXCRHGSMIPROFILE_SCOPE;
     90
     91static VBOXCRHGSMIPROFILE g_VBoxProfile;
     92
     93static void vboxCrHgsmiLog(char * szString, ...)
     94{
     95    char szBuffer[4096] = {0};
     96     va_list pArgList;
     97     va_start(pArgList, szString);
     98     _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
     99     va_end(pArgList);
     100
     101#ifdef VBOX_WITH_CRHGSMI
     102     VBoxCrHgsmiLog(szBuffer);
     103#else
     104     OutputDebugString(szBuffer);
     105#endif
     106}
     107
     108DECLINLINE(void) vboxCrHgsmiProfileLog(PVBOXCRHGSMIPROFILE pProfile, uint64_t cTime)
     109{
     110    uint64_t profileTime = cTime - pProfile->cStartTime;
     111    double percent = ((double)100.0) * pProfile->cStepsTime / profileTime;
     112    double cps = ((double)1000000000.) * pProfile->cSteps / profileTime;
     113    vboxCrHgsmiLog("hgcm: cps: %.1f, host %.1f%%\n", cps, percent);
     114}
     115
     116DECLINLINE(void) vboxCrHgsmiProfileScopeEnter(PVBOXCRHGSMIPROFILE_SCOPE pScope)
     117{
     118//    pScope->bDisable = false;
     119    pScope->cStartTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
     120}
     121
     122DECLINLINE(void) vboxCrHgsmiProfileScopeExit(PVBOXCRHGSMIPROFILE_SCOPE pScope)
     123{
     124//    if (!pScope->bDisable)
     125    {
     126        uint64_t cTime = VBOXCRHGSMIPROFILE_GET_TIME_NANO();
     127        vboxCrHgsmiProfileStep(&g_VBoxProfile, cTime - pScope->cStartTime);
     128        if (VBOXCRHGSMIPROFILE_LOG_STEP_TIME < cTime - g_VBoxProfile.cStartTime)
     129        {
     130            vboxCrHgsmiProfileLog(&g_VBoxProfile, cTime);
     131            vboxCrHgsmiProfileStart(&g_VBoxProfile);
     132        }
     133    }
     134}
     135
     136
     137#define VBOXCRHGSMIPROFILE_INIT() vboxCrHgsmiProfileStart(&g_VBoxProfile)
     138#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
     139
     140#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() \
     141        VBOXCRHGSMIPROFILE_SCOPE __vboxCrHgsmiProfileScope; \
     142        vboxCrHgsmiProfileScopeEnter(&__vboxCrHgsmiProfileScope);
     143
     144#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() \
     145        vboxCrHgsmiProfileScopeExit(&__vboxCrHgsmiProfileScope); \
     146
     147
     148#else
     149#ifdef IN_GUEST
     150#error "should not happen!"
     151#endif
     152#define VBOXCRHGSMIPROFILE_INIT() do {} while (0)
     153#define VBOXCRHGSMIPROFILE_TERM() do {} while (0)
     154#define VBOXCRHGSMIPROFILE_FUNC_PROLOGUE() do {} while (0)
     155#define VBOXCRHGSMIPROFILE_FUNC_EPILOGUE() do {} while (0)
     156#endif
     157
    48158typedef struct {
    49159    int                  initialized;
    … …  
    95205
    96206/* Some forward declarations */
    97 static void crVBoxHGCMReceiveMessage(CRConnection *conn);
     207static void _crVBoxHGCMReceiveMessage(CRConnection *conn);
    98208
    99209#ifndef IN_GUEST
    … …  
    233343}
    234344
    235 static void *crVBoxHGCMAlloc(CRConnection *conn)
     345static void *_crVBoxHGCMAlloc(CRConnection *conn)
    236346{
    237347    CRVBOXHGCMBUFFER *buf;
    … …  
    358468}
    359469
    360 static void crVBoxHGCMWriteExact(CRConnection *conn, const void *buf, unsigned int len)
     470static void *crVBoxHGCMAlloc(CRConnection *conn)
     471{
     472    void *pvBuff;
     473    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     474    pvBuff = _crVBoxHGCMAlloc(conn);
     475    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     476    return pvBuff;
     477}
     478
     479static void _crVBoxHGCMWriteExact(CRConnection *conn, const void *buf, unsigned int len)
    361480{
    362481    int rc;
    … …  
    407526}
    408527
     528static void crVBoxHGCMWriteExact(CRConnection *conn, const void *buf, unsigned int len)
     529{
     530    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     531    _crVBoxHGCMWriteExact(conn, buf, len);
     532    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     533}
     534
    409535static void crVBoxHGCMReadExact( CRConnection *conn, const void *buf, unsigned int len )
    410536{
    … …  
    441567
    442568    if (conn->cbBuffer)
    443         crVBoxHGCMReceiveMessage(conn);
     569        _crVBoxHGCMReceiveMessage(conn);
    444570
    445571}
    … …  
    517643
    518644    if (conn->cbBuffer)
    519         crVBoxHGCMReceiveMessage(conn);
     645        _crVBoxHGCMReceiveMessage(conn);
    520646}
    521647
    … …  
    524650{
    525651    CRVBOXHGCMBUFFER *hgcm_buffer;
     652    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    526653
    527654    if (!bufp) /* We're sending a user-allocated buffer. */
    … …  
    536663            crVBoxHGCMWriteReadExact(conn, start, len, CR_VBOXHGCM_USERALLOCATED);
    537664#endif
     665            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    538666        return;
    539667    }
    … …  
    553681    if (conn->u32InjectClientID)
    554682    {
    555         crVBoxHGCMWriteExact(conn, start, len);
     683        _crVBoxHGCMWriteExact(conn, start, len);
    556684    }
    557685    else
    … …  
    573701     */
    574702    *bufp = NULL;
     703
     704    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    575705}
    576706
    … …  
    611741static void crVBoxHGCMSingleRecv(CRConnection *conn, void *buf, unsigned int len)
    612742{
     743    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    613744    crVBoxHGCMReadExact(conn, buf, len);
    614 }
    615 
    616 static void crVBoxHGCMFree(CRConnection *conn, void *buf)
     745    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     746}
     747
     748static void _crVBoxHGCMFree(CRConnection *conn, void *buf)
    617749{
    618750    CRVBOXHGCMBUFFER *hgcm_buffer = (CRVBOXHGCMBUFFER *) buf - 1;
    … …  
    653785}
    654786
    655 static void crVBoxHGCMReceiveMessage(CRConnection *conn)
     787static void crVBoxHGCMFree(CRConnection *conn, void *buf)
     788{
     789    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     790    _crVBoxHGCMFree(conn, buf);
     791    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     792}
     793
     794static void _crVBoxHGCMReceiveMessage(CRConnection *conn)
    656795{
    657796    uint32_t len;
    … …  
    670809        CRASSERT(conn->buffer_size >= sizeof(CRMessageRedirPtr));
    671810
    672         hgcm_buffer = (CRVBOXHGCMBUFFER *) crVBoxHGCMAlloc( conn ) - 1;
     811        hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
    673812        hgcm_buffer->len = sizeof(CRMessageRedirPtr);
    674813
    … …  
    690829        {
    691830            /* put in pre-allocated buffer */
    692             hgcm_buffer = (CRVBOXHGCMBUFFER *) crVBoxHGCMAlloc( conn ) - 1;
     831            hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
    693832        }
    694833        else
    … …  
    728867        && cached_type != CR_MESSAGE_GATHER)
    729868    {
    730         crVBoxHGCMFree(conn, msg);
    731     }
    732 }
     869        _crVBoxHGCMFree(conn, msg);
     870    }
     871}
     872
     873static void crVBoxHGCMReceiveMessage(CRConnection *conn)
     874{
     875    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     876    _crVBoxHGCMReceiveMessage(conn);
     877    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
     878}
     879
    733880
    734881/*
    … …  
    737884static void crVBoxHGCMAccept( CRConnection *conn, const char *hostname, unsigned short port )
    738885{
     886    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    739887    CRASSERT(conn && conn->pHostBuffer);
    740888#ifdef IN_GUEST
    741889    CRASSERT(FALSE);
    742890#endif
     891    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    743892}
    744893
    … …  
    786935#ifdef RT_OS_WINDOWS
    787936    DWORD cbReturned;
     937
     938    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    788939
    789940    if (g_crvboxhgcm.hGuestDrv == INVALID_HANDLE_VALUE)
    … …  
    802953        {
    803954            crDebug("could not open VBox Guest Additions driver! rc = %d\n", GetLastError());
     955            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    804956            return FALSE;
    805957        }
    806958    }
    807959#else
     960    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    808961    if (g_crvboxhgcm.iGuestDrv == INVALID_HANDLE_VALUE)
    809962    {
    … …  
    812965        {
    813966            crDebug("could not open Guest Additions kernel module! rc = %d\n", errno);
     967            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    814968            return FALSE;
    815969        }
    … …  
    8471001            crDebug("HGCM connect was successful: client id =0x%x\n", conn->u32ClientID);
    8481002
     1003            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    8491004            return crVBoxHGCMSetVersion(conn, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR);
    8501005        }
    … …  
    8521007        {
    8531008            crDebug("HGCM connect failed with rc=0x%x\n", info.result);
     1009
     1010            VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    8541011            return FALSE;
    8551012        }
    … …  
    8621019        crDebug("IOCTL for HGCM connect failed with rc=0x%x\n", errno);
    8631020#endif
     1021        VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    8641022        return FALSE;
    8651023    }
    8661024
     1025    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    8671026    return TRUE;
    8681027
    … …  
    8841043    int i;
    8851044#endif
     1045
     1046    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    8861047
    8871048    if (conn->pHostBuffer)
    … …  
    9641125    }
    9651126#endif /* IN_GUEST */
     1127
     1128    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    9661129}
    9671130
    9681131static void crVBoxHGCMInstantReclaim(CRConnection *conn, CRMessage *mess)
    9691132{
    970     crVBoxHGCMFree(conn, mess);
     1133    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     1134    _crVBoxHGCMFree(conn, mess);
    9711135    CRASSERT(FALSE);
     1136    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    9721137}
    9731138
    9741139static void crVBoxHGCMHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len )
    9751140{
     1141    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    9761142    CRASSERT(FALSE);
     1143    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    9771144}
    9781145
    … …  
    9871154        return;
    9881155    }
     1156
     1157    VBOXCRHGSMIPROFILE_INIT();
    9891158
    9901159    g_crvboxhgcm.initialized = 1;
    … …  
    11421311    int32_t i;
    11431312
     1313    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
     1314
    11441315#ifdef IN_GUEST
    11451316    /* we're on guest side, poll host if it got something for us */
    … …  
    11671338        if (conn->cbBuffer>0)
    11681339        {
    1169             crVBoxHGCMReceiveMessage(conn);
    1170         }
    1171     }
     1340            _crVBoxHGCMReceiveMessage(conn);
     1341        }
     1342    }
     1343
     1344    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    11721345
    11731346    return 0;

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

    r33306 r33365  
    14571457
    14581458    if (!bHasHGSMI)
     1459    {
     1460#ifdef DEBUG_misha
     1461        AssertRelease(0);
     1462#endif
    14591463        return false;
     1464    }
     1465
     1466    return false;
    14601467
    14611468    g_crvboxhgsmi.recv_list = rfl;
    … …  
    15881595{
    15891596    int32_t i;
     1597    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    15901598
    15911599#ifdef IN_GUEST
    … …  
    16201628    }
    16211629
     1630    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    16221631    return 0;
    16231632}
    … …  
    16251634CRConnection** crVBoxHGSMIDump( int *num )
    16261635{
     1636    VBOXCRHGSMIPROFILE_FUNC_PROLOGUE();
    16271637    Assert(0);
    16281638    *num = g_crvboxhgsmi.num_conns;
    16291639
     1640    VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
    16301641    return g_crvboxhgsmi.conns;
    16311642}

  • trunk/src/VBox/Main/DisplayImpl.cpp

    r33146 r33365  
    29152915void Display::destructCrHgsmiData(void)
    29162916{
    2917     if (mhCrOglSvc)
    2918     {
    2919         VMMDev *pVMMDev = mParent->getVMMDev();
    2920         Assert(pVMMDev);
    2921         if (pVMMDev)
    2922         {
    2923             int rc = pVMMDev->hgcmHostSvcHandleDestroy(mhCrOglSvc);
    2924             AssertRC(rc);
    2925         }
    2926     }
     2917    mhCrOglSvc = NULL;
    29272918}
    29282919#endif

  • trunk/src/VBox/Main/hgcm/HGCM.cpp

    r33146 r33365  
    108108        uint32_t *m_paClientIds;
    109109
     110#ifdef VBOX_WITH_CRHGSMI
     111        uint32_t m_cHandleAcquires;
     112#endif
     113
    110114        HGCMSVCEXTHANDLE m_hExtension;
    111115
    … …  
    153157
    154158#ifdef VBOX_WITH_CRHGSMI
     159        int HandleAcquired();
     160        int HandleReleased();
    155161        int HostFastCallAsync (uint32_t u32Function, VBOXHGCMSVCPARM *pParm, PHGCMHOSTFASTCALLCB pfnCompletion, void *pvCompletion);
    156162#endif
    … …  
    230236    m_cClientsAllocated (0),
    231237    m_paClientIds (NULL),
     238#ifdef VBOX_WITH_CRHGSMI
     239    m_cHandleAcquires (0),
     240#endif
    232241    m_hExtension (NULL)
    233242{
    … …  
    11091118        }
    11101119
     1120#ifdef VBOX_WITH_CRHGSMI
     1121        /* @todo: could this actually happen that the service is destroyed on ReleaseService? */
     1122        HGCMService *pNextSvc = pSvc->m_pSvcNext;
     1123        while (pSvc->m_cHandleAcquires)
     1124        {
     1125            pSvc->HandleReleased ();
     1126            pSvc->ReleaseService ();
     1127        }
     1128        pSvc = pNextSvc;
     1129#else
    11111130        pSvc = pSvc->m_pSvcNext;
     1131#endif
    11121132    }
    11131133
    … …  
    15621582        pMsg->pfnCompletion (result, pMsg->u32Function, &pMsg->Param, pMsg->pvCompletion);
    15631583    }
     1584}
     1585
     1586int HGCMService::HandleAcquired()
     1587{
     1588    ++m_cHandleAcquires;
     1589    return VINF_SUCCESS;
     1590}
     1591
     1592int HGCMService::HandleReleased()
     1593{
     1594    Assert(m_cHandleAcquires);
     1595    if (m_cHandleAcquires)
     1596    {
     1597        --m_cHandleAcquires;
     1598        return VINF_SUCCESS;
     1599    }
     1600    return VERR_INVALID_STATE;
    15641601}
    15651602
    … …  
    18441881                if (RT_SUCCESS(rc))
    18451882                {
    1846                     pMsg->pService = pService;
     1883                    rc = pService->HandleAcquired ();
     1884                    if (RT_SUCCESS(rc))
     1885                    {
     1886                        pMsg->pService = pService;
     1887                    }
     1888                    else
     1889                    {
     1890                        pService->ReleaseService ();
     1891                    }
    18471892                }
    18481893            } break;
    … …  
    18561901                /* Resolve the service name to the pointer to service instance. */
    18571902
    1858                 pMsg->pService->ReleaseService ();
    1859 
    1860                 rc = VINF_SUCCESS;
     1903                rc = pMsg->pService->HandleReleased ();
     1904                if (RT_SUCCESS(rc))
     1905                {
     1906                    pMsg->pService->ReleaseService ();
     1907                }
    18611908            } break;
    18621909#endif
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