c++ - प्रक्रिया के अंदर से सीपीयू और मेमोरी खपत कैसे निर्धारित करें?




memory cpu (7)

मुझे एक बार चल रहे एप्लिकेशन के अंदर से निम्नलिखित प्रदर्शन पैरामीटर निर्धारित करने का कार्य था:

  • कुल वर्चुअल मेमोरी उपलब्ध है
  • वर्तमान में वर्चुअल मेमोरी का इस्तेमाल किया गया
  • वर्चुअल मेमोरी वर्तमान में मेरी प्रक्रिया द्वारा उपयोग की जाती है
  • कुल रैम उपलब्ध है
  • रैम वर्तमान में इस्तेमाल किया
  • रैम वर्तमान में मेरी प्रक्रिया द्वारा उपयोग किया जाता है
  • वर्तमान में इस्तेमाल% सीपीयू
  • वर्तमान में मेरी प्रक्रिया द्वारा उपयोग किया जाने वाला% सीपीयू

कोड को विंडोज और लिनक्स पर चलाना पड़ा। हालांकि यह एक मानक कार्य प्रतीत होता है, मैनुअल (WIN32 API, GNU दस्तावेज़) के साथ-साथ इंटरनेट पर आवश्यक जानकारी ढूंढने से मुझे कई दिन लगे, क्योंकि इस विषय पर इतनी अपूर्ण / गलत / पुरानी जानकारी है वहाँ पता चला।

दूसरों को एक ही परेशानी से गुज़रने से बचाने के लिए, मैंने सोचा कि सभी बिखरी हुई जानकारी एकत्र करने के लिए एक अच्छा विचार होगा और जो मैंने एक स्थान पर परीक्षण और त्रुटि से पाया है।


QNX

चूंकि यह "कोड का विकिपीज" जैसा है, मैं क्यूएनएक्स नॉलेज बेस से कुछ कोड जोड़ना चाहता हूं (नोट: यह मेरा काम नहीं है, लेकिन मैंने इसे चेक किया और यह मेरे सिस्टम पर ठीक काम करता है):

% में CPU उपयोग कैसे प्राप्त करें: http://www.qnx.com/support/knowledgebase.html?id=50130000000P9b5

#include <atomic.h>
#include <libc.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/iofunc.h>
#include <sys/neutrino.h>
#include <sys/resmgr.h>
#include <sys/syspage.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/debug.h>
#include <sys/procfs.h>
#include <sys/syspage.h>
#include <sys/neutrino.h>
#include <sys/time.h>
#include <time.h>
#include <fcntl.h>
#include <devctl.h>
#include <errno.h>

#define MAX_CPUS 32

static float Loads[MAX_CPUS];
static _uint64 LastSutime[MAX_CPUS];
static _uint64 LastNsec[MAX_CPUS];
static int ProcFd = -1;
static int NumCpus = 0;


int find_ncpus(void) {
    return NumCpus;
}

int get_cpu(int cpu) {
    int ret;
    ret = (int)Loads[ cpu % MAX_CPUS ];
    ret = max(0,ret);
    ret = min(100,ret);
    return( ret );
}

static _uint64 nanoseconds( void ) {
    _uint64 sec, usec;
    struct timeval tval;
    gettimeofday( &tval, NULL );
    sec = tval.tv_sec;
    usec = tval.tv_usec;
    return( ( ( sec * 1000000 ) + usec ) * 1000 );
}

int sample_cpus( void ) {
    int i;
    debug_thread_t debug_data;
    _uint64 current_nsec, sutime_delta, time_delta;
    memset( &debug_data, 0, sizeof( debug_data ) );

    for( i=0; i<NumCpus; i++ ) {
        /* Get the sutime of the idle thread #i+1 */
        debug_data.tid = i + 1;
        devctl( ProcFd, DCMD_PROC_TIDSTATUS,
        &debug_data, sizeof( debug_data ), NULL );
        /* Get the current time */
        current_nsec = nanoseconds();
        /* Get the deltas between now and the last samples */
        sutime_delta = debug_data.sutime - LastSutime[i];
        time_delta = current_nsec - LastNsec[i];
        /* Figure out the load */
        Loads[i] = 100.0 - ( (float)( sutime_delta * 100 ) / (float)time_delta );
        /* Flat out strange rounding issues. */
        if( Loads[i] < 0 ) {
            Loads[i] = 0;
        }
        /* Keep these for reference in the next cycle */
        LastNsec[i] = current_nsec;
        LastSutime[i] = debug_data.sutime;
    }
    return EOK;
}

int init_cpu( void ) {
    int i;
    debug_thread_t debug_data;
    memset( &debug_data, 0, sizeof( debug_data ) );
/* Open a connection to proc to talk over.*/
    ProcFd = open( "/proc/1/as", O_RDONLY );
    if( ProcFd == -1 ) {
        fprintf( stderr, "pload: Unable to access procnto: %s\n",strerror( errno ) );
        fflush( stderr );
        return -1;
    }
    i = fcntl(ProcFd,F_GETFD);
    if(i != -1){
        i |= FD_CLOEXEC;
        if(fcntl(ProcFd,F_SETFD,i) != -1){
            /* Grab this value */
            NumCpus = _syspage_ptr->num_cpu;
            /* Get a starting point for the comparisons */
            for( i=0; i<NumCpus; i++ ) {
                /*
                * the sutime of idle thread is how much
                * time that thread has been using, we can compare this
                * against how much time has passed to get an idea of the
                * load on the system.
                */
                debug_data.tid = i + 1;
                devctl( ProcFd, DCMD_PROC_TIDSTATUS, &debug_data, sizeof( debug_data ), NULL );
                LastSutime[i] = debug_data.sutime;
                LastNsec[i] = nanoseconds();
            }
            return(EOK);
        }
    }
    close(ProcFd);
    return(-1);
}

void close_cpu(void){
    if(ProcFd != -1){
        close(ProcFd);
        ProcFd = -1;
    }
}

int main(int argc, char* argv[]){
    int i,j;
    init_cpu();
    printf("System has: %d CPUs\n", NumCpus);
    for(i=0; i<20; i++) {
        sample_cpus();
        for(j=0; j<NumCpus;j++)
        printf("CPU #%d: %f\n", j, Loads[j]);
        sleep(1);
    }
    close_cpu();
}

मुफ्त (!) मेमोरी कैसे प्राप्त करें: http://www.qnx.com/support/knowledgebase.html?id=50130000000mlbx

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <err.h>
#include <sys/stat.h>
#include <sys/types.h>

int main( int argc, char *argv[] ){
    struct stat statbuf;
    paddr_t freemem;
    stat( "/proc", &statbuf );
    freemem = (paddr_t)statbuf.st_size;
    printf( "Free memory: %d bytes\n", freemem );
    printf( "Free memory: %d KB\n", freemem / 1024 );
    printf( "Free memory: %d MB\n", freemem / ( 1024 * 1024 ) );
    return 0;
} 

मैक ओएस एक्स

मैं मैक ओएस एक्स के लिए भी इसी तरह की जानकारी ढूंढने की उम्मीद कर रहा था। चूंकि यह यहां नहीं था, इसलिए मैं बाहर गया और इसे खुद खोद गया। मुझे मिली कुछ चीज़ें यहां दी गई हैं। अगर किसी के पास कोई अन्य सुझाव है, तो मुझे उन्हें सुनना अच्छा लगेगा।

कुल वर्चुअल मेमोरी

यह मैक ओएस एक्स पर मुश्किल है क्योंकि यह प्रीसेट स्वैप विभाजन या लिनक्स जैसी फ़ाइल का उपयोग नहीं करता है। ऐप्पल के दस्तावेज़ से एक प्रविष्टि यहां दी गई है:

नोट: अधिकांश यूनिक्स-आधारित ऑपरेटिंग सिस्टम के विपरीत, मैक ओएस एक्स वर्चुअल मेमोरी के लिए प्रीलोकेटेड स्वैप विभाजन का उपयोग नहीं करता है। इसके बजाए, यह मशीन के बूट विभाजन पर उपलब्ध सभी जगहों का उपयोग करता है।

इसलिए, यदि आप जानना चाहते हैं कि वर्चुअल मेमोरी अभी भी कितनी उपलब्ध है, तो आपको रूट विभाजन का आकार प्राप्त करने की आवश्यकता है। आप ऐसा कर सकते हैं:

struct statfs stats;
if (0 == statfs("/", &stats))
{
    myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}

कुल वर्चुअल वर्तमान में प्रयुक्त

"Vm.swapusage" कुंजी के साथ कॉलिंग systcl स्वैप उपयोग के बारे में दिलचस्प जानकारी प्रदान करता है:

sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M  used = 2511.78M  free = 560.22M  (encrypted)

यह नहीं कि उपरोक्त अनुभाग में बताए गए अनुसार कुल स्वैप उपयोग यहां बदल सकता है यदि अधिक स्वैप की आवश्यकता है। तो कुल वास्तव में वर्तमान स्वैप कुल है। सी ++ में, इस डेटा को इस तरह से पूछताछ की जा सकती है:

xsw_usage vmusage = {0};
size_t size = sizeof(vmusage);
if( sysctlbyname("vm.swapusage", &vmusage, &size, NULL, 0)!=0 )
{
   perror( "unable to get swap usage by calling sysctlbyname(\"vm.swapusage\",...)" );
}

ध्यान दें कि "xsw_usage", sysctl.h में घोषित, प्रतीत नहीं होता है और मुझे संदेह है कि इन मानों तक पहुंचने का एक और पोर्टेबल तरीका है।

वर्चुअल मेमोरी वर्तमान में मेरी प्रक्रिया द्वारा उपयोग की जाती है

आप task_info फ़ंक्शन का उपयोग करके अपनी वर्तमान प्रक्रिया के बारे में आंकड़े प्राप्त कर सकते हैं। इसमें आपकी प्रक्रिया का वर्तमान निवासी आकार और वर्तमान आभासी आकार शामिल है।

#include<mach/mach.h>

struct task_basic_info t_info;
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

if (KERN_SUCCESS != task_info(mach_task_self(),
                              TASK_BASIC_INFO, (task_info_t)&t_info, 
                              &t_info_count))
{
    return -1;
}
// resident size is in t_info.resident_size;
// virtual size is in t_info.virtual_size;

कुल रैम उपलब्ध है

आपके सिस्टम में उपलब्ध भौतिक रैम की मात्रा sysctl सिस्टम फ़ंक्शन का उपयोग करके उपलब्ध है:

#include <sys/types.h>
#include <sys/sysctl.h>
...
int mib[2];
int64_t physical_memory;
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(int64_t);
sysctl(mib, 2, &physical_memory, &length, NULL, 0);

रैम वर्तमान में प्रयुक्त

आप host_statistics सिस्टम फ़ंक्शन से सामान्य मेमोरी आंकड़े प्राप्त कर सकते हैं।

#include <mach/vm_statistics.h>
#include <mach/mach_types.h>
#include <mach/mach_init.h>
#include <mach/mach_host.h>

int main(int argc, const char * argv[]) {
    vm_size_t page_size;
    mach_port_t mach_port;
    mach_msg_type_number_t count;
    vm_statistics64_data_t vm_stats;

    mach_port = mach_host_self();
    count = sizeof(vm_stats) / sizeof(natural_t);
    if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
        KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
                                        (host_info64_t)&vm_stats, &count))
    {
        long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;

        long long used_memory = ((int64_t)vm_stats.active_count +
                                 (int64_t)vm_stats.inactive_count +
                                 (int64_t)vm_stats.wire_count) *  (int64_t)page_size;
        printf("free memory: %lld\nused memory: %lld\n", free_memory, used_memory);
    }

    return 0;
}

यहां ध्यान देने योग्य बात यह है कि मैक ओएस एक्स में पांच प्रकार के मेमोरी पेज हैं। वे निम्नानुसार हैं:

  1. वायर्ड पेज जो जगह में बंद हैं और उन्हें स्वैप नहीं किया जा सकता है
  2. सक्रिय पृष्ठ जो भौतिक स्मृति में लोड हो रहे हैं और स्वैप करना अपेक्षाकृत कठिन होगा
  3. निष्क्रिय पृष्ठ जो स्मृति में लोड होते हैं, लेकिन हाल ही में इसका उपयोग नहीं किया गया है और यहां तक ​​कि इसकी आवश्यकता भी नहीं हो सकती है। ये स्वैपिंग के लिए संभावित उम्मीदवार हैं। इस स्मृति को शायद फ्लश करने की आवश्यकता होगी।
  4. कैश किए गए पृष्ठ जो कुछ कैश किए गए हैं जिन्हें आसानी से पुन: उपयोग किया जा सकता है। कैश्ड मेमोरी शायद फ्लशिंग की आवश्यकता नहीं होगी। कैश किए गए पृष्ठों को पुनः सक्रिय करने के लिए अभी भी संभव है
  5. मुफ्त पेज जो पूरी तरह से स्वतंत्र हैं और उपयोग किए जाने के लिए तैयार हैं।

यह ध्यान रखना अच्छा होता है कि सिर्फ इसलिए कि मैक ओएस एक्स बहुत कम वास्तविक मुक्त स्मृति दिखा सकता है कि यह कम संकेत पर उपयोग करने के लिए तैयार होने का एक अच्छा संकेत नहीं हो सकता है।

रैम वर्तमान में मेरी प्रक्रिया द्वारा उपयोग किया जाता है

उपरोक्त "मेरी प्रक्रिया द्वारा वर्तमान में उपयोग की जाने वाली वर्चुअल मेमोरी" देखें। एक ही कोड लागू होता है।


लिनक्स

स्मृति और लोड संख्याओं को पढ़ने का एक पोर्टेबल तरीका sysinfo कॉल है

प्रयोग

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

विवरण

   Until Linux 2.3.16, sysinfo() used to return information in the
   following structure:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           char _f[22];             /* Pads structure to 64 bytes */
       };

   and the sizes were given in bytes.

   Since Linux 2.3.23 (i386), 2.3.48 (all architectures) the structure
   is:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           unsigned long totalhigh; /* Total high memory size */
           unsigned long freehigh;  /* Available high memory size */
           unsigned int mem_unit;   /* Memory unit size in bytes */
           char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
       };

   and the sizes are given as multiples of mem_unit bytes.

विंडोज

उपर्युक्त मानों में से कुछ उचित WIN32 API से आसानी से उपलब्ध हैं, मैं उन्हें पूर्णता के लिए यहां सूचीबद्ध करता हूं। हालांकि, दूसरों को प्रदर्शन डेटा हेल्पर लाइब्रेरी (पीडीएच) से प्राप्त करने की आवश्यकता है, जो थोड़ा "अनजान" है और काम करने के लिए बहुत दर्दनाक परीक्षण और त्रुटि लेता है। (कम से कम यह मुझे थोड़ी देर ले गया, शायद मैं केवल थोड़ा बेवकूफ रहा हूँ ...)

नोट: स्पष्टता के लिए निम्नलिखित त्रुटि से सभी त्रुटि जांच को छोड़ दिया गया है। रिटर्न कोड की जांच करें ...!


  • कुल वर्चुअल मेमोरी:

    #include "windows.h"
    
    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile;
    

    नोट: "TotalPageFile" नाम यहां थोड़ा भ्रामक है। हकीकत में यह पैरामीटर "वर्चुअल मेमोरी साइज" देता है, जो स्वैप फ़ाइल का आकार है और इंस्टॉल रैम है।

  • वर्तमान में वर्चुअल मेमोरी का उपयोग किया गया

    "कुल वर्चुअल मेमोरी" और उसके बाद समान कोड

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;
    
  • वर्चुअल मेमोरी वर्तमान में वर्तमान प्रक्रिया द्वारा उपयोग की जाती है:

    #include "windows.h"
    #include "psapi.h"
    
    PROCESS_MEMORY_COUNTERS_EX pmc;
    GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
    SIZE_T virtualMemUsedByMe = pmc.PrivateUsage;
    



  • कुल शारीरिक मेमोरी (रैम):

    "कुल वर्चुअल मेमोरी" और उसके बाद समान कोड

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;
    
  • वर्तमान में उपयोग की जाने वाली भौतिक मेमोरी:

    Same code as in "Total Virtual Memory" and then
    
    DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
    
  • वर्तमान में वर्तमान प्रक्रिया द्वारा उपयोग की जाने वाली भौतिक मेमोरी:

    "वर्तमान प्रक्रिया द्वारा वर्तमान में उपयोग की जाने वाली वर्चुअल मेमोरी" के समान कोड और फिर

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;
    



  • सीपीयू वर्तमान में इस्तेमाल किया गया:

    #include "TCHAR.h"
    #include "pdh.h"
    
    static PDH_HQUERY cpuQuery;
    static PDH_HCOUNTER cpuTotal;
    
    void init(){
        PdhOpenQuery(NULL, NULL, &cpuQuery);
        // You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()
        PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
        PdhCollectQueryData(cpuQuery);
    }
    
    double getCurrentValue(){
        PDH_FMT_COUNTERVALUE counterVal;
    
        PdhCollectQueryData(cpuQuery);
        PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
        return counterVal.doubleValue;
    }
    
  • सीपीयू वर्तमान में वर्तमान प्रक्रिया द्वारा उपयोग किया जाता है:

    #include "windows.h"
    
    static ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
    static int numProcessors;
    static HANDLE self;
    
    void init(){
        SYSTEM_INFO sysInfo;
        FILETIME ftime, fsys, fuser;
    
        GetSystemInfo(&sysInfo);
        numProcessors = sysInfo.dwNumberOfProcessors;
    
        GetSystemTimeAsFileTime(&ftime);
        memcpy(&lastCPU, &ftime, sizeof(FILETIME));
    
        self = GetCurrentProcess();
        GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
        memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));
        memcpy(&lastUserCPU, &fuser, sizeof(FILETIME));
    }
    
    double getCurrentValue(){
        FILETIME ftime, fsys, fuser;
        ULARGE_INTEGER now, sys, user;
        double percent;
    
        GetSystemTimeAsFileTime(&ftime);
        memcpy(&now, &ftime, sizeof(FILETIME));
    
        GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
        memcpy(&sys, &fsys, sizeof(FILETIME));
        memcpy(&user, &fuser, sizeof(FILETIME));
        percent = (sys.QuadPart - lastSysCPU.QuadPart) +
            (user.QuadPart - lastUserCPU.QuadPart);
        percent /= (now.QuadPart - lastCPU.QuadPart);
        percent /= numProcessors;
        lastCPU = now;
        lastUserCPU = user;
        lastSysCPU = sys;
    
        return percent * 100;
    }
    

लिनक्स

लिनक्स पर पहली बार जो स्पष्ट लग रहा था वह पॉज़िक्स एपीआई जैसे गेट्रेजेज () इत्यादि का उपयोग करना था। मैंने इसे काम करने के लिए कुछ समय बिताया, लेकिन सार्थक मूल्य कभी नहीं मिला। जब मैंने आखिर में कर्नेल स्रोतों की जांच की, तो मुझे पता चला कि स्पष्ट रूप से ये एपीआई अभी तक पूरी तरह से लिनक्स कर्नेल 2.6 के रूप में लागू नहीं हैं !?

अंत में मुझे छद्म-फाइल सिस्टम / प्रो और कर्नेल कॉल पढ़ने के संयोजन के माध्यम से सभी मूल्य मिल गए।

  • कुल वर्चुअल मेमोरी:

    #include "sys/types.h"
    #include "sys/sysinfo.h"
    
    struct sysinfo memInfo;
    
    sysinfo (&memInfo);
    long long totalVirtualMem = memInfo.totalram;
    //Add other values in next statement to avoid int overflow on right hand side...
    totalVirtualMem += memInfo.totalswap;
    totalVirtualMem *= memInfo.mem_unit;
    
  • वर्तमान में वर्चुअल मेमोरी का उपयोग किया गया

    "कुल वर्चुअल मेमोरी" और उसके बाद समान कोड

    long long virtualMemUsed = memInfo.totalram - memInfo.freeram;
    //Add other values in next statement to avoid int overflow on right hand side...
    virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
    virtualMemUsed *= memInfo.mem_unit;
    
  • वर्चुअल मेमोरी वर्तमान में वर्तमान प्रक्रिया द्वारा उपयोग की जाती है:

    #include "stdlib.h"
    #include "stdio.h"
    #include "string.h"
    
    int parseLine(char* line){
        // This assumes that a digit will be found and the line ends in " Kb".
        int i = strlen(line);
        const char* p = line;
        while (*p <'0' || *p > '9') p++;
        line[i-3] = '\0';
        i = atoi(p);
        return i;
    }
    
    int getValue(){ //Note: this value is in KB!
        FILE* file = fopen("/proc/self/status", "r");
        int result = -1;
        char line[128];
    
        while (fgets(line, 128, file) != NULL){
            if (strncmp(line, "VmSize:", 7) == 0){
                result = parseLine(line);
                break;
            }
        }
        fclose(file);
        return result;
    }
    



  • कुल शारीरिक मेमोरी (रैम):

    "कुल वर्चुअल मेमोरी" और उसके बाद समान कोड

    long long totalPhysMem = memInfo.totalram;
    //Multiply in next statement to avoid int overflow on right hand side...
    totalPhysMem *= memInfo.mem_unit;
    
  • वर्तमान में उपयोग की जाने वाली भौतिक मेमोरी:

    "कुल वर्चुअल मेमोरी" और उसके बाद समान कोड

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
    //Multiply in next statement to avoid int overflow on right hand side...
    physMemUsed *= memInfo.mem_unit;
    
  • वर्तमान में वर्तमान प्रक्रिया द्वारा उपयोग की जाने वाली भौतिक मेमोरी:

    GetValue () को "वर्तमान प्रक्रिया द्वारा वर्तमान में उपयोग की जाने वाली वर्चुअल मेमोरी" में निम्नानुसार बदलें:

    int getValue(){ //Note: this value is in KB!
        FILE* file = fopen("/proc/self/status", "r");
        int result = -1;
        char line[128];
    
        while (fgets(line, 128, file) != NULL){
            if (strncmp(line, "VmRSS:", 6) == 0){
                result = parseLine(line);
                break;
            }
        }
        fclose(file);
        return result;
    }
    



  • सीपीयू वर्तमान में इस्तेमाल किया गया:

    #include "stdlib.h"
    #include "stdio.h"
    #include "string.h"
    
    static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;
    
    void init(){
        FILE* file = fopen("/proc/stat", "r");
        fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow,
            &lastTotalSys, &lastTotalIdle);
        fclose(file);
    }
    
    double getCurrentValue(){
        double percent;
        FILE* file;
        unsigned long long totalUser, totalUserLow, totalSys, totalIdle, total;
    
        file = fopen("/proc/stat", "r");
        fscanf(file, "cpu %llu %llu %llu %llu", &totalUser, &totalUserLow,
            &totalSys, &totalIdle);
        fclose(file);
    
        if (totalUser < lastTotalUser || totalUserLow < lastTotalUserLow ||
            totalSys < lastTotalSys || totalIdle < lastTotalIdle){
            //Overflow detection. Just skip this value.
            percent = -1.0;
        }
        else{
            total = (totalUser - lastTotalUser) + (totalUserLow - lastTotalUserLow) +
                (totalSys - lastTotalSys);
            percent = total;
            total += (totalIdle - lastTotalIdle);
            percent /= total;
            percent *= 100;
        }
    
        lastTotalUser = totalUser;
        lastTotalUserLow = totalUserLow;
        lastTotalSys = totalSys;
        lastTotalIdle = totalIdle;
    
        return percent;
    }
    
  • सीपीयू वर्तमान में वर्तमान प्रक्रिया द्वारा उपयोग किया जाता है:

    #include "stdlib.h"
    #include "stdio.h"
    #include "string.h"
    #include "sys/times.h"
    #include "sys/vtimes.h"
    
    static clock_t lastCPU, lastSysCPU, lastUserCPU;
    static int numProcessors;
    
    void init(){
        FILE* file;
        struct tms timeSample;
        char line[128];
    
        lastCPU = times(&timeSample);
        lastSysCPU = timeSample.tms_stime;
        lastUserCPU = timeSample.tms_utime;
    
        file = fopen("/proc/cpuinfo", "r");
        numProcessors = 0;
        while(fgets(line, 128, file) != NULL){
            if (strncmp(line, "processor", 9) == 0) numProcessors++;
        }
        fclose(file);
    }
    
    double getCurrentValue(){
        struct tms timeSample;
        clock_t now;
        double percent;
    
        now = times(&timeSample);
        if (now <= lastCPU || timeSample.tms_stime < lastSysCPU ||
            timeSample.tms_utime < lastUserCPU){
            //Overflow detection. Just skip this value.
            percent = -1.0;
        }
        else{
            percent = (timeSample.tms_stime - lastSysCPU) +
                (timeSample.tms_utime - lastUserCPU);
            percent /= (now - lastCPU);
            percent /= numProcessors;
            percent *= 100;
        }
        lastCPU = now;
        lastSysCPU = timeSample.tms_stime;
        lastUserCPU = timeSample.tms_utime;
    
        return percent;
    }
    

TODO: अन्य प्लेटफार्म

मुझे लगता है कि कुछ लिनक्स कोड यूनिक्स के लिए भी काम करता है, जो कि / proc छद्म-फाइल सिस्टम को पढ़ने वाले हिस्सों को छोड़कर करता है। शायद यूनिक्स पर इन हिस्सों को गेट्रेजेज () और इसी तरह के कार्यों द्वारा प्रतिस्थापित किया जा सकता है? अगर यूनिक्स के साथ कोई व्यक्ति जानता है कि यह जवाब कैसे संपादित कर सकता है और विवरण भर सकता है ?!


खिड़कियों में आप कोड bpo द्वारा cpu उपयोग प्राप्त कर सकते हैं:

#include <windows.h>
#include <stdio.h>

    //------------------------------------------------------------------------------------------------------------------
    // Prototype(s)...
    //------------------------------------------------------------------------------------------------------------------
    CHAR cpuusage(void);

    //-----------------------------------------------------
    typedef BOOL ( __stdcall * pfnGetSystemTimes)( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
    static pfnGetSystemTimes s_pfnGetSystemTimes = NULL;

    static HMODULE s_hKernel = NULL;
    //-----------------------------------------------------
    void GetSystemTimesAddress()
    {
        if( s_hKernel == NULL )
        {   
            s_hKernel = LoadLibrary( L"Kernel32.dll" );
            if( s_hKernel != NULL )
            {
                s_pfnGetSystemTimes = (pfnGetSystemTimes)GetProcAddress( s_hKernel, "GetSystemTimes" );
                if( s_pfnGetSystemTimes == NULL )
                {
                    FreeLibrary( s_hKernel ); s_hKernel = NULL;
                }
            }
        }
    }
    //----------------------------------------------------------------------------------------------------------------

    //----------------------------------------------------------------------------------------------------------------
    // cpuusage(void)
    // ==============
    // Return a CHAR value in the range 0 - 100 representing actual CPU usage in percent.
    //----------------------------------------------------------------------------------------------------------------
    CHAR cpuusage()
    {
        FILETIME               ft_sys_idle;
        FILETIME               ft_sys_kernel;
        FILETIME               ft_sys_user;

        ULARGE_INTEGER         ul_sys_idle;
        ULARGE_INTEGER         ul_sys_kernel;
        ULARGE_INTEGER         ul_sys_user;

        static ULARGE_INTEGER    ul_sys_idle_old;
        static ULARGE_INTEGER  ul_sys_kernel_old;
        static ULARGE_INTEGER  ul_sys_user_old;

        CHAR  usage = 0;

        // we cannot directly use GetSystemTimes on C language
        /* add this line :: pfnGetSystemTimes */
        s_pfnGetSystemTimes(&ft_sys_idle,    /* System idle time */
            &ft_sys_kernel,  /* system kernel time */
            &ft_sys_user);   /* System user time */

        CopyMemory(&ul_sys_idle  , &ft_sys_idle  , sizeof(FILETIME)); // Could been optimized away...
        CopyMemory(&ul_sys_kernel, &ft_sys_kernel, sizeof(FILETIME)); // Could been optimized away...
        CopyMemory(&ul_sys_user  , &ft_sys_user  , sizeof(FILETIME)); // Could been optimized away...

        usage  =
            (
            (
            (
            (
            (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
            (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
            )
            -
            (ul_sys_idle.QuadPart-ul_sys_idle_old.QuadPart)
            )
            *
            (100)
            )
            /
            (
            (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
            (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
            )
            );

        ul_sys_idle_old.QuadPart   = ul_sys_idle.QuadPart;
        ul_sys_user_old.QuadPart   = ul_sys_user.QuadPart;
        ul_sys_kernel_old.QuadPart = ul_sys_kernel.QuadPart;

        return usage;
    }
    //------------------------------------------------------------------------------------------------------------------
    // Entry point
    //------------------------------------------------------------------------------------------------------------------
    int main(void)
    {
        int n;
        GetSystemTimesAddress();
        for(n=0;n<20;n++)
        {
            printf("CPU Usage: %3d%%\r",cpuusage());
            Sleep(2000);
        }
        printf("\n");
        return 0;
    }

मैक ओएस एक्स - सीपीयू

कुल मिलाकर सीपीयू उपयोग:

मैकोज़ एक्स पर सिस्टम जानकारी पुनर्प्राप्त करने से ? :

#include <mach/mach_init.h>
#include <mach/mach_error.h>
#include <mach/mach_host.h>
#include <mach/vm_map.h>

static unsigned long long _previousTotalTicks = 0;
static unsigned long long _previousIdleTicks = 0;

// Returns 1.0f for "CPU fully pinned", 0.0f for "CPU idle", or somewhere in between
// You'll need to call this at regular intervals, since it measures the load between
// the previous call and the current one.
float GetCPULoad()
{
   host_cpu_load_info_data_t cpuinfo;
   mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
   if (host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)&cpuinfo, &count) == KERN_SUCCESS)
   {
      unsigned long long totalTicks = 0;
      for(int i=0; i<CPU_STATE_MAX; i++) totalTicks += cpuinfo.cpu_ticks[i];
      return CalculateCPULoad(cpuinfo.cpu_ticks[CPU_STATE_IDLE], totalTicks);
   }
   else return -1.0f;
}

float CalculateCPULoad(unsigned long long idleTicks, unsigned long long totalTicks)
{
  unsigned long long totalTicksSinceLastTime = totalTicks-_previousTotalTicks;
  unsigned long long idleTicksSinceLastTime  = idleTicks-_previousIdleTicks;
  float ret = 1.0f-((totalTicksSinceLastTime > 0) ? ((float)idleTicksSinceLastTime)/totalTicksSinceLastTime : 0);
  _previousTotalTicks = totalTicks;
  _previousIdleTicks  = idleTicks;
  return ret;
}

यदि आप सीधे कोड में करना चाहते हैं तो आपको कर्नेल मॉड्यूल लिखना होगा (चूंकि यह सीधे कर्नेल में डेटा संरचनाओं तक पहुंच रहा है:

चल रही प्रक्रियाओं को सूचीबद्ध करने के लिए लिनक्स एपीआई देखें ? और https://linuxgazette.net/133/saha.html





cpu