Changeset 36128 in vbox

Timestamp:

Mar 2, 2011 5:44:04 AM (14 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

70296

Message:

Main/Metrics: Hypervisor and guest metrics re-done (#5566)

Location:

trunk/src/VBox/Main

Files:

• idl/VirtualBox.xidl (modified) (1 diff)
• include/MachineImpl.h (modified) (1 diff)
• include/Performance.h (modified) (11 diffs)
• include/PerformanceImpl.h (modified) (4 diffs)
• src-client/GuestImpl.cpp (modified) (3 diffs)
• src-server/HostImpl.cpp (modified) (1 diff)
• src-server/MachineImpl.cpp (modified) (5 diffs)
• src-server/Performance.cpp (modified) (10 diffs)
• src-server/PerformanceImpl.cpp (modified) (5 diffs)
• testcase/tstAPI.cpp (modified) (5 diffs)

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -14484 +14484 @@
       <li>CPU/MHz</li>
       <li>RAM/Usage</li>
+      <li>RAM/VMM</li>
       </ul>
 

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

@@ -860 +860 @@
     void registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
 
-    pm::CollectorGuestHAL  *mGuestHAL;
+    pm::CollectorGuest     *mCollectorGuest;
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
 

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

@@ -73 +73 @@
 
 
-    /* Collector Hardware Abstraction Layer *********************************/
     enum {
         COLLECT_NONE        = 0x0,
         COLLECT_CPU_LOAD    = 0x1,
-        COLLECT_RAM_USAGE   = 0x2
+        COLLECT_RAM_USAGE   = 0x2,
+        COLLECT_GUEST_STATS = 0x4
     };
     typedef int HintFlags;
@@ -92 +92 @@
         void collectHostRamUsage()
             { mHostFlags |= COLLECT_RAM_USAGE; }
+        void collectHostRamVmm()
+            { mHostFlags |= COLLECT_GUEST_STATS; }
         void collectProcessCpuLoad(RTPROCESS process)
             { findProcess(process).second |= COLLECT_CPU_LOAD; }
         void collectProcessRamUsage(RTPROCESS process)
             { findProcess(process).second |= COLLECT_RAM_USAGE; }
+        void collectGuestStats(RTPROCESS process)
+            { findProcess(process).second |= COLLECT_GUEST_STATS; }
         bool isHostCpuLoadCollected() const
             { return (mHostFlags & COLLECT_CPU_LOAD) != 0; }
         bool isHostRamUsageCollected() const
             { return (mHostFlags & COLLECT_RAM_USAGE) != 0; }
+        bool isHostRamVmmCollected() const
+            { return (mHostFlags & COLLECT_GUEST_STATS) != 0; }
         bool isProcessCpuLoadCollected(RTPROCESS process)
             { return (findProcess(process).second & COLLECT_CPU_LOAD) != 0; }
         bool isProcessRamUsageCollected(RTPROCESS process)
             { return (findProcess(process).second & COLLECT_RAM_USAGE) != 0; }
+        bool isGuestStatsCollected(RTPROCESS process)
+            { return (findProcess(process).second & COLLECT_GUEST_STATS) != 0; }
         void getProcesses(std::vector<RTPROCESS>& processes) const
         {
@@ -132 +140 @@
     };
 
+    /* Guest Collector Classes  *********************************/
+    class CollectorGuest
+    {
+    public:
+        CollectorGuest(Machine *machine, RTPROCESS process);
+        ~CollectorGuest();
+
+        bool isEnabled()        { return mEnabled; };
+        bool isValid()          { return mValid; };
+        void invalidateStats()  { mValid = false; };
+        int updateStats();
+        int enable();
+        int disable();
+
+        RTPROCESS getProcess()  { return mProcess; };
+        ULONG getCpuUser()      { return mCpuUser; };
+        ULONG getCpuKernel()    { return mCpuKernel; };
+        ULONG getCpuIdle()      { return mCpuIdle; };
+        ULONG getMemTotal()     { return mMemTotal; };
+        ULONG getMemFree()      { return mMemFree; };
+        ULONG getMemBalloon()   { return mMemBalloon; };
+        ULONG getMemShared()    { return mMemShared; };
+        ULONG getMemCache()     { return mMemCache; };
+        ULONG getPageTotal()    { return mPageTotal; };
+        ULONG getAllocVMM()     { return mAllocVMM; };
+        ULONG getFreeVMM()      { return mFreeVMM; };
+        ULONG getBalloonedVMM() { return mBalloonedVMM; };
+        ULONG getSharedVMM()    { return mSharedVMM; };
+
+    private:
+        bool                 mEnabled;
+        bool                 mValid;
+        Machine             *mMachine;
+        RTPROCESS            mProcess;
+        ComPtr<IConsole>     mConsole;
+        ComPtr<IGuest>       mGuest;
+        ULONG                mCpuUser;
+        ULONG                mCpuKernel;
+        ULONG                mCpuIdle;
+        ULONG                mMemTotal;
+        ULONG                mMemFree;
+        ULONG                mMemBalloon;
+        ULONG                mMemShared;
+        ULONG                mMemCache;
+        ULONG                mPageTotal;
+        ULONG                mAllocVMM;
+        ULONG                mFreeVMM;
+        ULONG                mBalloonedVMM;
+        ULONG                mSharedVMM;
+    };
+
+    typedef std::list<CollectorGuest*> CollectorGuestList;
+    class CollectorGuestManager
+    {
+    public:
+        CollectorGuestManager() : mVMMStatsProvider(NULL) {};
+        void registerGuest(CollectorGuest* pGuest);
+        void unregisterGuest(CollectorGuest* pGuest);
+        CollectorGuest *getVMMStatsProvider() { return mVMMStatsProvider; };
+        void preCollect(CollectorHints& hints, uint64_t iTick);
+    private:
+        CollectorGuestList mGuests;
+        CollectorGuest    *mVMMStatsProvider;
+    };
+
+    /* Collector Hardware Abstraction Layer *********************************/
     class CollectorHAL
     {
     public:
-                 CollectorHAL() : mMemAllocVMM(0), mMemFreeVMM(0), mMemBalloonedVMM(0), mMemSharedVMM(0) {};
+                 CollectorHAL() {};
         virtual ~CollectorHAL() { };
         virtual int preCollect(const CollectorHints& /* hints */, uint64_t /* iTick */) { return VINF_SUCCESS; }
@@ -153 +227 @@
         /** Returns process' CPU usage counter in platform-specific units. */
         virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t *user, uint64_t *kernel, uint64_t *total);
-
-        /** Enable metrics collecting (if applicable) */
-        virtual int enable();
-        /** Disable metrics collecting (if applicable) */
-        virtual int disable();
-
-        virtual int setMemHypervisorStats(ULONG memAlloc, ULONG memFree, ULONG memBallooned, ULONG memShared)
-        {
-            mMemAllocVMM     = memAlloc;
-            mMemFreeVMM      = memFree;
-            mMemBalloonedVMM = memBallooned;
-            mMemSharedVMM    = memShared;
-            return S_OK;
-        }
-
-        virtual void getMemHypervisorStats(ULONG *pMemAlloc, ULONG *pMemFree, ULONG *pMemBallooned, ULONG *pMemShared)
-        {
-            *pMemAlloc     = mMemAllocVMM;
-            *pMemFree      = mMemFreeVMM;
-            *pMemBallooned = mMemBalloonedVMM;
-            *pMemShared    = mMemSharedVMM;
-        }
-
-    private:
-        ULONG       mMemAllocVMM;
-        ULONG       mMemFreeVMM;
-        ULONG       mMemBalloonedVMM;
-        ULONG       mMemSharedVMM;
-    };
-
-    class CollectorGuestHAL : public CollectorHAL
-    {
-    public:
-        CollectorGuestHAL(Machine *machine, CollectorHAL *hostHAL);
-        ~CollectorGuestHAL();
-
-        virtual int preCollect(const CollectorHints& hints, uint64_t iTick);
-
-        /** Enable metrics collecting (if applicable) */
-        virtual int enable();
-        /** Disable metrics collecting (if applicable) */
-        virtual int disable();
-
-        /** Return guest cpu absolute load values (0-100). */
-        void getGuestCpuLoad(ULONG *pulCpuUser, ULONG *pulCpuKernel, ULONG *pulCpuIdle)
-        {
-            *pulCpuUser   = mCpuUser;
-            *pulCpuKernel = mCpuKernel;
-            *pulCpuIdle   = mCpuIdle;
-        }
-
-        /** Return guest memory information in KB. */
-        void getGuestMemLoad(ULONG *pulMemTotal, ULONG *pulMemFree, ULONG *pulMemBalloon, ULONG *pulMemShared, ULONG *pulMemCache, ULONG *pulPageTotal)
-        {
-            *pulMemTotal        = mMemTotal;
-            *pulMemFree         = mMemFree;
-            *pulMemBalloon      = mMemBalloon;
-            *pulMemShared       = mMemShared;
-            *pulMemCache        = mMemCache;
-            *pulPageTotal       = mPageTotal;
-        }
-
-
-    protected:
-        uint32_t             cEnabled;
-        Machine             *mMachine;
-        ComPtr<IConsole>     mConsole;
-        ComPtr<IGuest>       mGuest;
-        uint64_t             mLastTick;
-
-        CollectorHAL        *mHostHAL;
-
-        ULONG                mCpuUser;
-        ULONG                mCpuKernel;
-        ULONG                mCpuIdle;
-        ULONG                mMemTotal;
-        ULONG                mMemFree;
-        ULONG                mMemBalloon;
-        ULONG                mMemShared;
-        ULONG                mMemCache;
-        ULONG                mPageTotal;
-
-    private:
-        static uint32_t      cVMsEnabled;
     };
 
@@ -259 +249 @@
         bool collectorBeat(uint64_t nowAt);
 
-        void enable()
-        {
-            mEnabled = true;
-            mHAL->enable();
-        };
-        void disable()
-        {
-            mHAL->disable();
-            mEnabled = false;
-        };
+        void enable()  { mEnabled = true; };
+        void disable() { mEnabled = false; };
 
         bool isEnabled() { return mEnabled; };
@@ -287 +269 @@
     };
 
+    class BaseGuestMetric : public BaseMetric
+    {
+    public:
+        BaseGuestMetric(CollectorGuest *cguest, const char *name, ComPtr<IUnknown> object)
+            : BaseMetric(NULL, name, object), mCGuest(cguest) {};
+    protected:
+        CollectorGuest *mCGuest;
+    };
+
     class HostCpuLoad : public BaseMetric
     {
@@ -363 +354 @@
     {
     public:
-        HostRamVmm(CollectorHAL *hal, ComPtr<IUnknown> object, SubMetric *allocVMM, SubMetric *freeVMM, SubMetric *balloonVMM, SubMetric *sharedVMM)
-        : BaseMetric(hal, "RAM/VMM", object), mAllocVMM(allocVMM), mFreeVMM(freeVMM), mBalloonVMM(balloonVMM), mSharedVMM(sharedVMM) {};
+        HostRamVmm(CollectorGuestManager *gm, ComPtr<IUnknown> object, SubMetric *allocVMM, SubMetric *freeVMM, SubMetric *balloonVMM, SubMetric *sharedVMM)
+            : BaseMetric(NULL, "RAM/VMM", object), mCollectorGuestManager(gm),
+            mAllocVMM(allocVMM), mFreeVMM(freeVMM), mBalloonVMM(balloonVMM), mSharedVMM(sharedVMM),
+            mAllocCurrent(0), mFreeCurrent(0), mBalloonedCurrent(0), mSharedCurrent(0) {};
         ~HostRamVmm() { delete mAllocVMM; delete mFreeVMM; delete mBalloonVMM; delete mSharedVMM; };
 
@@ -374 +367 @@
         ULONG getMaxValue() { return INT32_MAX; };
         ULONG getScale() { return 1; }
-    private:
-        SubMetric *mAllocVMM;
-        SubMetric *mFreeVMM;
-        SubMetric *mBalloonVMM;
-        SubMetric *mSharedVMM;
+
+    private:
+        CollectorGuestManager *mCollectorGuestManager;
+        SubMetric             *mAllocVMM;
+        SubMetric             *mFreeVMM;
+        SubMetric             *mBalloonVMM;
+        SubMetric             *mSharedVMM;
+        ULONG                  mAllocCurrent;
+        ULONG                  mFreeCurrent;
+        ULONG                  mBalloonedCurrent;
+        ULONG                  mSharedCurrent;
     };
 
@@ -434 +433 @@
 
 
-    class GuestCpuLoad : public BaseMetric
-    {
-    public:
-        GuestCpuLoad(CollectorGuestHAL *hal, ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
-        : BaseMetric(hal, "CPU/Load", object), mUser(user), mKernel(kernel), mIdle(idle), mGuestHAL(hal) {};
+    class GuestCpuLoad : public BaseGuestMetric
+    {
+    public:
+        GuestCpuLoad(CollectorGuest *cguest, ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
+            : BaseGuestMetric(cguest, "Guest/CPU/Load", object), mUser(user), mKernel(kernel), mIdle(idle) {};
         ~GuestCpuLoad() { delete mUser; delete mKernel; delete mIdle; };
 
@@ -452 +451 @@
         SubMetric *mKernel;
         SubMetric *mIdle;
-        CollectorGuestHAL *mGuestHAL;
-    };
-
-    class GuestRamUsage : public BaseMetric
-    {
-    public:
-        GuestRamUsage(CollectorGuestHAL *hal, ComPtr<IUnknown> object, SubMetric *total, SubMetric *free, SubMetric *balloon, SubMetric *shared, SubMetric *cache, SubMetric *pagedtotal)
-        : BaseMetric(hal, "RAM/Usage", object), mTotal(total), mFree(free), mBallooned(balloon), mCache(cache), mPagedTotal(pagedtotal), mShared(shared), mGuestHAL(hal) {};
+    };
+
+    class GuestRamUsage : public BaseGuestMetric
+    {
+    public:
+        GuestRamUsage(CollectorGuest *cguest, ComPtr<IUnknown> object, SubMetric *total, SubMetric *free, SubMetric *balloon, SubMetric *shared, SubMetric *cache, SubMetric *pagedtotal)
+            : BaseGuestMetric(cguest, "Guest/RAM/Usage", object), mTotal(total), mFree(free), mBallooned(balloon), mCache(cache), mPagedTotal(pagedtotal), mShared(shared) {};
         ~GuestRamUsage() { delete mTotal; delete mFree; delete mBallooned; delete mShared; delete mCache; delete mPagedTotal; };
 
@@ -471 +469 @@
     private:
         SubMetric *mTotal, *mFree, *mBallooned, *mCache, *mPagedTotal, *mShared;
-        CollectorGuestHAL *mGuestHAL;
     };
 

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

@@ -36 +36 @@
     class BaseMetric;
     class CollectorHAL;
+    class CollectorGuest;
+    class CollectorGuestManager;
 }
 
@@ -174 +176 @@
     void unregisterBaseMetricsFor (const ComPtr<IUnknown> &object);
     void unregisterMetricsFor (const ComPtr<IUnknown> &object);
+    void registerGuest(pm::CollectorGuest* pGuest);
+    void unregisterGuest(pm::CollectorGuest* pGuest);
 
     void suspendSampling();
@@ -181 +185 @@
     // (ensure there is a caller and a read lock before calling them!)
 
-    pm::CollectorHAL *getHAL() { return m.hal; };
+    pm::CollectorHAL          *getHAL()          { return m.hal; };
+    pm::CollectorGuestManager *getGuestManager() { return m.gm; };
 
 private:
@@ -204 +209 @@
         Data() : hal(0) {};
 
-        BaseMetricList     baseMetrics;
-        MetricList         metrics;
-        RTTIMERLR          sampler;
-        pm::CollectorHAL  *hal;
+        BaseMetricList             baseMetrics;
+        MetricList                 metrics;
+        RTTIMERLR                  sampler;
+        pm::CollectorHAL          *hal;
+        pm::CollectorGuestManager *gm;
     };
 

trunk/src/VBox/Main/src-client/GuestImpl.cpp

@@ -392 +392 @@
             *aMemSharedTotal  = (ULONG)(uSharedTotal / _1K);
         }
+        else
+            return E_FAIL;
 
         /* Query the missing per-VM memory statistics. */
@@ -401 +403 @@
             *aMemShared = (ULONG)(uSharedMem / _1K);
         }
+        else
+            return E_FAIL;
     }
     else
@@ -409 +413 @@
         *aMemSharedTotal  = 0;
         *aMemShared       = 0;
+        return E_FAIL;
     }
 

trunk/src/VBox/Main/src-server/HostImpl.cpp

@@ -2794 +2794 @@
                                                     ramUsageFree);
     aCollector->registerBaseMetric (ramUsage);
-    pm::BaseMetric *ramVmm = new pm::HostRamVmm(hal, objptr, 
+    pm::BaseMetric *ramVmm = new pm::HostRamVmm(aCollector->getGuestManager(), objptr, 
                                                 ramVMMUsed,
                                                 ramVMMFree,

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -227 +227 @@
 
 Machine::Machine()
-    : mGuestHAL(NULL),
+    : mCollectorGuest(NULL),
       mPeer(NULL),
       mParent(NULL)
@@ -10067 +10067 @@
 
 
-    /* Guest metrics */
-    mGuestHAL = new pm::CollectorGuestHAL(this, hal);
+    /* Guest metrics collector */
+    mCollectorGuest = new pm::CollectorGuest(aMachine, pid);
+    aCollector->registerGuest(mCollectorGuest);
+    LogAleksey(("{%p} " LOG_FN_FMT ": mCollectorGuest=%p\n",
+                this, __PRETTY_FUNCTION__, mCollectorGuest));
 
     /* Create sub metrics */
@@ -10088 +10091 @@
 
     /* Create and register base metrics */
-    pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mGuestHAL, aMachine, guestLoadUser, guestLoadKernel, guestLoadIdle);
+    pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mCollectorGuest, aMachine,
+                                                        guestLoadUser, guestLoadKernel, guestLoadIdle);
     aCollector->registerBaseMetric(guestCpuLoad);
 
-    pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mGuestHAL, aMachine, guestMemTotal, guestMemFree, guestMemBalloon, guestMemShared,
+    pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mCollectorGuest, aMachine,
+                                                        guestMemTotal, guestMemFree,
+                                                        guestMemBalloon, guestMemShared,
                                                         guestMemCache, guestPagedTotal);
     aCollector->registerBaseMetric(guestCpuMem);
@@ -10149 +10155 @@
         aCollector->unregisterMetricsFor(aMachine);
         aCollector->unregisterBaseMetricsFor(aMachine);
-    }
-
-    if (mGuestHAL)
-    {
-        delete mGuestHAL;
-        mGuestHAL = NULL;
     }
 }
@@ -10465 +10465 @@
     AutoMultiWriteLock3 multilock(mParent, mParent->host(), this COMMA_LOCKVAL_SRC_POS);
 
+    LogAleksey(("{%p} " LOG_FN_FMT ": mCollectorGuest=%p\n",
+                this, __PRETTY_FUNCTION__, mCollectorGuest));
+    if (mCollectorGuest)
+    {
+        mParent->performanceCollector()->unregisterGuest(mCollectorGuest);
+        delete mCollectorGuest;
+        mCollectorGuest = NULL;
+    }
     // Trigger async cleanup tasks, avoid doing things here which are not
     // vital to be done immediately and maybe need more locks. This calls

trunk/src/VBox/Main/src-server/Performance.cpp

@@ -76 +76 @@
 }
 
-int CollectorHAL::enable()
-{
-    return E_NOTIMPL;
-}
-
-int  CollectorHAL::disable()
-{
-    return E_NOTIMPL;
-}
-
 /* Generic implementations */
 
@@ -121 +111 @@
 #ifndef VBOX_COLLECTOR_TEST_CASE
 
-uint32_t CollectorGuestHAL::cVMsEnabled = 0;
-
-CollectorGuestHAL::CollectorGuestHAL(Machine *machine, CollectorHAL *hostHAL)
-    : CollectorHAL(), cEnabled(0), mMachine(machine), mConsole(NULL),
-      mGuest(NULL), mLastTick(0), mHostHAL(hostHAL), mCpuUser(0),
-      mCpuKernel(0), mCpuIdle(0), mMemTotal(0), mMemFree(0),
-      mMemBalloon(0), mMemShared(0), mMemCache(0), mPageTotal(0)
+CollectorGuest::CollectorGuest(Machine *machine, RTPROCESS process) :
+    mEnabled(false), mValid(false), mMachine(machine), mProcess(process),
+    mCpuUser(0), mCpuKernel(0), mCpuIdle(0),
+    mMemTotal(0), mMemFree(0), mMemBalloon(0), mMemShared(0), mMemCache(0), mPageTotal(0),
+    mAllocVMM(0), mFreeVMM(0), mBalloonedVMM(0), mSharedVMM(0)
 {
     Assert(mMachine);
@@ -134 +122 @@
 }
 
-CollectorGuestHAL::~CollectorGuestHAL()
+CollectorGuest::~CollectorGuest()
 {
     /* cannot use ComObjPtr<Machine> in Performance.h, do it manually */
     mMachine->Release();
-    Assert(!cEnabled);
-}
-
-int CollectorGuestHAL::enable()
-{
+    // Assert(!cEnabled); why?
+}
+
+int CollectorGuest::enable()
+{
+    mEnabled = true;
     /* Must make sure that the machine object does not get uninitialized
      * in the middle of enabling this collector. Causes timing-related
@@ -154 +143 @@
     HRESULT ret = S_OK;
 
-    if (ASMAtomicIncU32(&cEnabled) == 1)
-    {
-        ASMAtomicIncU32(&cVMsEnabled);
-        ComPtr<IInternalSessionControl> directControl;
-
-        ret = mMachine->getDirectControl(&directControl);
-        if (ret != S_OK)
-            return ret;
-
-        /* get the associated console; this is a remote call (!) */
-        ret = directControl->GetRemoteConsole(mConsole.asOutParam());
-        if (ret != S_OK)
-            return ret;
-
-        ret = mConsole->COMGETTER(Guest)(mGuest.asOutParam());
-        if (ret == S_OK)
-            mGuest->COMSETTER(StatisticsUpdateInterval)(1 /* 1 sec */);
-    }
+    ComPtr<IInternalSessionControl> directControl;
+
+    ret = mMachine->getDirectControl(&directControl);
+    if (ret != S_OK)
+        return ret;
+
+    /* get the associated console; this is a remote call (!) */
+    ret = directControl->GetRemoteConsole(mConsole.asOutParam());
+    if (ret != S_OK)
+        return ret;
+
+    ret = mConsole->COMGETTER(Guest)(mGuest.asOutParam());
+    if (ret == S_OK)
+    {
+        ret = mGuest->COMSETTER(StatisticsUpdateInterval)(1 /* 1 sec */);
+        LogAleksey(("{%p} " LOG_FN_FMT ": Set guest statistics update interval to 1 sec (%s)\n",
+                    this, __PRETTY_FUNCTION__, SUCCEEDED(ret)?"success":"failed"));
+    }
+
     return ret;
 }
 
-int CollectorGuestHAL::disable()
-{
-    if (ASMAtomicDecU32(&cEnabled) == 0)
-    {
-        if (ASMAtomicDecU32(&cVMsEnabled) == 0)
-        {
-            if (mHostHAL)
-                mHostHAL->setMemHypervisorStats(0 /* ulMemAllocTotal */, 0 /* ulMemFreeTotal */, 0 /* ulMemBalloonTotal */, 0 /* ulMemSharedTotal */);
-        }
-        Assert(mGuest && mConsole);
-        mGuest->COMSETTER(StatisticsUpdateInterval)(0 /* off */);
-    }
+int CollectorGuest::disable()
+{
+    mEnabled = false;
+    Assert(mGuest && mConsole);
+    HRESULT ret = mGuest->COMSETTER(StatisticsUpdateInterval)(0 /* off */);
+    LogAleksey(("{%p} " LOG_FN_FMT ": Set guest statistics update interval to 0 sec (%s)\n",
+                this, __PRETTY_FUNCTION__, SUCCEEDED(ret)?"success":"failed"));
+    invalidateStats();
+
     return S_OK;
 }
 
-int CollectorGuestHAL::preCollect(const CollectorHints& /* hints */, uint64_t iTick)
-{
-    if (    mGuest
-        &&  iTick != mLastTick)
-    {
-        ULONG ulMemAllocTotal, ulMemFreeTotal, ulMemBalloonTotal, ulMemSharedTotal;
-
-        mGuest->InternalGetStatistics(&mCpuUser, &mCpuKernel, &mCpuIdle,
-                                      &mMemTotal, &mMemFree, &mMemBalloon, &mMemShared, &mMemCache,
-                                      &mPageTotal, &ulMemAllocTotal, &ulMemFreeTotal, &ulMemBalloonTotal, &ulMemSharedTotal);
-
-        if (mHostHAL)
-            mHostHAL->setMemHypervisorStats(ulMemAllocTotal, ulMemFreeTotal, ulMemBalloonTotal, ulMemSharedTotal);
-
-        mLastTick = iTick;
-    }
+int CollectorGuest::updateStats()
+{
+    if (mGuest)
+    {
+        HRESULT rc;
+        rc = mGuest->InternalGetStatistics(&mCpuUser, &mCpuKernel, &mCpuIdle,
+                                           &mMemTotal, &mMemFree, &mMemBalloon, &mMemShared, &mMemCache,
+                                           &mPageTotal, &mAllocVMM, &mFreeVMM, &mBalloonedVMM, &mSharedVMM);
+        if (SUCCEEDED(rc))
+        {
+            mValid = true;
+        }
+        LogAleksey(("{%p} " LOG_FN_FMT ": mValid=%s mCpuUser=%u mCpuKernel=%u mCpuIdle=%u\n"
+                    "mMemTotal=%u mMemFree=%u mMemBalloon=%u mMemShared=%u mMemCache=%u\n"
+                    "mPageTotal=%u mAllocVMM=%u mFreeVMM=%u mBalloonedVMM=%u mSharedVMM=%u\n",
+                    this, __PRETTY_FUNCTION__, mValid?"y":"n",
+                    mCpuUser, mCpuKernel, mCpuIdle,
+                    mMemTotal, mMemFree, mMemBalloon, mMemShared, mMemCache,
+                    mPageTotal, mAllocVMM, mFreeVMM, mBalloonedVMM, mSharedVMM));
+    }
+
     return S_OK;
 }
+
+void CollectorGuestManager::preCollect(CollectorHints& hints, uint64_t /* iTick */)
+{
+    CollectorGuestList::iterator it;
+
+    LogAleksey(("{%p} " LOG_FN_FMT ": provider=%p ramvmm=%s\n",
+                this, __PRETTY_FUNCTION__, mVMMStatsProvider, hints.isHostRamVmmCollected()?"y":"n"));
+    for (it = mGuests.begin(); it != mGuests.end(); it++)
+    {
+        LogAleksey(("{%p} " LOG_FN_FMT ": it=%p pid=%d gueststats=%s...\n",
+                    this, __PRETTY_FUNCTION__, *it, (*it)->getProcess(),
+                    hints.isGuestStatsCollected((*it)->getProcess())?"y":"n"));
+        if (  (hints.isHostRamVmmCollected() && *it == mVMMStatsProvider)
+            || hints.isGuestStatsCollected((*it)->getProcess()))
+        {
+            /* Guest stats collection needs to be enabled */
+            if ((*it)->isEnabled())
+            {
+                /* Already enabled, collect the data */
+                (*it)->updateStats();
+            }
+            else
+            {
+                (*it)->invalidateStats();
+                (*it)->enable();
+            }
+        }
+        else
+        {
+            /* Guest stats collection needs to be disabled */
+            if ((*it)->isEnabled())
+                (*it)->disable();
+        }
+    }
+}
+
+void CollectorGuestManager::registerGuest(CollectorGuest* pGuest)
+{
+    mGuests.push_back(pGuest);
+    /*
+     * If no VMM stats provider was elected previously than this is our
+     * candidate.
+     */
+    if (!mVMMStatsProvider)
+        mVMMStatsProvider = pGuest;
+    LogAleksey(("{%p} " LOG_FN_FMT ": Registered guest=%p provider=%p\n",
+                this, __PRETTY_FUNCTION__, pGuest, mVMMStatsProvider));
+}
+
+void CollectorGuestManager::unregisterGuest(CollectorGuest* pGuest)
+{
+    LogAleksey(("{%p} " LOG_FN_FMT ": About to unregister guest=%p provider=%p\n",
+                this, __PRETTY_FUNCTION__, pGuest, mVMMStatsProvider));
+    mGuests.remove(pGuest);
+    LogAleksey(("{%p} " LOG_FN_FMT ": Number of guests after remove is %d\n",
+                this, __PRETTY_FUNCTION__, mGuests.size()));
+    if (pGuest == mVMMStatsProvider)
+    {
+        /* This was our VMM stats provider, it is time to re-elect */
+        if (mGuests.empty())
+        {
+            /* Nobody can provide VMM stats */
+            mVMMStatsProvider = NULL;
+        }
+        else
+        {
+            /* First let's look for a guest already collecting stats */
+            CollectorGuestList::iterator it;
+
+            for (it = mGuests.begin(); it != mGuests.end(); it++)
+                if ((*it)->isEnabled())
+                {
+                    /* Found one, elect it */
+                    mVMMStatsProvider = *it;
+                    LogAleksey(("{%p} " LOG_FN_FMT ": LEAVE new provider=%p\n",
+                                this, __PRETTY_FUNCTION__, mVMMStatsProvider));
+                    return;
+                }
+
+            /* Nobody collects stats, take the first one */
+            mVMMStatsProvider = mGuests.front();
+        }
+    }
+    LogAleksey(("{%p} " LOG_FN_FMT ": LEAVE new provider=%p\n",
+                this, __PRETTY_FUNCTION__, mVMMStatsProvider));
+}
+
 
 #endif /* !VBOX_COLLECTOR_TEST_CASE */
@@ -225 +304 @@
     return false;
 }
-
-/*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(ULONG period, ULONG length)
@@ -345 +418 @@
 }
 
-void HostRamVmm::preCollect(CollectorHints& /* hints */, uint64_t /* iTick */)
-{
-    /*
-     * This is an ugly ugly hack to force VMM metrics to 0s if no VM is
-     * running. The reason it should work is that the VMM stats are
-     * stored in CollectorHAL in preCollect methods of guest base metrics
-     * which are always added after HostRamVmm. So each pass of collector
-     * first clears the metrics then gets new values.
-     */
-    mHAL->setMemHypervisorStats(0 /* ulMemAllocTotal */, 0 /* ulMemFreeTotal */, 0 /* ulMemBalloonTotal */, 0 /* ulMemSharedTotal */);
+void HostRamVmm::preCollect(CollectorHints& hints, uint64_t /* iTick */)
+{
+    hints.collectHostRamVmm();
 }
 
 void HostRamVmm::collect()
 {
-    ULONG allocVMM, freeVMM, balloonVMM, sharedVMM;
-
-    mHAL->getMemHypervisorStats(&allocVMM, &freeVMM, &balloonVMM, &sharedVMM);
-    mAllocVMM->put(allocVMM);
-    mFreeVMM->put(freeVMM);
-    mBalloonVMM->put(balloonVMM);
-    mSharedVMM->put(sharedVMM);
+    CollectorGuest *provider = mCollectorGuestManager->getVMMStatsProvider();
+    if (provider)
+    {
+        LogAleksey(("{%p} " LOG_FN_FMT ": provider=%p enabled=%s valid=%s...\n",
+                    this, __PRETTY_FUNCTION__, provider, provider->isEnabled()?"y":"n",
+                    provider->isValid()?"y":"n"));
+        if (provider->isValid())
+        {
+            /* Provider is ready, get updated stats */
+            mAllocCurrent     = provider->getAllocVMM();
+            mFreeCurrent      = provider->getFreeVMM();
+            mBalloonedCurrent = provider->getBalloonedVMM();
+            mSharedCurrent    = provider->getSharedVMM();
+        }
+    }
+    else
+    {
+        mAllocCurrent     = 0;
+        mFreeCurrent      = 0;
+        mBalloonedCurrent = 0;
+        mSharedCurrent    = 0;
+    }
+    LogAleksey(("{%p} " LOG_FN_FMT ": mAllocCurrent=%u mFreeCurrent=%u mBalloonedCurrent=%u mSharedCurrent=%u\n",
+                this, __PRETTY_FUNCTION__,
+                mAllocCurrent, mFreeCurrent, mBalloonedCurrent, mSharedCurrent));
+    mAllocVMM->put(mAllocCurrent);
+    mFreeVMM->put(mFreeCurrent);
+    mBalloonVMM->put(mBalloonedCurrent);
+    mSharedVMM->put(mSharedCurrent);
 }
 
@@ -450 +538 @@
 }
 
-void GuestCpuLoad::preCollect(CollectorHints& hints, uint64_t iTick)
-{
-    mHAL->preCollect(hints, iTick);
+void GuestCpuLoad::preCollect(CollectorHints& hints, uint64_t /* iTick */)
+{
+    hints.collectGuestStats(mCGuest->getProcess());
 }
 
 void GuestCpuLoad::collect()
 {
-    ULONG CpuUser = 0, CpuKernel = 0, CpuIdle = 0;
-
-    mGuestHAL->getGuestCpuLoad(&CpuUser, &CpuKernel, &CpuIdle);
-    mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * CpuUser) / 100);
-    mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * CpuKernel) / 100);
-    mIdle->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * CpuIdle) / 100);
+    if (mCGuest->isValid())
+    {
+        mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * mCGuest->getCpuUser()) / 100);
+        mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * mCGuest->getCpuKernel()) / 100);
+        mIdle->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * mCGuest->getCpuIdle()) / 100);
+    }
 }
 
@@ -478 +566 @@
 }
 
-void GuestRamUsage::preCollect(CollectorHints& hints,  uint64_t iTick)
-{
-    mHAL->preCollect(hints, iTick);
+void GuestRamUsage::preCollect(CollectorHints& hints,  uint64_t /* iTick */)
+{
+    hints.collectGuestStats(mCGuest->getProcess());
 }
 
 void GuestRamUsage::collect()
 {
-    ULONG ulMemTotal = 0, ulMemFree = 0, ulMemBalloon = 0, ulMemShared = 0, ulMemCache = 0, ulPageTotal = 0;
-
-    mGuestHAL->getGuestMemLoad(&ulMemTotal, &ulMemFree, &ulMemBalloon, &ulMemShared, &ulMemCache, &ulPageTotal);
-    mTotal->put(ulMemTotal);
-    mFree->put(ulMemFree);
-    mBallooned->put(ulMemBalloon);
-    mShared->put(ulMemShared);
-    mCache->put(ulMemCache);
-    mPagedTotal->put(ulPageTotal);
+    if (mCGuest->isValid())
+    {
+        mTotal->put(mCGuest->getMemTotal());
+        mFree->put(mCGuest->getMemFree());
+        mBallooned->put(mCGuest->getMemBalloon());
+        mShared->put(mCGuest->getMemShared());
+        mCache->put(mCGuest->getMemCache());
+        mPagedTotal->put(mCGuest->getPageTotal());
+    }
 }
 
@@ -792 +880 @@
     ElementList::const_iterator it;
 
-    LogAleksey(("Filter::match(%p, %s)\n", static_cast<const IUnknown*> (object), name.c_str()));
+    //LogAleksey(("Filter::match(%p, %s)\n", static_cast<const IUnknown*> (object), name.c_str()));
     for (it = mElements.begin(); it != mElements.end(); it++)
     {
-        LogAleksey(("...matching against(%p, %s)\n", static_cast<const IUnknown*> ((*it).first), (*it).second.c_str()));
+        //LogAleksey(("...matching against(%p, %s)\n", static_cast<const IUnknown*> ((*it).first), (*it).second.c_str()));
         if ((*it).first.isNull() || (*it).first == object)
         {
@@ -806 +894 @@
         }
     }
-    LogAleksey(("...no matches!\n"));
+    //LogAleksey(("...no matches!\n"));
     return false;
 }

trunk/src/VBox/Main/src-server/PerformanceImpl.cpp

@@ -159 +159 @@
 
     m.hal = pm::createHAL();
+    m.gm = new pm::CollectorGuestManager;
 
     /* Let the sampler know it gets a valid collector.  */
@@ -208 +209 @@
     //m.factory = NULL;
 
+    delete m.gm;
+    m.gm = NULL;
     delete m.hal;
     m.hal = NULL;
@@ -565 +568 @@
 }
 
+void PerformanceCollector::registerGuest(pm::CollectorGuest* pGuest)
+{
+    AutoCaller autoCaller(this);
+    if (!SUCCEEDED(autoCaller.rc())) return;
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    m.gm->registerGuest(pGuest);
+}
+
+void PerformanceCollector::unregisterGuest(pm::CollectorGuest* pGuest)
+{
+    AutoCaller autoCaller(this);
+    if (!SUCCEEDED(autoCaller.rc())) return;
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+    m.gm->unregisterGuest(pGuest);
+}
+
 void PerformanceCollector::suspendSampling()
 {
@@ -600 +621 @@
 }
 
+/*
+ * Metrics collection is a three stage process:
+ * 1) Pre-collection (hinting)
+ *    At this stage we compose the list of all metrics to be collected
+ *    If any metrics cannot be collected separately or if it is more
+ *    efficient to collect several metric at once, these metrics should
+ *    use hints to mark that they will need to be collected.
+ * 2) Pre-collection (bulk)
+ *    Using hints set at stage 1 platform-specific HAL
+ *    instance collects all marked host-related metrics.
+ *    Hinted guest-related metrics then get collected by CollectorGuestManager.
+ * 3) Collection
+ *    Metrics that are collected individually get collected and stored. Values
+ *    saved in HAL and CollectorGuestManager are extracted and stored to
+ *    individual metrics.
+ */
 void PerformanceCollector::samplerCallback(uint64_t iTick)
 {
@@ -618 +655 @@
 
     if (toBeCollected.size() == 0)
+    {
+        Log4(("{%p} " LOG_FN_FMT ": LEAVE (nothing to collect)\n", this, __PRETTY_FUNCTION__));
         return;
+    }
 
     /* Let know the platform specific code what is being collected */
     m.hal->preCollect(hints, iTick);
+    /* Collect the data in bulk from all hinted guests */
+    m.gm->preCollect(hints, iTick);
 
     /* Finally, collect the data */

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

@@ -1222 +1222 @@
 
         // Fill base metrics array
-        Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
+        //Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
+        Bstr baseMetricNames[] = { L"RAM/VMM" };
         com::SafeArray<BSTR> baseMetrics(1);
         baseMetricNames[0].cloneTo(&baseMetrics[0]);
@@ -1235 +1236 @@
         Bstr sessionType = argc > 2 ? argv[2] : "headless";
         RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
-        CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
+        CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
 
         // Open session
-        Guid guid;
-        CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
-        RTPrintf("Opening a remote session for this machine...\n");
         ComPtr<IProgress> progress;
-        CHECK_RC_BREAK(virtualBox->OpenRemoteSession(session, guid, sessionType,
-                                                       NULL, progress.asOutParam()));
-        RTPrintf("Waiting for the session to open...\n");
-        CHECK_RC_BREAK(progress->WaitForCompletion(-1));
-        ComPtr<IMachine> sessionMachine;
-        RTPrintf("Getting machine session object...\n");
-        CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
+        RTPrintf("Launching VM process...\n");
+        CHECK_ERROR_BREAK(machine, LaunchVMProcess(session, sessionType.raw(),
+                                                   NULL, progress.asOutParam()));
+        RTPrintf("Waiting for the VM to power on...\n");
+        CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
+
+        // ComPtr<IMachine> sessionMachine;
+        // RTPrintf("Getting machine session object...\n");
+        // CHECK_ERROR_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<IPerformanceMetric> affectedMetrics;
-        com::SafeIfaceArray<IUnknown> objects(2);
+        com::SafeIfaceArray<IUnknown> objects(1);
         host.queryInterfaceTo(&objects[0]);
-        machine.queryInterfaceTo(&objects[1]);
+        //machine.queryInterfaceTo(&objects[1]);
         CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
                                                    ComSafeArrayAsInParam(objects), 1u, 10u,
@@ -1266 +1266 @@
         ComPtr<IConsole> console;
         RTPrintf("Getting console object...\n");
-        CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
+        CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
 
         RTThreadSleep(5000); // Sleep for 5 seconds
@@ -1276 +1276 @@
         //RTPrintf("Press enter to pause the VM execution in the remote session...");
         //getchar();
-        CHECK_RC(console->Pause());
+        CHECK_ERROR_BREAK(console, Pause());
 
         RTThreadSleep(5000); // Sleep for 5 seconds
@@ -1321 +1321 @@
         RTPrintf("Press enter to power off VM...");
         getchar();
-        CHECK_RC(console->PowerDown());
+        CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam()));
+        RTPrintf("Waiting for the VM to power down...\n");
+        CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
         RTPrintf("Press enter to close this session...");
         getchar();
-        session->Close();
+        session->UnlockMachine();
     } while (false);
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */