Changeset 10868 in vbox

Timestamp:

Jul 24, 2008 6:34:35 PM (16 years ago)

Author:

vboxsync

Message:

PerfAPI: Windows collector re-worked to extract raw counters via WMI. Filtering for queries added. Security initialization is added to svcmain to access perf enumerators.

Location:

trunk/src/VBox/Main

Files:

• MachineImpl.cpp (modified) (6 diffs)
• Makefile.kmk (modified) (1 diff)
• Performance.cpp (modified) (10 diffs)
• PerformanceImpl.cpp (modified) (10 diffs)
• include/MachineImpl.h (modified) (1 diff)
• include/Performance.h (modified) (5 diffs)
• linux/PerformanceLinux.cpp (modified) (5 diffs)
• testcase/Makefile.kmk (modified) (1 diff)
• testcase/tstAPI.cpp (modified) (8 diffs)
• win/PerformanceWin.cpp (modified) (5 diffs)
• win/svcmain.cpp (modified) (1 diff)

trunk/src/VBox/Main/MachineImpl.cpp

@@ -7361 +7361 @@
 
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
-void Machine::registerMetrics (PerformanceCollector *aCollector)
+void Machine::registerMetrics (PerformanceCollector *aCollector, RTPROCESS pid)
 {
     pm::MetricFactory *metricFactory = aCollector->getMetricFactory();
@@ -7367 +7367 @@
     pm::SubMetric *cpuLoadUser = new pm::SubMetric ("CPU/Load/User");
     pm::SubMetric *cpuLoadKernel = new pm::SubMetric ("CPU/Load/Kernel");
+    pm::SubMetric *ramUsageUsed  = new pm::SubMetric ("RAM/Usage/Used");
     /* Create and register base metrics */
     IUnknown *objptr;
@@ -7373 +7374 @@
     tmp.queryInterfaceTo (&objptr);
     pm::BaseMetric *cpuLoad =
-        metricFactory->createMachineCpuLoad (objptr, mData->mSession.mPid,
+        metricFactory->createMachineCpuLoad (objptr, pid,
                                              cpuLoadUser, cpuLoadKernel);
     aCollector->registerBaseMetric (cpuLoad);
+    pm::BaseMetric *ramUsage =
+        metricFactory->createMachineRamUsage (objptr, pid, ramUsageUsed);
+    aCollector->registerBaseMetric (ramUsage);
 
     aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadUser, 0));
@@ -7391 +7395 @@
     aCollector->registerMetric (new pm::Metric(cpuLoad, cpuLoadKernel,
                                                 new pm::AggregateMax()));
+
+    aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed, 0));
+    aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed,
+                                               new pm::AggregateAvg()));
+    aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed,
+                                               new pm::AggregateMin()));
+    aCollector->registerMetric (new pm::Metric(ramUsage, ramUsageUsed,
+                                               new pm::AggregateMax()));
 };
 
@@ -7614 +7626 @@
     }
 
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    registerMetrics (mParent->performanceCollector(), mData->mSession.mPid);
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
     /* Confirm a successful initialization when it's the case */
     autoInitSpan.setSucceeded();
@@ -7687 +7703 @@
     AutoMultiWriteLock2 alock (mParent, this);
 
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
+    unregisterMetrics (mParent->performanceCollector());
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
+
     MachineState_T lastState = mData->mMachineState;
 

trunk/src/VBox/Main/Makefile.kmk

@@ -273 +273 @@
 VBoxSVC_SOURCES.solaris += solaris/PerformanceSolaris.cpp
 VBoxSVC_SOURCES.win     +=     win/PerformanceWin.cpp
-VBoxSVC_LDFLAGS.win     += PDH.LIB
+VBoxSVC_LDFLAGS.win     += wbemuuid.lib
 endif
 

trunk/src/VBox/Main/Performance.cpp

@@ -22 +22 @@
  */
 
+/*
+ * @todo list:
+ *
+ * 1) Solaris backend
+ * 2) Linux backend
+ * 3) Detection of erroneous metric names
+ * 4) Min/max ranges for metrics
+ * 5) Darwin backend
+ * 6) [OS/2 backend]
+ */
+
 #include <VBox/com/array.h>
 #include <VBox/com/ptr.h>
@@ -29 +40 @@
 #include <iprt/mem.h>
 
+#include "Logging.h"
 #include "Performance.h"
 
@@ -38 +50 @@
 {
     Assert(mHAL);
-    return new HostCpuLoad(mHAL, object, user, kernel, idle);
+    return new HostCpuLoadRaw(mHAL, object, user, kernel, idle);
 }
 BaseMetric *MetricFactory::createHostCpuMHz(ComPtr<IUnknown> object, SubMetric *mhz)
@@ -53 +65 @@
 {
     Assert(mHAL);
-    return new MachineCpuLoad(mHAL, object, process, user, kernel);
+    return new MachineCpuLoadRaw(mHAL, object, process, user, kernel);
 }
 BaseMetric *MetricFactory::createMachineRamUsage(ComPtr<IUnknown> object, RTPROCESS process, SubMetric *used)
@@ -73 +85 @@
 }
 
-int CollectorHAL::getRawHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
+int CollectorHAL::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
 {
     return E_NOTIMPL;
 }
 
-int CollectorHAL::getRawProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
+int CollectorHAL::getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total)
 {
     return E_NOTIMPL;
@@ -90 +102 @@
         {
             mLastSampleTaken = nowAt;
+            LogFlowThisFunc (("Collecting data for obj(%p)...\n", mObject));
             collect();
         }
     }
 }
+
+/*bool BaseMetric::associatedWith(ComPtr<IUnknown> object)
+{
+    LogFlowThisFunc (("mObject(%p) == object(%p) is %s.\n", mObject, object, mObject == object ? "true" : "false"));
+    return mObject == object;
+}*/
 
 void HostCpuLoad::init(unsigned long period, unsigned long length)
@@ -118 +137 @@
 void HostCpuLoadRaw::collect()
 {
-    unsigned long user, kernel, idle;
-    unsigned long userDiff, kernelDiff, idleDiff, totalDiff;
+    uint64_t user, kernel, idle;
+    uint64_t userDiff, kernelDiff, idleDiff, totalDiff;
 
     int rc = mHAL->getRawHostCpuLoad(&user, &kernel, &idle);
@@ -128 +147 @@
         idleDiff   = idle   - mIdlePrev;
         totalDiff  = userDiff + kernelDiff + idleDiff;
-    
-        mUser->put(PM_CPU_LOAD_MULTIPLIER * userDiff / totalDiff);
-        mKernel->put(PM_CPU_LOAD_MULTIPLIER * kernelDiff / totalDiff);
-        mIdle->put(PM_CPU_LOAD_MULTIPLIER * idleDiff / totalDiff);
+
+        if (totalDiff == 0)
+        {
+            /* This is only possible if none of counters has changed! */
+            LogFlowThisFunc (("Impossible! User, kernel and idle raw "
+                "counters has not changed since last sample.\n" ));
+            mUser->put(0);
+            mKernel->put(0);
+            mIdle->put(0);
+        }
+        else
+        {
+            mUser->put((unsigned long)(PM_CPU_LOAD_MULTIPLIER * userDiff / totalDiff));
+            mKernel->put((unsigned long)(PM_CPU_LOAD_MULTIPLIER * kernelDiff / totalDiff));
+            mIdle->put((unsigned long)(PM_CPU_LOAD_MULTIPLIER * idleDiff / totalDiff));
+        }
     
         mUserPrev   = user;
@@ -198 +229 @@
 void MachineCpuLoadRaw::collect()
 {
-    unsigned long hostUser, hostKernel, hostIdle, hostTotal;
-    unsigned long processUser, processKernel;
-
-    int rc = mHAL->getRawHostCpuLoad(&hostUser, &hostKernel, &hostIdle);
-    if (RT_SUCCESS(rc))
-    {
-        hostTotal = hostUser + hostKernel + hostIdle;
+    uint64_t processUser, processKernel, hostTotal;
+
+    int rc = mHAL->getRawProcessCpuLoad(mProcess, &processUser, &processKernel, &hostTotal);
+    if (RT_SUCCESS(rc))
+    {
+        if (hostTotal == mHostTotalPrev)
+        {
+            /* Nearly impossible, but... */
+            mUser->put(0);
+            mKernel->put(0);
+        }
+        else
+        {
+            mUser->put((unsigned long)(PM_CPU_LOAD_MULTIPLIER * (processUser - mProcessUserPrev) / (hostTotal - mHostTotalPrev)));
+            mKernel->put((unsigned long)(PM_CPU_LOAD_MULTIPLIER * (processKernel - mProcessKernelPrev ) / (hostTotal - mHostTotalPrev)));
+        }
     
-        rc = mHAL->getRawProcessCpuLoad(mProcess, &processUser, &processKernel);
-        AssertRC(rc);
-        if (RT_SUCCESS(rc))
-        {
-            mUser->put(PM_CPU_LOAD_MULTIPLIER * (processUser - mProcessUserPrev) / (hostTotal - mHostTotalPrev));
-            mUser->put(PM_CPU_LOAD_MULTIPLIER * (processKernel - mProcessKernelPrev ) / (hostTotal - mHostTotalPrev));
-        
-            mHostTotalPrev     = hostTotal;
-            mProcessUserPrev   = processUser;
-            mProcessKernelPrev = processKernel;
-        }
+        mHostTotalPrev     = hostTotal;
+        mProcessUserPrev   = processUser;
+        mProcessKernelPrev = processKernel;
     }
 }
@@ -270 +302 @@
         // Copy the wrapped part
         if (mEnd)
-            memcpy(data + mEnd, mData, mEnd * sizeof(unsigned long));
+            memcpy(data + (mLength - mEnd), mData, mEnd * sizeof(unsigned long));
     }
     else

trunk/src/VBox/Main/PerformanceImpl.cpp

@@ -202 +202 @@
                                   ComSafeArrayOut (IPerformanceMetric *, outMetrics))
 {
+    LogFlowThisFuncEnter();
     //LogFlowThisFunc (("mState=%d, mType=%d\n", mState, mType));
 
@@ -234 +235 @@
     }
     retMetrics.detachTo (ComSafeArrayOutArg(outMetrics));
+    LogFlowThisFuncLeave();
     return rc;
 }
@@ -271 +273 @@
                        ComSafeArrayInArg (objects));
 
-    /// @todo (r=dmik) why read lock below? individual elements get modified!
-
-    AutoReadLock alock (this); /* Need a read lock to access mBaseMetrics */
-                               /* Write lock is not needed since we are */
-                               /* fiddling with enable bit only. No harm */
-                               /* the readers may see it differently. */
+    AutoWriteLock alock (this); /* Write lock is not needed atm since we are */
+                                /* fiddling with enable bit only, but we */
+                                /* care for those who come next :-). */
 
     BaseMetricList::iterator it;
@@ -296 +295 @@
                        ComSafeArrayInArg (objects));
 
-    /// @todo (r=dmik) why read lock below? individual elements get modified!
-
-    AutoReadLock alock (this); /* Need a read lock to access mBaseMetrics */
-                               /* Write lock is not needed since we are */
-                               /* fiddling with enable bit only. No harm */
-                               /* the readers may see it differently. */
+    AutoWriteLock alock (this); /* Write lock is not needed atm since we are */
+                                /* fiddling with enable bit only, but we */
+                                /* care for those who come next :-). */
 
     BaseMetricList::iterator it;
@@ -323 +319 @@
     CheckComRCReturnRC (autoCaller.rc());
 
+    pm::Filter filter (ComSafeArrayInArg (metricNames),
+                       ComSafeArrayInArg (objects));
+
     AutoReadLock alock (this);
 
-    int i;
-    MetricList::const_iterator it;
     /* Let's compute the size of the resulting flat array */
-    size_t flatSize = 0, numberOfMetrics = 0;
+    size_t flatSize = 0;
+    MetricList filteredMetrics;
+    MetricList::iterator it;
     for (it = m.metrics.begin(); it != m.metrics.end(); ++it)
-    {
-        /* @todo Filtering goes here! */
-        flatSize += (*it)->getLength();
-        ++numberOfMetrics;
-    }
+        if (filter.match ((*it)->getObject(), (*it)->getName()))
+        {
+            filteredMetrics.push_back (*it);
+            flatSize += (*it)->getLength();
+        }
+
+    int i = 0;
     size_t flatIndex = 0;
+    size_t numberOfMetrics = filteredMetrics.size();
     com::SafeArray <BSTR> retNames (numberOfMetrics);
     com::SafeIfaceArray <IUnknown> retObjects (numberOfMetrics);
@@ -342 +344 @@
     com::SafeArray <LONG> retData (flatSize);
 
-    for (it = m.metrics.begin(), i = 0; it != m.metrics.end(); ++it)
+    for (it = filteredMetrics.begin(); it != filteredMetrics.end(); ++it, ++i)
     {
         /* @todo Filtering goes here! */
@@ -354 +356 @@
         retLengths[i] = length;
         retIndices[i] = flatIndex;
-        ++i;
         flatIndex += length;
     }
@@ -371 +372 @@
 void PerformanceCollector::registerBaseMetric (pm::BaseMetric *baseMetric)
 {
+    LogFlowThisFuncEnter();
     AutoCaller autoCaller (this);
     if (!SUCCEEDED (autoCaller.rc())) return;
 
     AutoWriteLock alock (this);
+    LogFlowThisFunc (("obj=%p name=%s\n", baseMetric->getObject(), baseMetric->getName()));
     m.baseMetrics.push_back (baseMetric);
+    LogFlowThisFuncLeave();
 }
 
 void PerformanceCollector::registerMetric (pm::Metric *metric)
 {
+    LogFlowThisFuncEnter();
     AutoCaller autoCaller (this);
     if (!SUCCEEDED (autoCaller.rc())) return;
 
     AutoWriteLock alock (this);
+    LogFlowThisFunc (("obj=%p name=%s\n", metric->getObject(), metric->getName()));
     m.metrics.push_back (metric);
+    LogFlowThisFuncLeave();
 }
 
 void PerformanceCollector::unregisterBaseMetricsFor (const ComPtr <IUnknown> &aObject)
 {
+    LogFlowThisFuncEnter();
     AutoCaller autoCaller (this);
     if (!SUCCEEDED (autoCaller.rc())) return;
 
     AutoWriteLock alock (this);
-    std::remove_if (m.baseMetrics.begin(), m.baseMetrics.end(),
-                    std::bind2nd (std::mem_fun (&pm::BaseMetric::associatedWith),
-                                  aObject));
+    LogFlowThisFunc (("before remove_if: m.baseMetrics.size()=%d, obj=%p\n", m.baseMetrics.size(), aObject));
+    BaseMetricList::iterator it = std::remove_if (
+        m.baseMetrics.begin(), m.baseMetrics.end(), std::bind2nd (
+            std::mem_fun (&pm::BaseMetric::associatedWith), aObject));
+    m.baseMetrics.erase(it, m.baseMetrics.end());
+    LogFlowThisFunc (("after remove_if: m.baseMetrics.size()=%d\n", m.baseMetrics.size()));
+    LogFlowThisFuncLeave();
 }
 
 void PerformanceCollector::unregisterMetricsFor (const ComPtr <IUnknown> &aObject)
 {
+    LogFlowThisFuncEnter();
     AutoCaller autoCaller (this);
     if (!SUCCEEDED (autoCaller.rc())) return;
 
     AutoWriteLock alock (this);
-    std::remove_if (m.metrics.begin(), m.metrics.end(),
-                    std::bind2nd (std::mem_fun (&pm::Metric::associatedWith),
-                                  aObject));
+    LogFlowThisFunc (("obj=%p\n", aObject));
+    MetricList::iterator it = std::remove_if (
+        m.metrics.begin(), m.metrics.end(), std::bind2nd (
+            std::mem_fun (&pm::Metric::associatedWith), aObject));
+    m.metrics.erase(it, m.metrics.end());
+    LogFlowThisFuncLeave();
 }
 
@@ -427 +443 @@
 void PerformanceCollector::samplerCallback()
 {
+    LogFlowThisFuncEnter();
     AutoWriteLock alock (this);
 
@@ -433 +450 @@
                    std::bind2nd (std::mem_fun (&pm::BaseMetric::collectorBeat),
                                  timestamp));
+    LogFlowThisFuncLeave();
 }
 

trunk/src/VBox/Main/include/MachineImpl.h

@@ -719 +719 @@
 
 #ifdef VBOX_WITH_RESOURCE_USAGE_API
-    void registerMetrics (PerformanceCollector *aCollector);
+    void registerMetrics (PerformanceCollector *aCollector, RTPROCESS pid);
     void unregisterMetrics (PerformanceCollector *aCollector);
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */

trunk/src/VBox/Main/include/Performance.h

@@ -72 +72 @@
         virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used) = 0;
 
-        virtual int getRawHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle);
-        virtual int getRawProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel);
+        virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
+        virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
     };
 
@@ -137 +137 @@
         void collect();
     private:
-        unsigned long mUserPrev;
-        unsigned long mKernelPrev;
-        unsigned long mIdlePrev;
+        uint64_t mUserPrev;
+        uint64_t mKernelPrev;
+        uint64_t mIdlePrev;
     };
 
@@ -199 +199 @@
         void collect();
     private:
-        unsigned long mHostTotalPrev;
-        unsigned long mProcessUserPrev;
-        unsigned long mProcessKernelPrev;
+        uint64_t mHostTotalPrev;
+        uint64_t mProcessUserPrev;
+        uint64_t mProcessKernelPrev;
     };
 
@@ -305 +305 @@
     public:
         MetricFactorySolaris();
-        virtual BaseMetric   *createHostCpuLoad(ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle);
-        virtual BaseMetric   *createMachineCpuLoad(ComPtr<IUnknown> object, RTPROCESS process, SubMetric *user, SubMetric *kernel);
+        // Nothing else to do here (yet)
     };
 
@@ -313 +312 @@
     public:
         MetricFactoryLinux();
-        virtual BaseMetric   *createHostCpuLoad(ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle);
-        virtual BaseMetric   *createMachineCpuLoad(ComPtr<IUnknown> object, RTPROCESS process, SubMetric *user, SubMetric *kernel);
+        // Nothing else to do here (yet)
     };
 

trunk/src/VBox/Main/linux/PerformanceLinux.cpp

@@ -37 +37 @@
     virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
 
-    virtual int getRawHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle);
-    virtual int getRawProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel);
+    virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
+    virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
 };
 
@@ -49 +49 @@
 }
 
-BaseMetric *MetricFactoryLinux::createHostCpuLoad(ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
-{
-    Assert(mHAL);
-    return new HostCpuLoadRaw(mHAL, object, user, kernel, idle);
-}
-
-BaseMetric *MetricFactoryLinux::createMachineCpuLoad(ComPtr<IUnknown> object, RTPROCESS process, SubMetric *user, SubMetric *kernel)
-{
-    Assert(mHAL);
-    return new MachineCpuLoadRaw(mHAL, object, process, user, kernel);
-}
-
 // Collector HAL for Linux
 
-int CollectorLinux::getRawHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
+int CollectorLinux::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
 {
     int rc = VINF_SUCCESS;
-    unsigned long nice;
+    unsigned long u32user, u32nice, u32kernel, u32idle;
     FILE *f = fopen("/proc/stat", "r");
 
     if (f)
     {
-        if (fscanf(f, "cpu %lu %lu %lu %lu", user, &nice, kernel, idle) == 4)
-            *user += nice;
+        if (fscanf(f, "cpu %lu %lu %lu %lu", &u32user, &u32nice, &u32kernel, &u32idle) == 4)
+        {
+            *user   = (uint64_t)u32user + u32nice;
+            *kernel = u32kernel;
+            *idle   = u32idle;
+        }
         else
             rc = VERR_FILE_IO_ERROR;
@@ -83 +75 @@
 }
 
-int CollectorLinux::getRawProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
+int CollectorLinux::getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total)
 {
     int rc = VINF_SUCCESS;
@@ -91 +83 @@
     int iTmp;
     unsigned uTmp;
-    unsigned long ulTmp;
+    unsigned long ulTmp, u32user, u32kernel;
     char buf[80]; /* @todo: this should be tied to max allowed proc name. */
+
+    uint64_t uHostUser, uHostKernel, uHostIdle;
+    rc = getRawHostCpuLoad(uHostUser, uHostKernel, uHostIdle);
+    if (RT_FAILURE(rc))
+        return rc;
+    *total = (uint64_t)uHostUser + uHostKernel + uHostIdle;
 
     RTStrAPrintf(&pszName, "/proc/%d/stat", process);
@@ -103 +101 @@
         if (fscanf(f, "%d %s %c %d %d %d %d %d %u %lu %lu %lu %lu %lu %lu",
                    &pid2, buf, &c, &iTmp, &iTmp, &iTmp, &iTmp, &iTmp, &uTmp,
-                   &ulTmp, &ulTmp, &ulTmp, &ulTmp, user, kernel) == 15)
+                   &ulTmp, &ulTmp, &ulTmp, &ulTmp, &u32user, &u32kernel) == 15)
         {
             Assert((pid_t)process == pid2);
+            *user = u32user;
+            *kernel = u32kernel;
         }
         else

trunk/src/VBox/Main/testcase/Makefile.kmk

@@ -68 +68 @@
 tstAPI_DEPS     = $(VBOX_PATH_SDK)/include/VirtualBox_XPCOM.h
 endif
+ifdef VBOX_WITH_RESOURCE_USAGE_API
+tstAPI_DEFS += VBOX_WITH_RESOURCE_USAGE_API
+endif
 
 

trunk/src/VBox/Main/testcase/tstAPI.cpp

@@ -926 +926 @@
 #endif
 
-#if 1
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
     do {
         // Get collector
@@ -948 +948 @@
         printf ("Getting a machine object named '%ls'...\n", name.raw());
         CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
-
-        // Setup base metrics
-        com::SafeIfaceArray<IUnknown> objects(2);
-        host.queryInterfaceTo(&objects[0]);
-        machine.queryInterfaceTo(&objects[1]);
-        CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
-                                                   ComSafeArrayAsInParam(objects), 1u, 10u) );
 
         // Open session
@@ -969 +962 @@
         CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
 
+        // Setup base metrics
+        // Note that one needs to set up metrics after a session is open for a machine.
+        com::SafeIfaceArray<IUnknown> objects(2);
+        host.queryInterfaceTo(&objects[0]);
+        sessionMachine.queryInterfaceTo(&objects[1]);
+        CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
+                                                   ComSafeArrayAsInParam(objects), 1u, 10u) );
+
         // Get console
         ComPtr <IConsole> console;
@@ -984 +985 @@
         CHECK_RC (console->Pause());
 
-        RTThreadSleep(3000); // Sleep for 10 seconds
+        RTThreadSleep(10000); // Sleep for 10 seconds
 
         printf("Metrics collected with DSL machine paused: ---------------------\n");
@@ -997 +998 @@
         session->Close();
     } while (false);
-#endif
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */
 
     printf ("Press enter to release Session and VirtualBox instances...");
@@ -1017 +1018 @@
 }
 
-#if 1
+#ifdef VBOX_WITH_RESOURCE_USAGE_API
 void queryMetrics (ComPtr <IPerformanceCollector> collector,
                    ComSafeArrayIn (IUnknown *, objects))
@@ -1023 +1024 @@
     HRESULT rc;
 
-    Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
+    //Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
+    Bstr metricNames[] = { L"*" };
     com::SafeArray<BSTR> metrics (1);
     metricNames[0].cloneTo (&metrics [0]);
@@ -1063 +1065 @@
     }
 }
-#endif
+#endif /* VBOX_WITH_RESOURCE_USAGE_API */

trunk/src/VBox/Main/win/PerformanceWin.cpp

@@ -22 +22 @@
  */
 
-#include <pdh.h>
-#include <pdhmsg.h>
+#include <Wbemidl.h>
 #include <iprt/err.h>
 
+#include "Logging.h"
 #include "Performance.h"
-
-//#pragma comment(lib, "pdh.lib")
 
 namespace pm {
@@ -44 +42 @@
     virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
 
+    virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
+    virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
 private:
-    int         convertPdhStatusToRTErr(PDH_STATUS pdhStatus);
-    HCOUNTER    addCounter(HQUERY hQuery, LPCTSTR name);
-    int         getCounterValue(HCOUNTER hCounter, DWORD flags, unsigned long *value);
-
-    HQUERY      mHostCpuLoadQuery;
-    HCOUNTER    mHostCpuLoadUserCounter;
-    HCOUNTER    mHostCpuLoadKernelCounter;
-    HCOUNTER    mHostCpuLoadIdleCounter;
+    long        getPropertyHandle(IWbemObjectAccess *objAccess, LPCWSTR name);
+    int         getObjects(IWbemHiPerfEnum *mEnum, IWbemObjectAccess ***objArray, DWORD *numReturned);
+
+    IWbemRefresher     *mRefresher;
+    IWbemServices      *mNameSpace;
+
+    IWbemHiPerfEnum    *mEnumProcessor;
+    long               mEnumProcessorID;
+    long               mHostCpuLoadNameHandle;
+    long               mHostCpuLoadUserHandle;
+    long               mHostCpuLoadKernelHandle;
+    long               mHostCpuLoadIdleHandle;
+
+    IWbemHiPerfEnum    *mEnumProcess;
+    long               mEnumProcessID;
+    long               mProcessPIDHandle;
+    long               mProcessCpuLoadUserHandle;
+    long               mProcessCpuLoadKernelHandle;
+    long               mProcessCpuLoadTimestampHandle;
+    long               mProcessMemoryUsedHandle;
 };
 
@@ -61 +73 @@
 }
 
-CollectorWin::CollectorWin() : mHostCpuLoadQuery(0)
-{
-    PDH_STATUS pdhStatus;
-
-    pdhStatus = PdhOpenQuery(NULL, NULL, &mHostCpuLoadQuery);
-    if (pdhStatus != ERROR_SUCCESS)
+CollectorWin::CollectorWin() : mRefresher(0), mNameSpace(0), mEnumProcessor(0), mEnumProcess(0)
+{
+    HRESULT                 hr = S_OK;
+    IWbemConfigureRefresher *pConfig = NULL;
+    IWbemLocator            *pWbemLocator = NULL;
+    BSTR                    bstrNameSpace = NULL;
+
+    if (SUCCEEDED (hr = CoCreateInstance(
+        CLSID_WbemLocator, 
+        NULL,
+        CLSCTX_INPROC_SERVER,
+        IID_IWbemLocator,
+        (void**) &pWbemLocator)))
+    {
+        // Connect to the desired namespace.
+        bstrNameSpace = SysAllocString(L"\\\\.\\root\\cimv2");
+        if (bstrNameSpace)
+        {
+            hr = pWbemLocator->ConnectServer(
+                bstrNameSpace,
+                NULL, // User name
+                NULL, // Password
+                NULL, // Locale
+                0L,   // Security flags
+                NULL, // Authority
+                NULL, // Wbem context
+                &mNameSpace);
+        }
+        pWbemLocator->Release();
+        SysFreeString(bstrNameSpace);
+    }
+
+    if (FAILED (hr)) {
+        Log (("Failed to get namespace. HR = %x\n", hr));
         return;
-
-    mHostCpuLoadUserCounter   = addCounter (mHostCpuLoadQuery,
-                                            L"\\Processor(_Total)\\% User Time");
-    mHostCpuLoadKernelCounter = addCounter (mHostCpuLoadQuery,
-                                            L"\\Processor(_Total)\\% Privileged Time");
-    mHostCpuLoadIdleCounter   = addCounter (mHostCpuLoadQuery,
-                                            L"\\Processor(_Total)\\% Idle Time");
+    }
+
+    if (SUCCEEDED (hr = CoCreateInstance(
+        CLSID_WbemRefresher,
+        NULL,
+        CLSCTX_INPROC_SERVER,
+        IID_IWbemRefresher, 
+        (void**) &mRefresher)))
+    {
+        if (SUCCEEDED (hr = mRefresher->QueryInterface(
+            IID_IWbemConfigureRefresher,
+            (void **)&pConfig)))
+        {
+            // Add an enumerator to the refresher.
+            if (SUCCEEDED (hr = pConfig->AddEnum(
+                mNameSpace, 
+                L"Win32_PerfRawData_PerfOS_Processor", 
+                0, 
+                NULL, 
+                &mEnumProcessor, 
+                &mEnumProcessorID)))
+            {
+                hr = pConfig->AddEnum(
+                    mNameSpace,
+                    L"Win32_PerfRawData_PerfProc_Process", 
+                    0, 
+                    NULL, 
+                    &mEnumProcess, 
+                    &mEnumProcessID);
+            }
+            pConfig->Release();
+        }
+    }
+
+
+    if (FAILED (hr)) {
+        Log (("Failed to add enumerators. HR = %x\n", hr));
+        return;
+    }
+
+    // Retrieve property handles
+
+    if (FAILED (hr = mRefresher->Refresh(0L)))
+    {
+        Log (("Refresher failed. HR = %x\n", hr));
+        return;
+    }
+
+    IWbemObjectAccess       **apEnumAccess = NULL;
+    DWORD                   dwNumReturned = 0;
+
+    if (RT_FAILURE(getObjects(mEnumProcessor, &apEnumAccess, &dwNumReturned)))
+        return;
+
+    mHostCpuLoadNameHandle   = getPropertyHandle(apEnumAccess[0], L"Name");
+    mHostCpuLoadUserHandle   = getPropertyHandle(apEnumAccess[0], L"PercentUserTime");
+    mHostCpuLoadKernelHandle = getPropertyHandle(apEnumAccess[0], L"PercentPrivilegedTime");
+    mHostCpuLoadIdleHandle   = getPropertyHandle(apEnumAccess[0], L"PercentProcessorTime");
+
+    delete [] apEnumAccess;
+
+    if (RT_FAILURE(getObjects(mEnumProcess, &apEnumAccess, &dwNumReturned)))
+        return;
+
+    mProcessPIDHandle              = getPropertyHandle(apEnumAccess[0], L"IDProcess");
+    mProcessCpuLoadUserHandle      = getPropertyHandle(apEnumAccess[0], L"PercentUserTime");
+    mProcessCpuLoadKernelHandle    = getPropertyHandle(apEnumAccess[0], L"PercentPrivilegedTime");
+    mProcessCpuLoadTimestampHandle = getPropertyHandle(apEnumAccess[0], L"Timestamp_Sys100NS");
+    mProcessMemoryUsedHandle       = getPropertyHandle(apEnumAccess[0], L"WorkingSet");
+
+    delete [] apEnumAccess;
 }
 
 CollectorWin::~CollectorWin()
 {
-    if (mHostCpuLoadQuery)
-        PdhCloseQuery (mHostCpuLoadQuery);
-}
-
-int CollectorWin::convertPdhStatusToRTErr(PDH_STATUS pdhStatus)
-{
-    switch (pdhStatus)
-    {
-        case PDH_INVALID_ARGUMENT:
-            return VERR_INVALID_PARAMETER;
-        case PDH_INVALID_HANDLE:
-            return VERR_INVALID_HANDLE;
-    }
-
-    return RTErrConvertFromWin32(pdhStatus);
-}
-
-HCOUNTER CollectorWin::addCounter(HQUERY hQuery, LPCTSTR name)
-{
-    PDH_STATUS pdhStatus;
-    HCOUNTER   hCounter;
-
-    pdhStatus = PdhAddCounter (hQuery, name, 0, &hCounter);
-    if (pdhStatus != ERROR_SUCCESS)
-        return 0;
-    return hCounter;
-}
-
-int CollectorWin::getCounterValue(HCOUNTER hCounter, DWORD flags, unsigned long *value)
-{
-    PDH_STATUS           pdhStatus;
-    PDH_FMT_COUNTERVALUE fmtValue;
-
-    pdhStatus = PdhGetFormattedCounterValue (hCounter,
-                                             PDH_FMT_LONG | flags,
-                                             NULL,
-                                             &fmtValue);
-    if (pdhStatus != ERROR_SUCCESS)
-        return convertPdhStatusToRTErr(pdhStatus);
-    
-    *value = fmtValue.longValue;
-    
+    if (NULL != mNameSpace)
+    {
+        mNameSpace->Release();
+    }
+    if (NULL != mEnumProcessor)
+    {
+        mEnumProcessor->Release();
+    }
+    if (NULL != mEnumProcess)
+    {
+        mEnumProcess->Release();
+    }
+    if (NULL != mRefresher)
+    {
+        mRefresher->Release();
+    }
+}
+
+long CollectorWin::getPropertyHandle(IWbemObjectAccess *objAccess, LPCWSTR name)
+{
+    HRESULT hr;
+    CIMTYPE tmp;
+    long    handle;
+
+    if (FAILED (hr = objAccess->GetPropertyHandle(
+        name,
+        &tmp,
+        &handle)))
+    {
+        Log (("Failed to get property handle for '%ls'. HR = %x\n", name, hr));
+        return 0;   /// @todo use throw
+    }
+
+    return handle;
+}
+
+int CollectorWin::getObjects(IWbemHiPerfEnum *mEnum, IWbemObjectAccess ***objArray, DWORD *numReturned)
+{
+    HRESULT hr;
+    DWORD   dwNumObjects = 0;
+
+    *objArray    = NULL;
+    *numReturned = 0;
+    hr = mEnum->GetObjects(0L, dwNumObjects, *objArray, numReturned);
+
+    // If the buffer was not big enough,
+    // allocate a bigger buffer and retry.
+    if (hr == WBEM_E_BUFFER_TOO_SMALL 
+        && *numReturned > dwNumObjects)
+    {
+        *objArray = new IWbemObjectAccess*[*numReturned];
+        if (NULL == *objArray)
+        {
+            Log (("Could not allocate enumerator access objects\n"));
+            return VERR_NO_MEMORY;
+        }
+
+        SecureZeroMemory(*objArray,
+            *numReturned*sizeof(IWbemObjectAccess*));
+        dwNumObjects = *numReturned;
+
+        if (FAILED (hr = mEnum->GetObjects(0L, 
+            dwNumObjects, *objArray, numReturned)))
+        {
+            delete [] objArray;
+            Log (("Failed to get objects from enumerator. HR = %x\n", hr));
+            return VERR_INTERNAL_ERROR;
+        }
+    }
+    else if (FAILED (hr))
+    {
+        Log (("Failed to get objects from enumerator. HR = %x\n", hr));
+        return VERR_INTERNAL_ERROR;
+    }
+
     return VINF_SUCCESS;
 }
@@ -126 +263 @@
 int CollectorWin::getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
 {
-    int         rc;
-    PDH_STATUS  pdhStatus;
-
-    pdhStatus = PdhCollectQueryData (mHostCpuLoadQuery);
-    if (pdhStatus != ERROR_SUCCESS)
-        return convertPdhStatusToRTErr(pdhStatus);
-
-    rc = getCounterValue (mHostCpuLoadUserCounter, PDH_FMT_1000, user);
-    AssertRCReturn(rc, rc);
-
-    rc = getCounterValue (mHostCpuLoadKernelCounter, PDH_FMT_1000, kernel);
-    AssertRCReturn(rc, rc);
-
-    rc = getCounterValue (mHostCpuLoadIdleCounter, PDH_FMT_1000, idle);
-    AssertRCReturn(rc, rc);
-
-    return VINF_SUCCESS;
+    return VERR_NOT_IMPLEMENTED;
+}
+
+int CollectorWin::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
+{
+    HRESULT hr;
+    IWbemObjectAccess       **apEnumAccess = NULL;
+    DWORD                   dwNumReturned = 0;
+
+    LogFlowThisFuncEnter();
+
+    if (FAILED (hr = mRefresher->Refresh(0L)))
+    {
+        Log (("Refresher failed. HR = %x\n", hr));
+        return VERR_INTERNAL_ERROR;
+    }
+
+    int rc = getObjects(mEnumProcessor, &apEnumAccess, &dwNumReturned);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    for (unsigned i = 0; i < dwNumReturned; i++)
+    {
+        long  bytesRead = 0;
+        WCHAR tmpBuf[200];
+
+        if (FAILED (hr = apEnumAccess[i]->ReadPropertyValue(
+            mHostCpuLoadNameHandle,
+            sizeof(tmpBuf),
+            &bytesRead,
+            (byte*)tmpBuf)))
+        {
+            Log (("Failed to read 'Name' property. HR = %x\n", hr));
+            return VERR_INTERNAL_ERROR;
+        }
+        if (wcscmp(tmpBuf, L"_Total") == 0)
+        {
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mHostCpuLoadUserHandle,
+                user)))
+            {
+            Log (("Failed to read 'PercentUserTime' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mHostCpuLoadKernelHandle,
+                kernel)))
+            {
+            Log (("Failed to read 'PercentPrivilegedTime' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mHostCpuLoadIdleHandle,
+                idle)))
+            {
+            Log (("Failed to read 'PercentProcessorTime' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            rc = VINF_SUCCESS;
+        }
+        apEnumAccess[i]->Release();
+        apEnumAccess[i] = NULL;
+    }
+    delete [] apEnumAccess;
+
+    LogFlowThisFunc(("user=%lu kernel=%lu idle=%lu\n", *user, *kernel, *idle));
+    LogFlowThisFuncLeave();
+
+    return rc;
 }
 
 int CollectorWin::getHostCpuMHz(unsigned long *mhz)
 {
-    return E_NOTIMPL;
+    return VERR_NOT_IMPLEMENTED;
 }
 
@@ -169 +358 @@
 int CollectorWin::getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
 {
-    return E_NOTIMPL;
+    return VERR_NOT_IMPLEMENTED;
+}
+
+int CollectorWin::getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total)
+{
+    HRESULT hr;
+    IWbemObjectAccess       **apEnumAccess = NULL;
+    DWORD                   dwNumReturned = 0;
+
+    LogFlowThisFuncEnter();
+
+    if (FAILED (hr = mRefresher->Refresh(0L)))
+    {
+        Log (("Refresher failed. HR = %x\n", hr));
+        return VERR_INTERNAL_ERROR;
+    }
+
+    int rc = getObjects(mEnumProcess, &apEnumAccess, &dwNumReturned);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = VERR_NOT_FOUND;
+
+    for (unsigned i = 0; i < dwNumReturned; i++)
+    {
+        DWORD dwIDProcess;
+
+        if (FAILED (hr = apEnumAccess[i]->ReadDWORD(
+            mProcessPIDHandle,
+            &dwIDProcess)))
+        {
+            Log (("Failed to read 'IDProcess' property. HR = %x\n", hr));
+            return VERR_INTERNAL_ERROR;
+        }
+        LogFlowThisFunc (("Matching machine process %x against %x...\n", process, dwIDProcess));
+        if (dwIDProcess == process)
+        {
+            LogFlowThisFunc (("Match found.\n"));
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mProcessCpuLoadUserHandle,
+                user)))
+            {
+            Log (("Failed to read 'PercentUserTime' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mProcessCpuLoadKernelHandle,
+                kernel)))
+            {
+            Log (("Failed to read 'PercentPrivilegedTime' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mProcessCpuLoadTimestampHandle,
+                total)))
+            {
+            Log (("Failed to read 'Timestamp_Sys100NS' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            rc = VINF_SUCCESS;
+        }
+        apEnumAccess[i]->Release();
+        apEnumAccess[i] = NULL;
+    }
+    delete [] apEnumAccess;
+
+    LogFlowThisFunc(("user=%lu kernel=%lu total=%lu\n", *user, *kernel, *total));
+    LogFlowThisFuncLeave();
+
+    return rc;
 }
 
 int CollectorWin::getProcessMemoryUsage(RTPROCESS process, unsigned long *used)
 {
-    return E_NOTIMPL;
-}
-
-}
+    HRESULT hr;
+    IWbemObjectAccess       **apEnumAccess = NULL;
+    DWORD                   dwNumReturned = 0;
+
+    LogFlowThisFuncEnter();
+
+    if (FAILED (hr = mRefresher->Refresh(0L)))
+    {
+        Log (("Refresher failed. HR = %x\n", hr));
+        return VERR_INTERNAL_ERROR;
+    }
+
+    int rc = getObjects(mEnumProcess, &apEnumAccess, &dwNumReturned);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = VERR_NOT_FOUND;
+
+    for (unsigned i = 0; i < dwNumReturned; i++)
+    {
+        DWORD dwIDProcess;
+
+        if (FAILED (hr = apEnumAccess[i]->ReadDWORD(
+            mProcessPIDHandle,
+            &dwIDProcess)))
+        {
+            Log (("Failed to read 'IDProcess' property. HR = %x\n", hr));
+            return VERR_INTERNAL_ERROR;
+        }
+        if (dwIDProcess == process)
+        {
+            uint64_t u64used = 0;
+
+            if (FAILED (hr = apEnumAccess[i]->ReadQWORD(
+                mProcessMemoryUsedHandle,
+                &u64used)))
+            {
+            Log (("Failed to read 'WorkingSet' property. HR = %x\n", hr));
+                return VERR_INTERNAL_ERROR;
+            }
+            *used = (unsigned long)(u64used / 1024);
+            rc = VINF_SUCCESS;
+        }
+        apEnumAccess[i]->Release();
+        apEnumAccess[i] = NULL;
+    }
+    delete [] apEnumAccess;
+
+    LogFlowThisFunc(("used=%lu\n", *used));
+    LogFlowThisFuncLeave();
+
+    return rc;
+}
+
+}

trunk/src/VBox/Main/win/svcmain.cpp

@@ -173 +173 @@
 #endif
     _ASSERTE(SUCCEEDED(hRes));
+    /*
+     * Need to initialize security to access performance enumerators.
+     */
+    hRes = CoInitializeSecurity(
+        NULL,
+        -1,
+        NULL,
+        NULL,
+        RPC_C_AUTHN_LEVEL_NONE,
+        RPC_C_IMP_LEVEL_IMPERSONATE,
+        NULL, EOAC_NONE, 0);
+    _ASSERTE(SUCCEEDED(hRes));
     _Module.Init(ObjectMap, hInstance, &LIBID_VirtualBox);
     _Module.dwThreadID = GetCurrentThreadId();