Changeset 11180 in vbox for trunk/src/VBox

Timestamp:

Aug 6, 2008 3:34:11 PM (17 years ago)

Author:

vboxsync

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

34200

Message:

PerfAPI: replaced unsigned long with ULONG to get rid of solaris 64-bit issue.

Location:

trunk/src/VBox/Main

Files:

• Performance.cpp (modified) (18 diffs)
• PerformanceImpl.cpp (modified) (1 diff)
• darwin/PerformanceDarwin.cpp (modified) (2 diffs)
• include/Performance.h (modified) (16 diffs)
• linux/PerformanceLinux.cpp (modified) (7 diffs)
• os2/PerformanceOs2.cpp (modified) (2 diffs)
• solaris/PerformanceSolaris.cpp (modified) (3 diffs)
• win/PerformanceWin.cpp (modified) (7 diffs)

trunk/src/VBox/Main/Performance.cpp

@@ -75 +75 @@
 // Stubs for non-pure virtual methods
 
-int CollectorHAL::getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
+int CollectorHAL::getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle)
 {
     return E_NOTIMPL;
 }
 
-int CollectorHAL::getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
+int CollectorHAL::getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel)
 {
     return E_NOTIMPL;
@@ -114 +114 @@
 }*/
 
-void HostCpuLoad::init(unsigned long period, unsigned long length)
+void HostCpuLoad::init(ULONG period, ULONG length)
 {
     mPeriod = period;
@@ -125 +125 @@
 void HostCpuLoad::collect()
 {
-    unsigned long user, kernel, idle;
+    ULONG user, kernel, idle;
     int rc = mHAL->getHostCpuLoad(&user, &kernel, &idle);
     if (RT_SUCCESS(rc))
@@ -159 +159 @@
         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));
+            mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * userDiff / totalDiff));
+            mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * kernelDiff / totalDiff));
+            mIdle->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * idleDiff / totalDiff));
         }
     
@@ -170 +170 @@
 }
 
-void HostCpuMhz::init(unsigned long period, unsigned long length)
+void HostCpuMhz::init(ULONG period, ULONG length)
 {
     mPeriod = period;
@@ -179 +179 @@
 void HostCpuMhz::collect()
 {
-    unsigned long mhz;
+    ULONG mhz;
     int rc = mHAL->getHostCpuMHz(&mhz);
     if (RT_SUCCESS(rc))
@@ -185 +185 @@
 }
 
-void HostRamUsage::init(unsigned long period, unsigned long length)
+void HostRamUsage::init(ULONG period, ULONG length)
 {
     mPeriod = period;
@@ -196 +196 @@
 void HostRamUsage::collect()
 {
-    unsigned long total, used, available;
+    ULONG total, used, available;
     int rc = mHAL->getHostMemoryUsage(&total, &used, &available);
     if (RT_SUCCESS(rc))
@@ -208 +208 @@
 
 
-void MachineCpuLoad::init(unsigned long period, unsigned long length)
+void MachineCpuLoad::init(ULONG period, ULONG length)
 {
     mPeriod = period;
@@ -218 +218 @@
 void MachineCpuLoad::collect()
 {
-    unsigned long user, kernel;
+    ULONG user, kernel;
     int rc = mHAL->getProcessCpuLoad(mProcess, &user, &kernel);
     if (RT_SUCCESS(rc))
@@ -242 +242 @@
         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)));
+            mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * (processUser - mProcessUserPrev) / (hostTotal - mHostTotalPrev)));
+            mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * (processKernel - mProcessKernelPrev ) / (hostTotal - mHostTotalPrev)));
         }
     
@@ -252 +252 @@
 }
 
-void MachineRamUsage::init(unsigned long period, unsigned long length)
+void MachineRamUsage::init(ULONG period, ULONG length)
 {
     mPeriod = period;
@@ -261 +261 @@
 void MachineRamUsage::collect()
 {
-    unsigned long used;
+    ULONG used;
     int rc = mHAL->getProcessMemoryUsage(mProcess, &used);
     if (RT_SUCCESS(rc))
@@ -267 +267 @@
 }
 
-void CircularBuffer::init(unsigned long length)
+void CircularBuffer::init(ULONG length)
 {
     if (mData)
         RTMemFree(mData);
     mLength = length;
-    mData = (unsigned long *)RTMemAllocZ(length * sizeof(unsigned long));
+    mData = (ULONG *)RTMemAllocZ(length * sizeof(ULONG));
     mWrapped = false;
     mEnd = 0;
 }
 
-unsigned long CircularBuffer::length()
+ULONG CircularBuffer::length()
 {
     return mWrapped ? mLength : mEnd;
 }
 
-void CircularBuffer::put(unsigned long value)
+void CircularBuffer::put(ULONG value)
 {
     if (mData)
@@ -295 +295 @@
 }
 
-void CircularBuffer::copyTo(unsigned long *data)
+void CircularBuffer::copyTo(ULONG *data)
 {
     if (mWrapped)
     {
-        memcpy(data, mData + mEnd, (mLength - mEnd) * sizeof(unsigned long));
+        memcpy(data, mData + mEnd, (mLength - mEnd) * sizeof(ULONG));
         // Copy the wrapped part
         if (mEnd)
-            memcpy(data + (mLength - mEnd), mData, mEnd * sizeof(unsigned long));
+            memcpy(data + (mLength - mEnd), mData, mEnd * sizeof(ULONG));
     }
     else
-        memcpy(data, mData, mEnd * sizeof(unsigned long));
-}
-
-void SubMetric::query(unsigned long *data)
+        memcpy(data, mData, mEnd * sizeof(ULONG));
+}
+
+void SubMetric::query(ULONG *data)
 {
     copyTo(data);
 }
     
-void Metric::query(unsigned long **data, unsigned long *count)
-{
-    unsigned long length;
-    unsigned long *tmpData;
+void Metric::query(ULONG **data, ULONG *count)
+{
+    ULONG length;
+    ULONG *tmpData;
 
     length = mSubMetric->length();
     if (length)
     {
-        tmpData = (unsigned long*)RTMemAlloc(sizeof(*tmpData)*length);
+        tmpData = (ULONG*)RTMemAlloc(sizeof(*tmpData)*length);
         mSubMetric->query(tmpData);
         if (mAggregate)
         {
             *count = 1;
-            *data  = (unsigned long*)RTMemAlloc(sizeof(**data));
+            *data  = (ULONG*)RTMemAlloc(sizeof(**data));
             **data = mAggregate->compute(tmpData, length);
             RTMemFree(tmpData);
@@ -343 +343 @@
 }
 
-unsigned long AggregateAvg::compute(unsigned long *data, unsigned long length)
+ULONG AggregateAvg::compute(ULONG *data, ULONG length)
 {
     uint64_t tmp = 0;
-    for (unsigned long i = 0; i < length; ++i)
+    for (ULONG i = 0; i < length; ++i)
         tmp += data[i];
-    return (unsigned long)(tmp / length);
+    return (ULONG)(tmp / length);
 }
 
@@ -356 +356 @@
 }
 
-unsigned long AggregateMin::compute(unsigned long *data, unsigned long length)
-{
-    unsigned long tmp = *data;
-    for (unsigned long i = 0; i < length; ++i)
+ULONG AggregateMin::compute(ULONG *data, ULONG length)
+{
+    ULONG tmp = *data;
+    for (ULONG i = 0; i < length; ++i)
         if (data[i] < tmp)
             tmp = data[i];
@@ -370 +370 @@
 }
 
-unsigned long AggregateMax::compute(unsigned long *data, unsigned long length)
-{
-    unsigned long tmp = *data;
-    for (unsigned long i = 0; i < length; ++i)
+ULONG AggregateMax::compute(ULONG *data, ULONG length)
+{
+    ULONG tmp = *data;
+    for (ULONG i = 0; i < length; ++i)
         if (data[i] > tmp)
             tmp = data[i];

trunk/src/VBox/Main/PerformanceImpl.cpp

@@ -347 +347 @@
     {
         /* @todo Filtering goes here! */
-        unsigned long *values, length;
+        ULONG *values, length;
         /* @todo We may want to revise the query method to get rid of excessive alloc/memcpy calls. */
         (*it)->query(&values, &length);

trunk/src/VBox/Main/darwin/PerformanceDarwin.cpp

@@ -29 +29 @@
 {
 public:
-    virtual int getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle);
-    virtual int getHostCpuMHz(unsigned long *mhz);
-    virtual int getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available);
-    virtual int getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel);
-    virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
+    virtual int getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle);
+    virtual int getHostCpuMHz(ULONG *mhz);
+    virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+    virtual int getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel);
+    virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used);
 };
 
@@ -42 +42 @@
 }
 
-int CollectorDarwin::getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
+int CollectorDarwin::getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle)
 {
     return E_NOTIMPL;
 }
 
-int CollectorDarwin::getHostCpuMHz(unsigned long *mhz)
+int CollectorDarwin::getHostCpuMHz(ULONG *mhz)
 {
     return E_NOTIMPL;
 }
 
-int CollectorDarwin::getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available)
+int CollectorDarwin::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
 {
     return E_NOTIMPL;
 }
 
-int CollectorDarwin::getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
+int CollectorDarwin::getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel)
 {
     return E_NOTIMPL;
 }
 
-int CollectorDarwin::getProcessMemoryUsage(RTPROCESS process, unsigned long *used)
+int CollectorDarwin::getProcessMemoryUsage(RTPROCESS process, ULONG *used)
 {
     return E_NOTIMPL;

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

@@ -39 +39 @@
     public:
         CircularBuffer() : mData(0), mLength(0), mEnd(0), mWrapped(false) {};
-        void init(unsigned long length);
-        unsigned long length();
-        void put(unsigned long value);
-        void copyTo(unsigned long *data);
-    private:
-        unsigned long *mData;
-        unsigned long  mLength;
-        unsigned long  mEnd;
+        void init(ULONG length);
+        ULONG length();
+        void put(ULONG value);
+        void copyTo(ULONG *data);
+    private:
+        ULONG *mData;
+        ULONG  mLength;
+        ULONG  mEnd;
         bool           mWrapped;
     };
@@ -55 +55 @@
         SubMetric(const char *name)
         : mName(name) {};
-        void query(unsigned long *data);
+        void query(ULONG *data);
         const char *getName() { return mName; };
     private:
@@ -66 +66 @@
     {
     public:
-        virtual int getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle);
-        virtual int getHostCpuMHz(unsigned long *mhz) = 0;
-        virtual int getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available) = 0;
-        virtual int getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel);
-        virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used) = 0;
+        virtual int getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle);
+        virtual int getHostCpuMHz(ULONG *mhz) = 0;
+        virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available) = 0;
+        virtual int getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel);
+        virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used) = 0;
 
         virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
@@ -83 +83 @@
             : mHAL(hal), mLength(0), mName(name), mObject(object), mLastSampleTaken(0), mEnabled(false) {};
 
-        virtual void init(unsigned long period, unsigned long length) = 0;
+        virtual void init(ULONG period, ULONG length) = 0;
         virtual void collect() = 0;
         virtual const char *getUnit() = 0;
-        virtual unsigned long getMinValue() = 0;
-        virtual unsigned long getMaxValue() = 0;
+        virtual ULONG getMinValue() = 0;
+        virtual ULONG getMaxValue() = 0;
 
         void collectorBeat(uint64_t nowAt);
@@ -95 +95 @@
 
         bool isEnabled() { return mEnabled; };
-        unsigned long getPeriod() { return mPeriod; };
-        unsigned long getLength() { return mLength; };
+        ULONG getPeriod() { return mPeriod; };
+        ULONG getLength() { return mLength; };
         const char *getName() { return mName; };
         ComPtr<IUnknown> getObject() { return mObject; };
@@ -103 +103 @@
     protected:
         CollectorHAL    *mHAL;
-        unsigned long    mPeriod;
-        unsigned long    mLength;
+        ULONG    mPeriod;
+        ULONG    mLength;
         const char      *mName;
         ComPtr<IUnknown> mObject;
@@ -116 +116 @@
         HostCpuLoad(CollectorHAL *hal, ComPtr<IUnknown> object, SubMetric *user, SubMetric *kernel, SubMetric *idle)
         : BaseMetric(hal, "CPU/Load", object), mUser(user), mKernel(kernel), mIdle(idle) {};
-        void init(unsigned long period, unsigned long length);
+        void init(ULONG period, ULONG length);
 
         void collect();
         const char *getUnit() { return "%"; };
-        unsigned long getMinValue() { return 0; };
-        unsigned long getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
 
     protected:
@@ -148 +148 @@
         : BaseMetric(hal, "CPU/MHz", object), mMHz(mhz) {};
 
-        void init(unsigned long period, unsigned long length);
+        void init(ULONG period, ULONG length);
         void collect();
         const char *getUnit() { return "MHz"; };
-        unsigned long getMinValue() { return 0; };
-        unsigned long getMaxValue() { return UINT32_MAX; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return UINT32_MAX; };
     private:
         SubMetric *mMHz;
@@ -163 +163 @@
         : BaseMetric(hal, "RAM/Usage", object), mTotal(total), mUsed(used), mAvailable(available) {};
 
-        void init(unsigned long period, unsigned long length);
+        void init(ULONG period, ULONG length);
         void collect();
         const char *getUnit() { return "kB"; };
-        unsigned long getMinValue() { return 0; };
-        unsigned long getMaxValue() { return UINT32_MAX; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return UINT32_MAX; };
     private:
         SubMetric *mTotal;
@@ -180 +180 @@
         : BaseMetric(hal, "CPU/Load", object), mProcess(process), mUser(user), mKernel(kernel) {};
 
-        void init(unsigned long period, unsigned long length);
+        void init(ULONG period, ULONG length);
         void collect();
         const char *getUnit() { return "%"; };
-        unsigned long getMinValue() { return 0; };
-        unsigned long getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
     protected:
         RTPROCESS  mProcess;
@@ -210 +210 @@
         : BaseMetric(hal, "RAM/Usage", object), mProcess(process), mUsed(used) {};
 
-        void init(unsigned long period, unsigned long length);
+        void init(ULONG period, ULONG length);
         void collect();
         const char *getUnit() { return "kB"; };
-        unsigned long getMinValue() { return 0; };
-        unsigned long getMaxValue() { return UINT32_MAX; };
+        ULONG getMinValue() { return 0; };
+        ULONG getMaxValue() { return UINT32_MAX; };
     private:
         RTPROCESS  mProcess;
@@ -224 +224 @@
     {
     public:
-        virtual unsigned long compute(unsigned long *data, unsigned long length) = 0;
+        virtual ULONG compute(ULONG *data, ULONG length) = 0;
         virtual const char *getName() = 0;
     };
@@ -231 +231 @@
     {
     public:
-        virtual unsigned long compute(unsigned long *data, unsigned long length);
+        virtual ULONG compute(ULONG *data, ULONG length);
         virtual const char *getName();
     };
@@ -238 +238 @@
     {
     public:
-        virtual unsigned long compute(unsigned long *data, unsigned long length);
+        virtual ULONG compute(ULONG *data, ULONG length);
         virtual const char *getName();
     };
@@ -245 +245 @@
     {
     public:
-        virtual unsigned long compute(unsigned long *data, unsigned long length);
+        virtual ULONG compute(ULONG *data, ULONG length);
         virtual const char *getName();
     };
@@ -272 +272 @@
         ComPtr<IUnknown> getObject() { return mBaseMetric->getObject(); };
         const char *getUnit() { return mBaseMetric->getUnit(); };
-        unsigned long getMinValue() { return mBaseMetric->getMinValue(); };
-        unsigned long getMaxValue() { return mBaseMetric->getMaxValue(); };
-        unsigned long getPeriod() { return mBaseMetric->getPeriod(); };
-        unsigned long getLength() { return mAggregate ? 1 : mBaseMetric->getLength(); };
-        void query(unsigned long **data, unsigned long *count);
+        ULONG getMinValue() { return mBaseMetric->getMinValue(); };
+        ULONG getMaxValue() { return mBaseMetric->getMaxValue(); };
+        ULONG getPeriod() { return mBaseMetric->getPeriod(); };
+        ULONG getLength() { return mAggregate ? 1 : mBaseMetric->getLength(); };
+        void query(ULONG **data, ULONG *count);
 
     private:

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

@@ -34 +34 @@
 {
 public:
-    virtual int getHostCpuMHz(unsigned long *mhz);
-    virtual int getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available);
-    virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
+    virtual int getHostCpuMHz(ULONG *mhz);
+    virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+    virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *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 getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, unsigned long *memPagesUsed);
+    int getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, ULONG *memPagesUsed);
 };
 
@@ -57 +57 @@
 {
     int rc = VINF_SUCCESS;
-    unsigned long u32user, u32nice, u32kernel, u32idle;
+    ULONG u32user, u32nice, u32kernel, u32idle;
     FILE *f = fopen("/proc/stat", "r");
 
@@ -86 +86 @@
     if (RT_SUCCESS(rc))
     {
-        unsigned long ulTmp;
+        ULONG ulTmp;
         *total = (uint64_t)uHostUser + uHostKernel + uHostIdle;
         rc = getRawProcessStats(process, user, kernel, &ulTmp);
@@ -94 +94 @@
 }
 
-int CollectorLinux::getHostCpuMHz(unsigned long *mhz)
+int CollectorLinux::getHostCpuMHz(ULONG *mhz)
 {
     return E_NOTIMPL;
 }
 
-int CollectorLinux::getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available)
+int CollectorLinux::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
 {
     int rc = VINF_SUCCESS;
-    unsigned long buffers, cached;
+    ULONG buffers, cached;
     FILE *f = fopen("/proc/meminfo", "r");
 
@@ -126 +126 @@
 }
 
-int CollectorLinux::getProcessMemoryUsage(RTPROCESS process, unsigned long *used)
+int CollectorLinux::getProcessMemoryUsage(RTPROCESS process, ULONG *used)
 {
     uint64_t u64Tmp;
-    unsigned long nPagesUsed;
+    ULONG nPagesUsed;
     int rc = getRawProcessStats(process, &u64Tmp, &u64Tmp, &nPagesUsed);
     if (RT_SUCCESS(rc))
@@ -139 +139 @@
 }
 
-int CollectorLinux::getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, unsigned long *memPagesUsed)
+int CollectorLinux::getRawProcessStats(RTPROCESS process, uint64_t *cpuUser, uint64_t *cpuKernel, ULONG *memPagesUsed)
 {
     int rc = VINF_SUCCESS;
@@ -148 +148 @@
     uint64_t u64Tmp;
     unsigned uTmp;
-    unsigned long ulTmp, u32user, u32kernel;
+    ULONG ulTmp, u32user, u32kernel;
     char buf[80]; /* @todo: this should be tied to max allowed proc name. */
 

trunk/src/VBox/Main/os2/PerformanceOs2.cpp

@@ -29 +29 @@
 {
 public:
-    virtual int getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle);
-    virtual int getHostCpuMHz(unsigned long *mhz);
-    virtual int getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available);
-    virtual int getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel);
-    virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
+    virtual int getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle);
+    virtual int getHostCpuMHz(ULONG *mhz);
+    virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+    virtual int getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel);
+    virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used);
 };
 
@@ -43 +43 @@
 }
 
-int CollectorOS2::getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
+int CollectorOS2::getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle)
 {
     return E_NOTIMPL;
 }
 
-int CollectorOS2::getHostCpuMHz(unsigned long *mhz)
+int CollectorOS2::getHostCpuMHz(ULONG *mhz)
 {
     return E_NOTIMPL;
 }
 
-int CollectorOS2::getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available)
+int CollectorOS2::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
 {
     return E_NOTIMPL;
 }
 
-int CollectorOS2::getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
+int CollectorOS2::getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel)
 {
     return E_NOTIMPL;
 }
 
-int CollectorOS2::getProcessMemoryUsage(RTPROCESS process, unsigned long *used)
+int CollectorOS2::getProcessMemoryUsage(RTPROCESS process, ULONG *used)
 {
     return E_NOTIMPL;

trunk/src/VBox/Main/solaris/PerformanceSolaris.cpp

@@ -45 +45 @@
     CollectorSolaris();
     ~CollectorSolaris();
-    virtual int getHostCpuMHz(unsigned long *mhz);
-    virtual int getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available);
-    virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
+    virtual int getHostCpuMHz(ULONG *mhz);
+    virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+    virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used);
 
     virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
@@ -164 +164 @@
 }
 
-int CollectorSolaris::getHostCpuMHz(unsigned long *mhz)
+int CollectorSolaris::getHostCpuMHz(ULONG *mhz)
 {
     return VERR_NOT_IMPLEMENTED;
 }
 
-int CollectorSolaris::getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available)
+int CollectorSolaris::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
 {
     int rc = VINF_SUCCESS;
@@ -199 +199 @@
     return rc;
 }
-int CollectorSolaris::getProcessMemoryUsage(RTPROCESS process, unsigned long *used)
+int CollectorSolaris::getProcessMemoryUsage(RTPROCESS process, ULONG *used)
 {
     int rc = VINF_SUCCESS;

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

@@ -36 +36 @@
     ~CollectorWin();
 
-    virtual int getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle);
-    virtual int getHostCpuMHz(unsigned long *mhz);
-    virtual int getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available);
-    virtual int getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel);
-    virtual int getProcessMemoryUsage(RTPROCESS process, unsigned long *used);
+    virtual int getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle);
+    virtual int getHostCpuMHz(ULONG *mhz);
+    virtual int getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available);
+    virtual int getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel);
+    virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used);
 
     virtual int getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle);
@@ -261 +261 @@
 }
 
-int CollectorWin::getHostCpuLoad(unsigned long *user, unsigned long *kernel, unsigned long *idle)
+int CollectorWin::getHostCpuLoad(ULONG *user, ULONG *kernel, ULONG *idle)
 {
     return VERR_NOT_IMPLEMENTED;
@@ -334 +334 @@
 }
 
-int CollectorWin::getHostCpuMHz(unsigned long *mhz)
+int CollectorWin::getHostCpuMHz(ULONG *mhz)
 {
     return VERR_NOT_IMPLEMENTED;
 }
 
-int CollectorWin::getHostMemoryUsage(unsigned long *total, unsigned long *used, unsigned long *available)
+int CollectorWin::getHostMemoryUsage(ULONG *total, ULONG *used, ULONG *available)
 {
     MEMORYSTATUSEX mstat;
@@ -346 +346 @@
     if (GlobalMemoryStatusEx(&mstat))
     {
-        *total = (unsigned long)( mstat.ullTotalPhys / 1000 );
-        *available = (unsigned long)( mstat.ullAvailPhys / 1000 );
+        *total = (ULONG)( mstat.ullTotalPhys / 1000 );
+        *available = (ULONG)( mstat.ullAvailPhys / 1000 );
         *used = *total - *available;
     }
@@ -356 +356 @@
 }
 
-int CollectorWin::getProcessCpuLoad(RTPROCESS process, unsigned long *user, unsigned long *kernel)
+int CollectorWin::getProcessCpuLoad(RTPROCESS process, ULONG *user, ULONG *kernel)
 {
     return VERR_NOT_IMPLEMENTED;
@@ -430 +430 @@
 }
 
-int CollectorWin::getProcessMemoryUsage(RTPROCESS process, unsigned long *used)
+int CollectorWin::getProcessMemoryUsage(RTPROCESS process, ULONG *used)
 {
     HRESULT hr;
@@ -472 +472 @@
                 return VERR_INTERNAL_ERROR;
             }
-            *used = (unsigned long)(u64used / 1024);
+            *used = (ULONG)(u64used / 1024);
             rc = VINF_SUCCESS;
         }