সি ++ ব্যবহার করে রানটাইমে মেমরির ব্যবহার কীভাবে পাবেন?

Question 1

আমার প্রোগ্রামটি চলাকালীন আমার মেমের ব্যবহার ভিআইআরটি এবং আরএসই নেওয়া এবং সেগুলি প্রদর্শন করা দরকার।

আমি এখন পর্যন্ত যা চেষ্টা করেছি:

getrusage ( http://linux.die.net/man/2/getrusage )

int who = RUSAGE_SELF; 
struct rusage usage; 
int ret; 

ret=getrusage(who,&usage);

cout<<usage.ru_maxrss;

তবে আমি সর্বদা 0 পাই

Question 2

লিনাক্সে, আমি কখনই একটি আইওএসটিএল () সমাধান খুঁজে পাইনি । আমাদের অ্যাপ্লিকেশনগুলির জন্য, আমরা / প্রোক / পিডে ফাইলগুলি পড়ার উপর ভিত্তি করে একটি সাধারণ ইউটিলিটি রুটিন কোড করেছি । এই ফাইলগুলির একটি রয়েছে যা বিভিন্ন ফলাফল দেয়। এখানে আমরা স্থিতিযুক্ত একটি এখানে রয়েছে (প্রশ্নটি সি ++ ট্যাগ করা হয়েছিল, এবং আমরা সি ++ কনস্ট্রাক্ট ব্যবহার করে I / O পরিচালনা করেছি, তবে আপনার যদি প্রয়োজন হয় তবে এটি সহজেই I / O রুটিনগুলির সাথে মানিয়ে নেওয়া উচিত):

#include <unistd.h>
#include <ios>
#include <iostream>
#include <fstream>
#include <string>

//////////////////////////////////////////////////////////////////////////////
//
// process_mem_usage(double &, double &) - takes two doubles by reference,
// attempts to read the system-dependent data for a process' virtual memory
// size and resident set size, and return the results in KB.
//
// On failure, returns 0.0, 0.0

void process_mem_usage(double& vm_usage, double& resident_set)
{
   using std::ios_base;
   using std::ifstream;
   using std::string;

   vm_usage     = 0.0;
   resident_set = 0.0;

   // 'file' stat seems to give the most reliable results
   //
   ifstream stat_stream("/proc/self/stat",ios_base::in);

   // dummy vars for leading entries in stat that we don't care about
   //
   string pid, comm, state, ppid, pgrp, session, tty_nr;
   string tpgid, flags, minflt, cminflt, majflt, cmajflt;
   string utime, stime, cutime, cstime, priority, nice;
   string O, itrealvalue, starttime;

   // the two fields we want
   //
   unsigned long vsize;
   long rss;

   stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
               >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
               >> utime >> stime >> cutime >> cstime >> priority >> nice
               >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest

   stat_stream.close();

   long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
   vm_usage     = vsize / 1024.0;
   resident_set = rss * page_size_kb;
}

int main()
{
   using std::cout;
   using std::endl;

   double vm, rss;
   process_mem_usage(vm, rss);
   cout << "VM: " << vm << "; RSS: " << rss << endl;
}

Question 3

ডেভিড রবার্ট নাদাউ তার ওয়েবসাইটে প্রক্রিয়া বাসিন্দার সেট আকার (শারীরিক স্মৃতি ব্যবহার) পেতে একটি ভাল স্ব -সংযুক্ত মাল্টি-প্ল্যাটফর্ম সি ফাংশন রেখেছেন :

/*
 * Author:  David Robert Nadeau
 * Site:    http://NadeauSoftware.com/
 * License: Creative Commons Attribution 3.0 Unported License
 *          http://creativecommons.org/licenses/by/3.0/deed.en_US
 */

#if defined(_WIN32)
#include <windows.h>
#include <psapi.h>

#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
#include <unistd.h>
#include <sys/resource.h>

#if defined(__APPLE__) && defined(__MACH__)
#include <mach/mach.h>

#elif (defined(_AIX) || defined(__TOS__AIX__)) || (defined(__sun__) || defined(__sun) || defined(sun) && (defined(__SVR4) || defined(__svr4__)))
#include <fcntl.h>
#include <procfs.h>

#elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
#include <stdio.h>

#endif

#else
#error "Cannot define getPeakRSS( ) or getCurrentRSS( ) for an unknown OS."
#endif





/**
 * Returns the peak (maximum so far) resident set size (physical
 * memory use) measured in bytes, or zero if the value cannot be
 * determined on this OS.
 */
size_t getPeakRSS( )
{
#if defined(_WIN32)
    /* Windows -------------------------------------------------- */
    PROCESS_MEMORY_COUNTERS info;
    GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
    return (size_t)info.PeakWorkingSetSize;

#elif (defined(_AIX) || defined(__TOS__AIX__)) || (defined(__sun__) || defined(__sun) || defined(sun) && (defined(__SVR4) || defined(__svr4__)))
    /* AIX and Solaris ------------------------------------------ */
    struct psinfo psinfo;
    int fd = -1;
    if ( (fd = open( "/proc/self/psinfo", O_RDONLY )) == -1 )
        return (size_t)0L;      /* Can't open? */
    if ( read( fd, &psinfo, sizeof(psinfo) ) != sizeof(psinfo) )
    {
        close( fd );
        return (size_t)0L;      /* Can't read? */
    }
    close( fd );
    return (size_t)(psinfo.pr_rssize * 1024L);

#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) && defined(__MACH__))
    /* BSD, Linux, and OSX -------------------------------------- */
    struct rusage rusage;
    getrusage( RUSAGE_SELF, &rusage );
#if defined(__APPLE__) && defined(__MACH__)
    return (size_t)rusage.ru_maxrss;
#else
    return (size_t)(rusage.ru_maxrss * 1024L);
#endif

#else
    /* Unknown OS ----------------------------------------------- */
    return (size_t)0L;          /* Unsupported. */
#endif
}





/**
 * Returns the current resident set size (physical memory use) measured
 * in bytes, or zero if the value cannot be determined on this OS.
 */
size_t getCurrentRSS( )
{
#if defined(_WIN32)
    /* Windows -------------------------------------------------- */
    PROCESS_MEMORY_COUNTERS info;
    GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
    return (size_t)info.WorkingSetSize;

#elif defined(__APPLE__) && defined(__MACH__)
    /* OSX ------------------------------------------------------ */
    struct mach_task_basic_info info;
    mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
    if ( task_info( mach_task_self( ), MACH_TASK_BASIC_INFO,
        (task_info_t)&info, &infoCount ) != KERN_SUCCESS )
        return (size_t)0L;      /* Can't access? */
    return (size_t)info.resident_size;

#elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
    /* Linux ---------------------------------------------------- */
    long rss = 0L;
    FILE* fp = NULL;
    if ( (fp = fopen( "/proc/self/statm", "r" )) == NULL )
        return (size_t)0L;      /* Can't open? */
    if ( fscanf( fp, "%*s%ld", &rss ) != 1 )
    {
        fclose( fp );
        return (size_t)0L;      /* Can't read? */
    }
    fclose( fp );
    return (size_t)rss * (size_t)sysconf( _SC_PAGESIZE);

#else
    /* AIX, BSD, Solaris, and Unknown OS ------------------------ */
    return (size_t)0L;          /* Unsupported. */
#endif
}

ব্যবহার

size_t currentSize = getCurrentRSS( );
size_t peakSize    = getPeakRSS( );

আরও আলোচনার জন্য, ওয়েবসাইটটি দেখুন, এটি কোনও সিস্টেমের শারীরিক মেমরির আকার পেতে একটি ফাংশন সরবরাহ করে ।

Question 4

পুরাতন:

ম্যাক্সার্স প্রক্রিয়াটির জন্য সর্বাধিক উপলভ্য মেমরিটি উল্লেখ করে। 0 এর অর্থ হল যে প্রক্রিয়াটির উপরে কোনও সীমা রাখা হয়নি। আপনি যা চান সম্ভবত শেয়ারড ডেটা ব্যবহার ru_idrss।

নতুন: মনে হচ্ছে উপরেরগুলি আসলে কাজ করে না, কারণ কার্নেল বেশিরভাগ মান পূরণ করে না। কাজটি হ'ল প্রোকে তথ্য সংগ্রহ করা। যদিও এটি নিজের ভাগ করার পরিবর্তে, নিম্নরূপে লাইবপ্রোক (প্রোপসের অংশ) ব্যবহার করা সহজ:

// getrusage.c
#include <stdio.h>
#include <proc/readproc.h>

int main() {
  struct proc_t usage;
  look_up_our_self(&usage);
  printf("usage: %lu\n", usage.vsize);
}

" gcc -o getrusage getrusage.c -lproc" দিয়ে সংকলন করুন

Question 5

লিনাক্সে, আপনি যদি রান টাইম ব্যয় (ডিবাগিংয়ের জন্য) সামর্থ্য করতে পারেন তবে আপনি ম্যাসিফ টুল দিয়ে ভালগ্রাইন্ড ব্যবহার করতে পারেন:

http://valgrind.org/docs/manual/ms-manual.html

এটি ভারী ওজনযুক্ত, তবে খুব দরকারী।

Question 6

ডন ওয়েকফিল্ড পদ্ধতির জন্য আরও মার্জিত উপায়:

#include <iostream>
#include <fstream>

using namespace std;

int main(){

    int tSize = 0, resident = 0, share = 0;
    ifstream buffer("/proc/self/statm");
    buffer >> tSize >> resident >> share;
    buffer.close();

    long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
    double rss = resident * page_size_kb;
    cout << "RSS - " << rss << " kB\n";

    double shared_mem = share * page_size_kb;
    cout << "Shared Memory - " << shared_mem << " kB\n";

    cout << "Private Memory - " << rss - shared_mem << "kB\n";
    return 0;
}

Question 7

বিদ্যমান উত্তরগুলি সঠিক মান কীভাবে পাওয়া যায় তার জন্য আরও ভাল তবে আমি কেন অন্তত তা বুঝতে পারি যে কেন গথ্রাসেজ আপনার পক্ষে কাজ করছে না।

ম্যান 2 গেট্রাসেজ:

উপরোক্ত স্ট্রাক্ট [rusage] BSD 4.3 রেনো থেকে নেওয়া হয়েছিল। সমস্ত ক্ষেত্র লিনাক্সের অধীনে অর্থবহ নয়। এই মুহুর্তে (লিনাক্স ২.৪, ২.6) কেবলমাত্র ক্ষেত্রগুলি রু_উইমটাইম, রু_সটাইম, রু_মিনফল্ট, রু_মাজফল্ট এবং রু_সনপ পরিচালনা করে।

Question 8

আপনার
উপায়ের অতিরিক্ত হিসাবে আপনি সিস্টেম পিএস কমান্ড কল করতে পারেন এবং এর আউটপুট থেকে মেমরির ব্যবহার পেতে পারেন।
অথবা / প্রোক / পিডের তথ্য পড়ুন (পিআইওসিপিএসআইএনফো স্ট্রাক্ট দেখুন)

Question 9

আপনার সিস্টেমে একটি ফাইল রয়েছে /proc/self/statm। প্রোক ফাইল সিস্টেমটি একটি সিউডো-ফাইল সিস্টেম যা কার্নেল ডেটা স্ট্রাকচারকে ইন্টারফেস সরবরাহ করে। এই ফাইলটিতে কলামগুলিতে আপনার প্রয়োজনীয় তথ্য রয়েছে কেবলমাত্র পৃথক পূর্ণসংখ্যার সাথে space

কলাম নম্বর:

= মোট প্রোগ্রামের আকার (VmSize in / proc / [pid] / status)
= আবাসিক সেট আকার (ভিএমআরএসএস ইন / প্রোক / [পিআইডি] / স্ট্যাটাসে)

আরও তথ্যের জন্য লিঙ্কটি দেখুন ।

Question 10

আমি এটি করতে অন্য উপায় ব্যবহার করছি এবং এটি বাস্তববাদী মনে হচ্ছে। আমি যা করি তা হ'ল আমি getpid () ফাংশন দ্বারা প্রক্রিয়াটির পিআইডি পেয়েছি এবং তারপরে আমি / proc / pid / stat ফাইলটি ব্যবহার করি। আমি বিশ্বাস করি স্ট্যাটাস ফাইলের 23 তম কলামটি vmsize (ডন পোস্টে দেখুন)। আপনি কোডটিতে যেখানেই প্রয়োজন ফাইলটি থেকে vmsize পড়তে পারেন। আপনি যদি বিস্মিত হন যে কোনও কোডের স্নিপেট মেমোরিটি কতটা ব্যবহার করতে পারে, আপনি সেই ফাইলটি স্নিপেটের আগে একবার এবং পরে একবার পড়তে পারেন এবং আপনি একে অপরের থেকে বিয়োগ করতে পারেন।

Question 11

কম ভেরিয়েবল সহ ডন ডাব্লু এর সমাধানের ভিত্তিতে।

void process_mem_usage(double& vm_usage, double& resident_set)
{
    vm_usage     = 0.0;
    resident_set = 0.0;

    // the two fields we want
    unsigned long vsize;
    long rss;
    {
        std::string ignore;
        std::ifstream ifs("/proc/self/stat", std::ios_base::in);
        ifs >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore
                >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore >> ignore
                >> ignore >> ignore >> vsize >> rss;
    }

    long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
    vm_usage = vsize / 1024.0;
    resident_set = rss * page_size_kb;
}

Question 12

ব্যবহৃত সর্বাধিক স্মৃতি মাপার জন্য আমি একটি লিনাক্স অ্যাপ্লিকেশন সন্ধান করছিলাম। ভালগ্রাইন্ড একটি দুর্দান্ত সরঞ্জাম, তবে আমার চেয়ে আমি আরও বেশি তথ্য দিচ্ছিলাম। টিএসটাইমটি আমার কাছে পাওয়া সেরা সরঞ্জাম বলে মনে হয়েছিল। এটি "উচ্চ জল" মেমরির ব্যবহার (আরএসএস এবং ভার্চুয়াল) পরিমাপ করে। এই উত্তর দেখুন ।