712

इस प्रश्न को यहाँ बहुत विस्तार से कवर किया गया है।

आप लिनक्स में किसी एप्लिकेशन या प्रक्रिया के मेमोरी उपयोग को कैसे मापते हैं?

लिनक्स पर मेमोरी के उपयोग को समझने के ब्लॉग लेख से , psइस इरादे के लिए उपयोग करने के लिए एक सटीक उपकरण नहीं है।

ps"गलत" क्यों है

आप इसे कैसे देखते हैं इसके आधार पर, psप्रक्रियाओं की वास्तविक मेमोरी उपयोग की रिपोर्ट नहीं कर रहा है। यह वास्तव में क्या कर रहा है यह दिखा रहा है कि यदि प्रत्येक प्रक्रिया केवल चल रही है तो प्रत्येक प्रक्रिया में कितनी वास्तविक मेमोरी होगी । बेशक, एक विशिष्ट लिनक्स मशीन में किसी भी समय कई दर्जन प्रक्रियाएं चल रही हैं, जिसका अर्थ है कि वीएसजेड और आरएसएस द्वारा बताए गए नंबर psनिश्चित रूप से गलत हैं ।

linux memory process

— ksuralta
स्रोत

6

यह प्रश्न शायद आजकल के बजाय serverfault.com पर है, हालांकि यह मुझे बता रहा है कि "यह बहुत पुराना है"। हालांकि इसे बंद नहीं करना चाहते ...

— thomasrutter

इस प्रश्न का संदर्भ लें। stackoverflow.com/questions/669438/…

— ब्लडमून

2

वास्तव में psयह भी नहीं दिखाता है कि - यह आभासी और निवासी मेमोरी नंबर दिखाता है, जहां वर्चुअल अधिकतम मात्रा में मेमोरी है प्रक्रिया सैद्धांतिक रूप से इसका उपयोग कर सकती है यह एकमात्र प्रक्रिया थी (ऐसा कभी नहीं), हर एक पृष्ठ का उपयोग किया जो इसे आवंटित किया गया (कभी नहीं होता) और किसी भी पृष्ठ (असंभावित) को मैप या अनमैप नहीं किया। जबकि निवासी दर्शाता है कि अभी भौतिक में कितनी वर्चुअल मेमोरी मैप की गई है। आमतौर पर virt > usage > resहालांकि 64-बिट सिस्टम पर virt ~= res*10यह एक बहुत विस्तृत श्रृंखला है।

— दिमा तिस्नेक

5

लिंक किए गए लेख का अंश कुल बकवास है। आरएसएस वास्तव में उपयोग की जाने वाली भौतिक मेमोरी है, और वीएसजेड भौतिक मेमोरी उपयोग में अनुवाद कर सकता है या नहीं कर सकता है, भले ही प्रक्रिया केवल एक ही चल रही हो।

— डेविड श्वार्ट्ज

356

साथ psसमान उपकरण या आप केवल स्मृति पृष्ठों है कि इस प्रक्रिया द्वारा आवंटित की राशि मिल जाएगा। यह संख्या सही है, लेकिन:

एप्लिकेशन द्वारा उपयोग की जाने वाली मेमोरी की वास्तविक मात्रा को प्रतिबिंबित नहीं करता है, केवल मेमोरी की मात्रा इसके लिए आरक्षित है
यदि पृष्ठ साझा किए जाते हैं, उदाहरण के लिए कई थ्रेड्स द्वारा या डायनामिकली लिंक्ड लाइब्रेरियों का उपयोग करके भ्रामक हो सकते हैं

यदि आप वास्तव में यह जानना चाहते हैं कि आपका एप्लिकेशन वास्तव में किस मेमोरी का उपयोग करता है, तो आपको इसे एक प्रोफाइलर के भीतर चलाने की आवश्यकता है। उदाहरण के लिए, valgrindआप उपयोग की गई मेमोरी की मात्रा के बारे में जानकारी दे सकते हैं, और, इससे भी महत्वपूर्ण बात, आपके प्रोग्राम में संभावित मेमोरी लीक के बारे में। वेलग्राइंड के ढेर प्रोफाइलर उपकरण को 'मासिफ' कहा जाता है:

मासिफ एक ढेर प्रोफाइलर है। यह एक कार्यक्रम के ढेर के नियमित स्नैपशॉट लेकर विस्तृत ढेर प्रोफाइलिंग करता है। यह समय के साथ ढेर उपयोग दिखाते हुए एक ग्राफ का उत्पादन करता है, जिसमें इस बात की जानकारी भी शामिल है कि कार्यक्रम के कौन से हिस्से सबसे अधिक मेमोरी आवंटन के लिए जिम्मेदार हैं। ग्राफ़ को एक पाठ या HTML फ़ाइल द्वारा पूरक किया गया है जिसमें यह निर्धारित करने के लिए अधिक जानकारी शामिल है कि सबसे अधिक मेमोरी कहाँ आवंटित की जा रही है। मासिफ सामान्य से 20x धीमी गति से कार्यक्रम चलाता है।

जैसा कि वैलेग्रिंड डॉक्यूमेंटेशन में बताया गया है , आपको वेलग्रिंड के माध्यम से प्रोग्राम चलाने की आवश्यकता है:

valgrind --tool=massif <executable> <arguments>

मैसिफ मेमोरी उपयोग स्नैपशॉट (जैसे massif.out.12345) का एक डंप लिखता है । ये प्रदान करते हैं, (1) प्रत्येक स्नैपशॉट के लिए मेमोरी उपयोग की समयरेखा, (2), आपके प्रोग्राम मेमोरी में कहां रिकॉर्ड किया गया था। इन फ़ाइलों का विश्लेषण करने के लिए एक महान चित्रमय उपकरण है द्रव्यमान-विज़ुअलाइज़र । लेकिन मैंने पाया ms_print, एक सरल टेक्स्ट-आधारित टूल, जो वैलेग्रिंड के साथ शिप किया गया है, पहले से ही बहुत मदद के लिए है।

मेमोरी लीक को खोजने के लिए, memcheckवैलग्राइंड के डिफ़ॉल्ट (डिफ़ॉल्ट) टूल का उपयोग करें ।

— ypnos
स्रोत

44

वेलग्रिंड द्वारा उत्पन्न परिणामों की व्याख्या करने के लिए, मैं गलीयों की सिफारिश कर सकता हूं। यह बहुत फैंसी नहीं है, और आपको बताता है कि आपको लीक के स्रोतों का पता लगाने के लिए क्या चाहिए। उपयोगिताओं की एक अच्छी जोड़ी।

— डेन

6

आइटम (ए) सही है। वास्तव में उपयोग किए गए पृष्ठों और मेमोरी के बीच एक अंतर होता है, जो कि एप्लिकेशन द्वारा मॉलोक (), नए, इत्यादि के माध्यम से आवंटित किया जाता है। निवासी का उपयोग यह दर्शाता है कि रैम में निवासी की स्मृति कितनी है।

— jcoffland

63

यह वास्तव में नहीं बताता है कि वैलग्राइंड का उपयोग करके मेमोरी का उपयोग कैसे किया जाए?

— मैट जॉइनर

11

डिफ़ॉल्ट वैलग्राइंड टूल, मेमचेक, मेमोरी लीक का पता लगाने के लिए उपयोगी है, लेकिन यह वास्तव में मेमोरी प्रोफाइलर नहीं है। उसके लिए, आपको valgrind --tool = massif चाहिए।

— टोड फ्रीड

3

@DavidSchwartz मैं यह नहीं देखता कि आपका बयान मेरा विरोध कैसे कर रहा है। मुझे लगता है कि आप वास्तव में जो मैं कह रहा हूं उसे पढ़ने की तुलना में "गलत" होने के आपके बिंदु पर बहुत अधिक चिंतित हूं। यहां मेरा पूरा कहना यह है कि आरएसएस आवेदन के वास्तविक मेमोरी उपयोग के लिए एक अनुचित उपाय है, और आप अपने दो दो वाक्यों में एक ही बिंदु बना रहे हैं। वास्तव में, आपने क्या सोचा था कि मेरे लिए पहली बार में आरएसएस संकोचन लाने का कारण था? इतना है कि आप इसे मुझे गलत साबित करने के लिए मुझे "गलत" साबित करने के लिए वापस भेज देते हैं? मेरे प्रति आपका रवैया थकाऊ है।

— ypnos

280

Pmap कमांड आज़माएं :

sudo pmap -x <process pid>

— Anil
स्रोत

45

सूडो के साथ चलाएं या यह कोई त्रुटि नहीं देता है और न ही खपत की गई मेमोरी दिखाता है।

— मैट

22

OSX पर मौजूद नहीं है (जो कोई भी Google से यहां आता है)

— jcollum

3

यह सवाल का एक पूर्ण जवाब है! ps। मेरे खोल में, pmap बिना sudo के प्रक्रिया पढ़ सकता है।

— MasterControlProgram

7

रे ओएस एक्स (प्रतीत होता है कि ओपी की चिंता नहीं), आप कुछ इसी तरह के डेटा को vmmap (1)

— jrg

नोट: से पूरी तरह से अलग जवाब देता हैgnome-system-monitor

— Ribamar

190

यकीन के लिए कहना मुश्किल है, लेकिन यहां दो "करीब" चीजें हैं जो मदद कर सकती हैं।

$ ps aux

आपको वर्चुअल साइज़ (VSZ) देगा

आप फाइल / सिस्टम से विस्तृत आँकड़े भी प्राप्त कर सकते हैं /proc/$pid/status

सबसे महत्वपूर्ण VmSize है, जो जो ps auxदेता है उसके करीब होना चाहिए ।

/ proc / 19420 $ बिल्ली की स्थिति
नाम: फ़ायरफ़ॉक्स
राज्य: एस (नींद)
Tgid: 19420
पिड: 19420
पीपीपी: १
ट्रेसरपिड: 0
यूआईडी: 1000 1000 1000 1000
Gid: 1000 1000 1000 1000
FDSize: 256
समूह: 4 6 20 24 25 29 30 44 46 107 109 115 124 1000 
VmPeak: 222956 kB
VmSize: 212520 kB
VmLck: 0 kB
VHHWM: 127912 kB
VmRSS: 118768 kB
VmData: 170180 kB
VmStk: 228 kB
VmExe: 28 kB
VmLib: 35424 kB
VmPTE: 184 kB
सूत्र: 8
SigQ: 0/16382
सिगपंड: 0000000000000000
ShdPnd: 0000000000000000
सिब्लॉक: 0000000000000000
सिग्नगन: 0000000020001000
SigCgt: 000000018000442f
CapInh: 0000000000000000
कैपप्रम: 0000000000000000
CapEff: 0000000000000000
Cpus_allowed: 03
Mems_allowed: 1
voluntary_ctxt_switches: 63422
nonvoluntary_ctxt_switches: 7171

— DustinB
स्रोत

21

क्या मैं कुछ भूल रहा हूँ? प्रश्न पूछा गया कि मेमोरी प्रक्रिया को बेहतर तरीके से कैसे मापना है, यह देखते हुए कि वीएसजेड और आरएसएस ने पीएस में बताया कि यह भ्रामक है। आपका उत्तर विवरण वीएसजेड को कैसे देखना है - वही मूल्य जो भ्रामक होने के रूप में उल्लेख किया गया था।

— थोमसट्रेटर

16

@thomasrutter हाँ, आपको मूल प्रश्न याद नहीं है (Rev 1), इसे कई बार संपादित किया गया है और यह काफी पुराना है (2008)। मूल प्रश्न सिर्फ यह पूछा गया कि किसी प्रक्रिया के मेमोरी उपयोग को कैसे मापें। प्रश्न और उत्तर संपादित करने के लिए स्वतंत्र महसूस करें, हालांकि, यदि चीजें पुरानी हैं। :)

— डस्टबिन

1

नोट: से पूरी तरह से अलग जवाब देता हैgnome-system-monitor

— Ribamar

131

लिनक्स के हाल के संस्करणों में, का उपयोग करें स्मैप सबसिस्टम का । उदाहरण के लिए, 1234 के पीआईडी के साथ एक प्रक्रिया के लिए:

cat /proc/1234/smaps

यह आपको बताएगा कि उस समय यह कितनी मेमोरी का उपयोग कर रहा है। इससे भी महत्वपूर्ण बात, यह निजी और साझा में स्मृति को विभाजित करके बता सकते हैं कि कितना स्मृति अपने जाएगा उदाहरण , स्मृति कार्यक्रम के कई उदाहरण के बीच साझा शामिल किए बिना कार्यक्रम के उपयोग कर रहा है।

— पॉल बिगगर
स्रोत

मुझे लगता pmapहै कि यह एक सरल इंटरफ़ेस है।

— रिबमार

126

इसकी गणना करने का कोई आसान तरीका नहीं है। लेकिन कुछ लोगों ने कुछ अच्छे जवाब पाने की कोशिश की है:

— दे घुमा के
स्रोत

अच्छी मेमोरी और प्रोसेस की साफ-सुथरी लिस्टिंग के लिए आउटपुट

— Rubytastic

बहुत अच्छा, काफी स्मार्ट ग्रुपिंग के साथ।

— रोहमर

हाँ, वास्तव में काफी अच्छा है। मुझे लगता है ps_memऔर smemबहुत, अंत उपयोगकर्ता के उपायों के लिए उपयोगी जैसे हैं। pmapबहुत विस्तृत आउटपुट देवों की ओर बढ़ाया जाता है ... फ़ायरफ़ॉक्स मेमोरी मेमोरी को प्रत्येक फोंट, एडोन, लिब्स के लिए पूर्व में प्राप्त करने की अनुमति देता है। आप सभी को धन्यवाद। @ बैश, @thomasruther

— 20

यह अब तक केवल एक ही है जिसका उत्पादनgnome-system-monitor

— ribamar

110

Smem का उपयोग करें , जो ps का एक विकल्प है जो USS और PSS प्रति प्रक्रिया की गणना करता है। आप जो चाहते हैं वह शायद PSS है।

यूएसएस - अद्वितीय सेट का आकार। यह उस प्रक्रिया के लिए अनसैचर्ड मेमोरी की मात्रा है (इसे यूनिक मेमोरी के लिए यू समझें)। इसमें साझा मेमोरी शामिल नहीं है। इस प्रकार यह एक प्रक्रिया द्वारा उपयोग की जाने वाली मेमोरी की मात्रा को कम कर देगा, लेकिन जब आप साझा की गई मेमोरी को अनदेखा करना चाहते हैं तो यह सहायक होता है।
PSS - आनुपातिक सेट आकार। ये वो है जो तुम चाहते हो। यह अद्वितीय मेमोरी (यूएसएस) को एक साथ जोड़ता है, साथ ही उस मेमोरी को साझा करने वाली प्रक्रियाओं की संख्या से विभाजित अपनी साझा मेमोरी के अनुपात के साथ। इस प्रकार यह आपको एक सटीक प्रतिनिधित्व देगा कि प्रति प्रक्रिया में वास्तविक भौतिक स्मृति का कितना उपयोग किया जा रहा है - साझा स्मृति के साथ वास्तव में साझा के रूप में प्रतिनिधित्व किया गया है। भौतिक स्मृति के लिए P के बारे में सोचें ।

यह कैसे आरएसएस की तुलना पीएस और अन्य उपयोगों द्वारा रिपोर्ट करता है :

आरएसएस - निवासी सेट का आकार। यह प्रत्येक प्रक्रिया द्वारा उपयोग की जाने वाली साझा मेमोरी प्लस अनसर्ड मेमोरी की मात्रा है। यदि कोई प्रक्रिया मेमोरी साझा करती है, तो यह वास्तव में उपयोग की जाने वाली मेमोरी की मात्रा को अधिक कर देगा, क्योंकि एक ही साझा की गई मेमोरी को एक से अधिक बार गिना जाएगा - फिर से एक ही मेमोरी को साझा करने वाली प्रत्येक अन्य प्रक्रिया में दिखाई देगा। इस प्रकार यह काफी अविश्वसनीय है, खासकर जब उच्च-स्मृति प्रक्रियाओं में बहुत सारे कांटे होते हैं - जो एक सर्वर में आम है, जिसमें अपाचे या पीएचपी (फास्टसी / एफपीएम) जैसी चीजें होती हैं।

सूचना: smem भी (वैकल्पिक रूप से) आउटपुट ग्राफ़ जैसे पाई चार्ट और पसंद कर सकता है। IMO आपको इसकी कोई आवश्यकता नहीं है। यदि आप इसे कमांड लाइन से उपयोग करना चाहते हैं जैसे आप ps-v का उपयोग कर सकते हैं, तो आपको अजगर-मेटप्लोटलिब अनुशंसित निर्भरता स्थापित करने की आवश्यकता नहीं है।

— thomasrutter
स्रोत

2

RSS के बारे में एक महत्वपूर्ण बात यह है कि इन दिनों अधिकांश एप्लिकेशन बहुत सारे कोड पृष्ठ साझा करते हैं। प्रत्येक साझा पुस्तकालय (जैसे libc और libstdc ++) का उपयोग करने वाली प्रत्येक प्रक्रिया के लिए गिना जाएगा। और अगर किसी प्रक्रिया के कई उदाहरण हैं, तो उस कोड के सभी डबल-काउंट होंगे।

— डेविड सी।

1

वास्तव में, यही वजह है कि आरएसएस प्रति प्रक्रिया वास्तविक भौतिक स्मृति की अवधि में ओवर-रिपोर्ट करता है।

— थोमसट्रेटर

3

smem वह है जो मुझे चाहिए था। हर बार इसे -t के साथ चलाने से, मैं एक नई प्रक्रिया का उदाहरण शुरू करता हूं, मैं वह मेमोरी देख सकता हूं जिसका प्रत्येक उदाहरण खपत करता है। क्रोम के लिए: smem -t -P '/ opt / google / chrome'

— xtian

मुझे स्मैम के लिए डॉक्यूमेंट ढूंढने में मुश्किल समय हो रहा है .. क्या यह बाइट्स, किलोबाइट्स या मेगाबाइट्स में डिफॉल्ट रूप से आउटपुट होता है ??

— ZN13

4

TL; DR: USS = भौतिक मेमोरी की मात्रा जो प्रक्रिया के मारे जाने पर मुक्त हो जाएगी, PSS = भौतिक स्मृति की मात्रा जो इस प्रक्रिया को सिस्टम से चाहिए अगर कोई मौजूदा प्रक्रिया नहीं मारी जाएगी, RSS = भौतिक स्मृति की मात्रा जो कि सुलभ है यह प्रक्रिया (लेकिन हमेशा अनन्य पहुँच नहीं)।

— मिकीको रैंटलैनेन

95

ps -eo size,pid,user,command --sort -size | \
    awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' |\
    cut -d "" -f2 | cut -d "-" -f1

इसे रूट के रूप में उपयोग करें और आप प्रत्येक प्रक्रिया द्वारा मेमोरी उपयोग के लिए एक स्पष्ट आउटपुट प्राप्त कर सकते हैं।

बाहर निकलने का समय:

     0.00 Mb COMMAND 
  1288.57 Mb /usr/lib/firefox
   821.68 Mb /usr/lib/chromium/chromium 
   762.82 Mb /usr/lib/chromium/chromium 
   588.36 Mb /usr/sbin/mysqld 
   547.55 Mb /usr/lib/chromium/chromium 
   523.92 Mb /usr/lib/tracker/tracker
   476.59 Mb /usr/lib/chromium/chromium 
   446.41 Mb /usr/bin/gnome
   421.62 Mb /usr/sbin/libvirtd 
   405.11 Mb /usr/lib/chromium/chromium 
   302.60 Mb /usr/lib/chromium/chromium 
   291.46 Mb /usr/lib/chromium/chromium 
   284.56 Mb /usr/lib/chromium/chromium 
   238.93 Mb /usr/lib/tracker/tracker
   223.21 Mb /usr/lib/chromium/chromium 
   197.99 Mb /usr/lib/chromium/chromium 
   194.07 Mb conky 
   191.92 Mb /usr/lib/chromium/chromium 
   190.72 Mb /usr/bin/mongod 
   169.06 Mb /usr/lib/chromium/chromium 
   155.11 Mb /usr/bin/gnome
   136.02 Mb /usr/lib/chromium/chromium 
   125.98 Mb /usr/lib/chromium/chromium 
   103.98 Mb /usr/lib/chromium/chromium 
    93.22 Mb /usr/lib/tracker/tracker
    89.21 Mb /usr/lib/gnome
    80.61 Mb /usr/bin/gnome
    77.73 Mb /usr/lib/evolution/evolution
    76.09 Mb /usr/lib/evolution/evolution
    72.21 Mb /usr/lib/gnome
    69.40 Mb /usr/lib/evolution/evolution
    68.84 Mb nautilus
    68.08 Mb zeitgeist
    60.97 Mb /usr/lib/tracker/tracker
    59.65 Mb /usr/lib/evolution/evolution
    57.68 Mb apt
    55.23 Mb /usr/lib/gnome
    53.61 Mb /usr/lib/evolution/evolution
    53.07 Mb /usr/lib/gnome
    52.83 Mb /usr/lib/gnome
    51.02 Mb /usr/lib/udisks2/udisksd 
    50.77 Mb /usr/lib/evolution/evolution
    50.53 Mb /usr/lib/gnome
    50.45 Mb /usr/lib/gvfs/gvfs
    50.36 Mb /usr/lib/packagekit/packagekitd 
    50.14 Mb /usr/lib/gvfs/gvfs
    48.95 Mb /usr/bin/Xwayland :1024 
    46.21 Mb /usr/bin/gnome
    42.43 Mb /usr/bin/zeitgeist
    42.29 Mb /usr/lib/gnome
    41.97 Mb /usr/lib/gnome
    41.64 Mb /usr/lib/gvfs/gvfsd
    41.63 Mb /usr/lib/gvfs/gvfsd
    41.55 Mb /usr/lib/gvfs/gvfsd
    41.48 Mb /usr/lib/gvfs/gvfsd
    39.87 Mb /usr/bin/python /usr/bin/chrome
    37.45 Mb /usr/lib/xorg/Xorg vt2 
    36.62 Mb /usr/sbin/NetworkManager 
    35.63 Mb /usr/lib/caribou/caribou 
    34.79 Mb /usr/lib/tracker/tracker
    33.88 Mb /usr/sbin/ModemManager 
    33.77 Mb /usr/lib/gnome
    33.61 Mb /usr/lib/upower/upowerd 
    33.53 Mb /usr/sbin/gdm3 
    33.37 Mb /usr/lib/gvfs/gvfsd
    33.36 Mb /usr/lib/gvfs/gvfs
    33.23 Mb /usr/lib/gvfs/gvfs
    33.15 Mb /usr/lib/at
    33.15 Mb /usr/lib/at
    30.03 Mb /usr/lib/colord/colord 
    29.62 Mb /usr/lib/apt/methods/https 
    28.06 Mb /usr/lib/zeitgeist/zeitgeist
    27.29 Mb /usr/lib/policykit
    25.55 Mb /usr/lib/gvfs/gvfs
    25.55 Mb /usr/lib/gvfs/gvfs
    25.23 Mb /usr/lib/accountsservice/accounts
    25.18 Mb /usr/lib/gvfs/gvfsd 
    25.15 Mb /usr/lib/gvfs/gvfs
    25.15 Mb /usr/lib/gvfs/gvfs
    25.12 Mb /usr/lib/gvfs/gvfs
    25.10 Mb /usr/lib/gnome
    25.10 Mb /usr/lib/gnome
    25.07 Mb /usr/lib/gvfs/gvfsd 
    24.99 Mb /usr/lib/gvfs/gvfs
    23.26 Mb /usr/lib/chromium/chromium 
    22.09 Mb /usr/bin/pulseaudio 
    19.01 Mb /usr/bin/pulseaudio 
    18.62 Mb (sd
    18.46 Mb (sd
    18.30 Mb /sbin/init 
    18.17 Mb /usr/sbin/rsyslogd 
    17.50 Mb gdm
    17.42 Mb gdm
    17.09 Mb /usr/lib/dconf/dconf
    17.09 Mb /usr/lib/at
    17.06 Mb /usr/lib/gvfs/gvfsd
    16.98 Mb /usr/lib/at
    16.91 Mb /usr/lib/gdm3/gdm
    16.86 Mb /usr/lib/gvfs/gvfsd
    16.86 Mb /usr/lib/gdm3/gdm
    16.85 Mb /usr/lib/dconf/dconf
    16.85 Mb /usr/lib/dconf/dconf
    16.73 Mb /usr/lib/rtkit/rtkit
    16.69 Mb /lib/systemd/systemd
    13.13 Mb /usr/lib/chromium/chromium 
    13.13 Mb /usr/lib/chromium/chromium 
    10.92 Mb anydesk 
     8.54 Mb /sbin/lvmetad 
     7.43 Mb /usr/sbin/apache2 
     6.82 Mb /usr/sbin/apache2 
     6.77 Mb /usr/sbin/apache2 
     6.73 Mb /usr/sbin/apache2 
     6.66 Mb /usr/sbin/apache2 
     6.64 Mb /usr/sbin/apache2 
     6.63 Mb /usr/sbin/apache2 
     6.62 Mb /usr/sbin/apache2 
     6.51 Mb /usr/sbin/apache2 
     6.25 Mb /usr/sbin/apache2 
     6.22 Mb /usr/sbin/apache2 
     3.92 Mb bash 
     3.14 Mb bash 
     2.97 Mb bash 
     2.95 Mb bash 
     2.93 Mb bash 
     2.91 Mb bash 
     2.86 Mb bash 
     2.86 Mb bash 
     2.86 Mb bash 
     2.84 Mb bash 
     2.84 Mb bash 
     2.45 Mb /lib/systemd/systemd
     2.30 Mb (sd
     2.28 Mb /usr/bin/dbus
     1.84 Mb /usr/bin/dbus
     1.46 Mb ps 
     1.21 Mb openvpn hackthebox.ovpn 
     1.16 Mb /sbin/dhclient 
     1.16 Mb /sbin/dhclient 
     1.09 Mb /lib/systemd/systemd 
     0.98 Mb /sbin/mount.ntfs /dev/sda3 /media/n0bit4/Data 
     0.97 Mb /lib/systemd/systemd 
     0.96 Mb /lib/systemd/systemd 
     0.89 Mb /usr/sbin/smartd 
     0.77 Mb /usr/bin/dbus
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.76 Mb su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.75 Mb sudo su 
     0.74 Mb /usr/bin/dbus
     0.71 Mb /usr/lib/apt/methods/http 
     0.68 Mb /bin/bash /usr/bin/mysqld_safe 
     0.68 Mb /sbin/wpa_supplicant 
     0.66 Mb /usr/bin/dbus
     0.61 Mb /lib/systemd/systemd
     0.54 Mb /usr/bin/dbus
     0.46 Mb /usr/sbin/cron 
     0.45 Mb /usr/sbin/irqbalance 
     0.43 Mb logger 
     0.41 Mb awk { hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" } 
     0.40 Mb /usr/bin/ssh
     0.34 Mb /usr/lib/chromium/chrome
     0.32 Mb cut 
     0.32 Mb cut 
     0.00 Mb [kthreadd] 
     0.00 Mb [ksoftirqd/0] 
     0.00 Mb [kworker/0:0H] 
     0.00 Mb [rcu_sched] 
     0.00 Mb [rcu_bh] 
     0.00 Mb [migration/0] 
     0.00 Mb [lru
     0.00 Mb [watchdog/0] 
     0.00 Mb [cpuhp/0] 
     0.00 Mb [cpuhp/1] 
     0.00 Mb [watchdog/1] 
     0.00 Mb [migration/1] 
     0.00 Mb [ksoftirqd/1] 
     0.00 Mb [kworker/1:0H] 
     0.00 Mb [cpuhp/2] 
     0.00 Mb [watchdog/2] 
     0.00 Mb [migration/2] 
     0.00 Mb [ksoftirqd/2] 
     0.00 Mb [kworker/2:0H] 
     0.00 Mb [cpuhp/3] 
     0.00 Mb [watchdog/3] 
     0.00 Mb [migration/3] 
     0.00 Mb [ksoftirqd/3] 
     0.00 Mb [kworker/3:0H] 
     0.00 Mb [kdevtmpfs] 
     0.00 Mb [netns] 
     0.00 Mb [khungtaskd] 
     0.00 Mb [oom_reaper] 
     0.00 Mb [writeback] 
     0.00 Mb [kcompactd0] 
     0.00 Mb [ksmd] 
     0.00 Mb [khugepaged] 
     0.00 Mb [crypto] 
     0.00 Mb [kintegrityd] 
     0.00 Mb [bioset] 
     0.00 Mb [kblockd] 
     0.00 Mb [devfreq_wq] 
     0.00 Mb [watchdogd] 
     0.00 Mb [kswapd0] 
     0.00 Mb [vmstat] 
     0.00 Mb [kthrotld] 
     0.00 Mb [ipv6_addrconf] 
     0.00 Mb [acpi_thermal_pm] 
     0.00 Mb [ata_sff] 
     0.00 Mb [scsi_eh_0] 
     0.00 Mb [scsi_tmf_0] 
     0.00 Mb [scsi_eh_1] 
     0.00 Mb [scsi_tmf_1] 
     0.00 Mb [scsi_eh_2] 
     0.00 Mb [scsi_tmf_2] 
     0.00 Mb [scsi_eh_3] 
     0.00 Mb [scsi_tmf_3] 
     0.00 Mb [scsi_eh_4] 
     0.00 Mb [scsi_tmf_4] 
     0.00 Mb [scsi_eh_5] 
     0.00 Mb [scsi_tmf_5] 
     0.00 Mb [bioset] 
     0.00 Mb [kworker/1:1H] 
     0.00 Mb [kworker/3:1H] 
     0.00 Mb [kworker/0:1H] 
     0.00 Mb [kdmflush] 
     0.00 Mb [bioset] 
     0.00 Mb [kdmflush] 
     0.00 Mb [bioset] 
     0.00 Mb [jbd2/sda5
     0.00 Mb [ext4
     0.00 Mb [kworker/2:1H] 
     0.00 Mb [kauditd] 
     0.00 Mb [bioset] 
     0.00 Mb [drbd
     0.00 Mb [irq/27
     0.00 Mb [i915/signal:0] 
     0.00 Mb [i915/signal:1] 
     0.00 Mb [i915/signal:2] 
     0.00 Mb [ttm_swap] 
     0.00 Mb [cfg80211] 
     0.00 Mb [kworker/u17:0] 
     0.00 Mb [hci0] 
     0.00 Mb [hci0] 
     0.00 Mb [kworker/u17:1] 
     0.00 Mb [iprt
     0.00 Mb [iprt
     0.00 Mb [kworker/1:0] 
     0.00 Mb [kworker/3:0] 
     0.00 Mb [kworker/0:0] 
     0.00 Mb [kworker/2:0] 
     0.00 Mb [kworker/u16:0] 
     0.00 Mb [kworker/u16:2] 
     0.00 Mb [kworker/3:2] 
     0.00 Mb [kworker/2:1] 
     0.00 Mb [kworker/1:2] 
     0.00 Mb [kworker/0:2] 
     0.00 Mb [kworker/2:2] 
     0.00 Mb [kworker/0:1] 
     0.00 Mb [scsi_eh_6] 
     0.00 Mb [scsi_tmf_6] 
     0.00 Mb [usb
     0.00 Mb [bioset] 
     0.00 Mb [kworker/3:1] 
     0.00 Mb [kworker/u16:1]

— लोकेंद्र सिंह रावत
स्रोत

1

सूची को फ़िल्टर करने का कोई तरीका ताकि केवल ऐसी प्रक्रियाएं हों जो 30% कहने के लिए 25% से अधिक मेमोरी का उपयोग करें? मैं एक PHPEclipse डीबगर का उपयोग करते समय Chrome ब्राउज़र की तरह चलने वाली प्रक्रियाओं को देखने की कोशिश कर रहा हूं।

— स्टीफन

वह फ़िल्टर भयानक होगा

— aleix

1

मैं जितनी जल्दी हो सके पोस्ट करूँगा।

— लोकेंद्र सिंह रावत

2

महान! लेकिन लूप की शुरुआत x=2आउटपुट पिड और यूजर से भी होनी चाहिए ।

— बोरिस ब्रोड्स्की

70

किस बारे में time?

उदाहरण के लिए, बाश बिलिन नहीं, timeबल्कि आप जिसके साथ मिल सकते हैंwhich time/usr/bin/time

यहाँ यह एक सरल पर कवर ls:

$ /usr/bin/time --verbose ls
(...)
Command being timed: "ls"
User time (seconds): 0.00
System time (seconds): 0.00
Percent of CPU this job got: 0%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 2372
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 1
Minor (reclaiming a frame) page faults: 121
Voluntary context switches: 2
Involuntary context switches: 9
Swaps: 0
File system inputs: 256
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0

— चंद्रमा जैसे बच्चे
स्रोत

मैं भी। यह जिस तरह से मैं powercron.eu में :) प्रोफ़ाइल कार्य करने के लिए उपयोग

— Moonchild

5

brew install gnu-timegtimeयदि आप macOS पर हैं तो उपयोग करें ।

— नोबू

4

दोष: प्रक्रिया के पूरा होने तक परिणाम नहीं मिलेंगे। रनिंग प्रक्रिया की वास्तविक समय की निगरानी के लिए उपयोग नहीं किया जा सकता है।

— मकेश

/ usr / bin / time -f '% M'

— शिशु

1

आप इसे शेल के आंतरिक समय का उपयोग करने से रोकने के लिए (बैकस्लैश के साथ) का उपयोग करके भी इसे लागू कर सकते हैं।

— राउल सालिनास-मोंटेगुडो

39

यह टूल और समस्याओं का एक उत्कृष्ट सारांश है: आर्काइव.ऑर्ग लिंक

मैं इसे उद्धृत करूंगा, ताकि अधिक देव वास्तव में इसे पढ़ेंगे।

यदि आप संपूर्ण सिस्टम के मेमोरी उपयोग का विश्लेषण करना चाहते हैं या किसी एप्लिकेशन के मेमोरी उपयोग का विश्लेषण करना चाहते हैं (न कि केवल इसके ढेर का उपयोग), एक्साम का उपयोग करें । पूरे सिस्टम विश्लेषण के लिए, उच्चतम प्रभावी उपयोग के साथ प्रक्रियाएं ढूंढें, वे व्यवहार में सबसे अधिक मेमोरी लेते हैं, उच्चतम लिखने योग्य उपयोग के साथ प्रक्रियाएं ढूंढते हैं, वे सबसे अधिक डेटा बनाते हैं (और इसलिए संभवतः रिसाव या उनके डेटा उपयोग में बहुत अप्रभावी हैं)। ऐसे आवेदन का चयन करें और दूसरी सूची में इसकी मैपिंग का विश्लेषण करें। अधिक विवरण के लिए निर्गमन अनुभाग देखें। एक्स संसाधनों के उच्च उपयोग की जांच करने के लिए भी एक्सरेस्टॉप का उपयोग करें, खासकर अगर एक्स सर्वर की प्रक्रिया में बहुत अधिक मेमोरी लगती है। विवरण के लिए xrestop अनुभाग देखें।

यदि आप लीक, उपयोग का पता लगाने के लिए चाहते हैं valgrind या संभवतः kmtrace ।

यदि आप किसी एप्लिकेशन के हीप (मालॉक आदि) का विश्लेषण करना चाहते हैं, तो इसे या तो मेम्प्रिट में चलाएं या kmtrace के साथ , एप्लिकेशन को प्रोफाइल करें और सबसे बड़े आवंटन के लिए फ़ंक्शन कॉल ट्री खोजें। अधिक जानकारी के लिए उनके अनुभाग देखें।

— phoku
स्रोत

28

आपके उत्तरों में सूचीबद्ध समाधानों के अलावा, आप लिनक्स कमांड "टॉप" का उपयोग कर सकते हैं; यह रनिंग सिस्टम का एक गतिशील वास्तविक समय दृश्य प्रदान करता है, यह सीपीयू और मेमोरी का उपयोग देता है, पूरे सिस्टम के लिए हर प्रोग्राम के लिए, प्रतिशत में:

top

प्रोग्राम पीड द्वारा फ़िल्टर करना:

top -p <PID>

प्रोग्राम नाम से फ़िल्टर करना:

top | grep <PROCESS NAME>

"शीर्ष" कुछ क्षेत्र भी प्रदान करता है जैसे:

VIRT - वर्चुअल इमेज (kb): कार्य द्वारा उपयोग की जाने वाली वर्चुअल मेमोरी की कुल मात्रा

आरईएस - रेजिडेंट साइज (केबी): गैर-स्वैप किए गए भौतिक मेमोरी का उपयोग किया गया कार्य; RES = CODE + डेटा।

डेटा - डेटा + स्टैक आकार (केबी): निष्पादन योग्य कोड के अलावा अन्य के लिए समर्पित भौतिक मेमोरी की मात्रा, जिसे 'डेटा निवासी सेट' आकार या डीआरएस के रूप में भी जाना जाता है।

SHR - साझा मेम का आकार (kb): किसी कार्य द्वारा उपयोग की जाने वाली साझा मेमोरी की मात्रा। यह बस स्मृति को दर्शाता है जिसे संभावित रूप से अन्य प्रक्रियाओं के साथ साझा किया जा सकता है।

संदर्भ यहाँ ।

— याह्या याह्याउइ
स्रोत

20

इसके लिए एक भी उत्तर नहीं है क्योंकि आप एक प्रक्रिया द्वारा उपयोग की जाने वाली मेमोरी की मात्रा को ठीक से इंगित नहीं कर सकते हैं। लिनक्स के तहत अधिकांश प्रक्रियाएं साझा पुस्तकालयों का उपयोग करती हैं। उदाहरण के लिए, मान लें कि आप 'ls' प्रक्रिया के लिए मेमोरी उपयोग की गणना करना चाहते हैं। क्या आप केवल निष्पादन योग्य 'ls' द्वारा उपयोग की जाने वाली मेमोरी की गणना करते हैं (यदि आप इसे अलग कर सकते थे)? कैसे होगा libc के बारे में? या ये सभी अन्य देयताएँ जो 'ls' को चलाने के लिए आवश्यक हैं?

linux-gate.so.1 =>  (0x00ccb000)
librt.so.1 => /lib/librt.so.1 (0x06bc7000)
libacl.so.1 => /lib/libacl.so.1 (0x00230000)
libselinux.so.1 => /lib/libselinux.so.1 (0x00162000)
libc.so.6 => /lib/libc.so.6 (0x00b40000)
libpthread.so.0 => /lib/libpthread.so.0 (0x00cb4000)
/lib/ld-linux.so.2 (0x00b1d000)
libattr.so.1 => /lib/libattr.so.1 (0x00229000)
libdl.so.2 => /lib/libdl.so.2 (0x00cae000)
libsepol.so.1 => /lib/libsepol.so.1 (0x0011a000)

आप तर्क दे सकते हैं कि वे अन्य प्रक्रियाओं द्वारा साझा किए गए हैं, लेकिन 'ls' को सिस्टम पर लोड किए बिना नहीं चलाया जा सकता है।

इसके अलावा, यदि आपको यह जानने की आवश्यकता है कि क्षमता नियोजन करने के लिए किसी प्रक्रिया की कितनी स्मृति की आवश्यकता है, तो आपको यह गणना करनी होगी कि प्रक्रिया की प्रत्येक अतिरिक्त प्रति का उपयोग कितना होता है। मुझे लगता है कि खरीद / पीआईडी / स्थिति आपको एक बार में मेमोरी उपयोग एटी की पर्याप्त जानकारी दे सकती है। दूसरी ओर, वैलग्राइंड आपको कार्यक्रम के पूरे जीवनकाल में मेमोरी के उपयोग की बेहतर रूपरेखा प्रदान करेगा

— Dprado
स्रोत

मैं यह जानने की कोशिश कर रहा हूं कि वीएम पर कितनी मेमोरी होती है और कुबेरनेट्स में मेमोरी लिमिट सेटअप करने के लिए मैं इसका इस्तेमाल करना चाहता हूं, मैं इस जवाब पर सहमत हूं, इसलिए इसके द्वारा दिखाए गए मेमोरी का उपयोग करना होगाpmap

— दीपक देवर

16

यदि आपका कोड C या C ++ में है तो आप उपयोग करने में सक्षम हो सकते हैं getrusage() जो आपको स्मृति और आपकी प्रक्रिया के समय के उपयोग के बारे में विभिन्न आँकड़े देता है।

सभी प्लेटफ़ॉर्म हालांकि इसका समर्थन नहीं करते हैं और स्मृति-उपयोग विकल्पों के लिए 0 मान लौटाएंगे।

इसके बजाय आप इसमें बनाई गई आभासी फ़ाइल को देख सकते हैं /proc/[pid]/statm(जहां [pid]आपकी प्रक्रिया आईडी द्वारा बदल दी गई है। आप इसे प्राप्त कर सकते हैं getpid())।

यह फ़ाइल 7 पूर्णांक के साथ एक पाठ फ़ाइल की तरह दिखाई देगी। आप शायद इस फ़ाइल में पहले (सभी मेमोरी उपयोग) और छठे (डेटा मेमोरी का उपयोग) संख्याओं में सबसे अधिक रुचि रखते हैं।

— नकदी गाय
स्रोत

ध्यान दें कि यह सभी प्लेटफार्मों पर समर्थित नहीं है।

— कैशको

लिनक्स मैन पेज ( linux.die.net/man/2/getrusage ) के अनुसार, गेट्रेज SVr4, 4.3BSD और POSIX.1-2001 स्पेक्स का हिस्सा है (यह देखते हुए कि POSIX केवल utime और stime फ़ील्ड्स को निर्दिष्ट करता है।) उम्मीद नहीं की जाती कि यह गैर-यूनिक्स प्लेटफॉर्म पर काम करे (सिगविन की तरह एक वातावरण के माध्यम से, शायद, जो अन्य प्लेटफार्मों के लिए UNIX प्रदान करता है।)

— डेविड सी।

@DavidC। ओपी लिनक्स के बारे में पूछ रहा है।

— एलेक्सिस विल्के जुएल

@CashCow, क्या आपका मतलब था getpid(), क्योंकि मैं getprocessid()लिनक्स के तहत C / C ++ में एक फ़ंक्शन के बारे में नहीं जानता ।

— एलेक्सिस विलके

12

Valgrind विस्तृत जानकारी दिखा सकता है, लेकिन यह लक्ष्य एप्लिकेशन को काफी धीमा कर देता है, और अधिकांश समय यह ऐप के व्यवहार को बदल देता है।
एक्साम कुछ ऐसा था जो मुझे अभी तक पता नहीं था, लेकिन ऐसा लगता है कि आपको जानकारी प्राप्त करने के लिए एक कर्नेल मॉड्यूल की आवश्यकता है , जो एक बाधा हो सकती है।

मुझे लगता है कि हर कोई WRT "मेमोरी उपयोग" जानना चाहता है निम्नलिखित है ...
लिनक्स में, एक एकल प्रक्रिया का उपयोग करने वाली भौतिक मेमोरी की मात्रा को मोटे तौर पर निम्नलिखित श्रेणियों में विभाजित किया जा सकता है।

मा गुमनाम स्मृति
- .p निजी
  - .d गंदा == मॉलॉक / मिमीपेड ढेर और स्टैक आवंटित और लिखित मेमोरी
  - .c क्लीन == मॉलोक / मिमीपेड हीप और स्टैक मेमोरी को एक बार आवंटित, लिखित, फिर मुक्त किया गया, लेकिन अभी तक पुनः प्राप्त नहीं किया गया
- .s साझा किया
  - .d गंदा == मॉलोक / एमएमएपीड हीप को कॉपी-ऑन-राइट और प्रक्रियाओं के बीच साझा किया जा सकता है (संपादित)
  - .c साफ == मॉलोक / एमएमएपीड ढेर को कॉपी-ऑन-राइट और प्रक्रियाओं के बीच साझा किया जा सकता है (संपादित)
Mn का नाम मैप्ड मेमोरी है
- .p निजी
  - .d गंदा == फ़ाइल लिखी गई मेमोरी निजी रूप से मिली हुई है
  - .c क्लीन == मैप्ड प्रोग्राम / लाइब्रेरी टेक्स्ट प्राइवेट मैप्ड
- .s साझा किया
  - .d गंदा == फ़ाइल साझा की गई मेमरी साझा की गई
  - .c clean == मैप किया गया लाइब्रेरी टेक्स्ट साझा मैप किया गया

एंड्रॉइड में शोमैप नाम की उपयोगिता काफी उपयोगी है

virtual                    shared   shared   private  private
size     RSS      PSS      clean    dirty    clean    dirty    object
-------- -------- -------- -------- -------- -------- -------- ------------------------------
       4        0        0        0        0        0        0 0:00 0                  [vsyscall]
       4        4        0        4        0        0        0                         [vdso]
      88       28       28        0        0        4       24                         [stack]
      12       12       12        0        0        0       12 7909                    /lib/ld-2.11.1.so
      12        4        4        0        0        0        4 89529                   /usr/lib/locale/en_US.utf8/LC_IDENTIFICATION
      28        0        0        0        0        0        0 86661                   /usr/lib/gconv/gconv-modules.cache
       4        0        0        0        0        0        0 87660                   /usr/lib/locale/en_US.utf8/LC_MEASUREMENT
       4        0        0        0        0        0        0 89528                   /usr/lib/locale/en_US.utf8/LC_TELEPHONE
       4        0        0        0        0        0        0 89527                   /usr/lib/locale/en_US.utf8/LC_ADDRESS
       4        0        0        0        0        0        0 87717                   /usr/lib/locale/en_US.utf8/LC_NAME
       4        0        0        0        0        0        0 87873                   /usr/lib/locale/en_US.utf8/LC_PAPER
       4        0        0        0        0        0        0 13879                   /usr/lib/locale/en_US.utf8/LC_MESSAGES/SYS_LC_MESSAGES
       4        0        0        0        0        0        0 89526                   /usr/lib/locale/en_US.utf8/LC_MONETARY
       4        0        0        0        0        0        0 89525                   /usr/lib/locale/en_US.utf8/LC_TIME
       4        0        0        0        0        0        0 11378                   /usr/lib/locale/en_US.utf8/LC_NUMERIC
    1156        8        8        0        0        4        4 11372                   /usr/lib/locale/en_US.utf8/LC_COLLATE
     252        0        0        0        0        0        0 11321                   /usr/lib/locale/en_US.utf8/LC_CTYPE
     128       52        1       52        0        0        0 7909                    /lib/ld-2.11.1.so
    2316       32       11       24        0        0        8 7986                    /lib/libncurses.so.5.7
    2064        8        4        4        0        0        4 7947                    /lib/libdl-2.11.1.so
    3596      472       46      440        0        4       28 7933                    /lib/libc-2.11.1.so
    2084        4        0        4        0        0        0 7995                    /lib/libnss_compat-2.11.1.so
    2152        4        0        4        0        0        0 7993                    /lib/libnsl-2.11.1.so
    2092        0        0        0        0        0        0 8009                    /lib/libnss_nis-2.11.1.so
    2100        0        0        0        0        0        0 7999                    /lib/libnss_files-2.11.1.so
    3752     2736     2736        0        0      864     1872                         [heap]
      24       24       24        0        0        0       24 [anon]
     916      616      131      584        0        0       32                         /bin/bash
-------- -------- -------- -------- -------- -------- -------- ------------------------------
   22816     4004     3005     1116        0      876     2012 TOTAL

— होम्स
स्रोत

10

कोशिश करने के लिए तीन और तरीके:

ps aux --sort pmem
यह द्वारा उत्पादन को हल करता है %MEM।
ps aux | awk '{print $2, $4, $11}' | sort -k2r | head -n 15
यह पाइप का उपयोग करके छंटनी करता है।
top -a
इसके द्वारा शीर्ष छँटाई शुरू होती है %MEM

( यहां से निकाला गया )

— थॉमस शैकर
स्रोत

2

topऔर शायद अन्य लोग वास्तव में प्रक्रिया द्वारा उपयोग की जाने वाली स्मृति का सटीक प्रतिनिधित्व नहीं करते हैं। उदाहरण के लिए, मेरे पास 64GiB RAM है, और मेरे पास postgresप्रत्येक रिपोर्टिंग 16GiB RES और 25% MEM प्रत्येक 10 प्रक्रियाएं हैं। बेशक, वे सभी 25% का उपयोग नहीं कर सकते हैं ... प्रत्येक में 15GiB SHR भी है, और ऐसा लगता है कि वे इसे साझा कर रहे हैं।

— sudo

8

#!/bin/ksh
#
# Returns total memory used by process $1 in kb.
#
# See /proc/NNNN/smaps if you want to do something
# more interesting.
#

IFS=$'\n'

for line in $(</proc/$1/smaps)
do
   [[ $line =~ ^Size:\s+(\S+) ]] && ((kb += ${.sh.match[1]}))
done

print $kb

— pokute
स्रोत

5

ksh एक मानक शेल है। यह डेस्कटॉप यूजर्स के लिए या न्यूनतर उद्देश्यों के लिए लिनक्स डिस्ट्रोस पर डिफ़ॉल्ट रूप से इंस्टॉल नहीं किया जा सकता है, लेकिन यह लगभग किसी भी यूनिक्स- / लिनक्स ओएस में केवल एक कमांड है। (यानी सभी बीएसडी पर, सभी वास्तविक यूनिक्स पर, आरएचईएल पर, एसएलईएस पर, डेबियन पर, उबंटू पर, ओएसएक्स पर)

— फ्लोरियन हीगल

यह फ़ाइल डिफ़ॉल्ट रूप से सुलभ है, केवल रूट उपयोगकर्ता के लिए।

— दिमित्री गिंजबर्ग

निम्नलिखित में बस फिर से लिखा गया है sed | awkऔर बिजीबॉक्स v1.23.2 में काम करता है: sed -n 's/^Size:\s\+$\S\+$ .*/\1/p' /proc/$1/smaps | awk '{s+=$1} END {print s}'

— JAN Sáreník

1

@ कैटस्कुल - पोसिक्स मानक अपने मानक शेल को बोर्न शेल के वर्धित संस्करण, कोर्न शेल के सख्त उपसमुच्चय के रूप में निर्दिष्ट करता है।

— ceph3us

8

मैं उपयोग कर रहा हूं htop; यह विंडोज टास्क मैनेजर के समान एक बहुत अच्छा कंसोल प्रोग्राम है।

— टॉमस डज़ीसीलेवस्की
स्रोत

मैंने उपयोग किया htopऔर शीर्ष से बेहतर है, लेकिन फिर भी यह आपको अलग-अलग ऐप के सभी थ्रेड्स दिखाएगा, बिना उन्हें समूहीकृत किए बिना यह लगभग शीर्ष के रूप में बेकार बना देगा।

— सोरिन

1

$ htop -p $ (pgrep <अपनी प्रक्रिया का नाम> | xargs | tr '' ',')

— AAAfarmclub

6

यदि प्रक्रिया बहुत अधिक मेमोरी का उपयोग नहीं कर रही है (या तो क्योंकि आप इस मामले की उम्मीद करते हैं, या कुछ अन्य कमांड ने यह प्रारंभिक संकेत दिया है), और प्रक्रिया को थोड़े समय के लिए रोका जा सकता है, तो आप कोशिश कर सकते हैं gcore कमांड का उपयोग करें।

gcore <pid>

किसी विशेष प्रक्रिया का उपयोग करने के लिए कितनी अच्छी मेमोरी है यह जानने के लिए जेनरेट की गई कोर फाइल के आकार की जांच करें।

यह बहुत अच्छी तरह से काम नहीं करेगा अगर प्रक्रिया सैकड़ों megs या gigs का उपयोग कर रही है, क्योंकि कोर पीढ़ी को I / O प्रदर्शन के आधार पर बनाने में कई सेकंड या मिनट लग सकते हैं। कोर निर्माण के दौरान स्मृति परिवर्तन को रोकने के लिए प्रक्रिया को रोक दिया जाता है (या "जमे हुए")। तो सावधान रहें।

यह भी सुनिश्चित करें कि जहां कोर उत्पन्न होता है वहां माउंट बिंदु में डिस्क स्थान बहुत अधिक है और यह कि सिस्टम उस विशेष निर्देशिका में बनाई जा रही कोर फ़ाइल पर नकारात्मक प्रतिक्रिया नहीं करेगा।

— रोको कोर्सी
स्रोत

6

मैं आर्क लिनक्स का उपयोग कर रहा हूं और इस अद्भुत पैकेज को कहा जाता है ps_mem

ps_mem -p <pid>

उदाहरण आउटपुट

$ ps_mem -S -p $(pgrep firefox)

Private   +   Shared  =  RAM used   Swap used   Program

355.0 MiB +  38.7 MiB = 393.7 MiB    35.9 MiB   firefox
---------------------------------------------
                        393.7 MiB    35.9 MiB
=============================================

— GypsyCosmonaut
स्रोत

5

नीचे कमांड लाइन आपको एमबी में लिनक्स मशीन पर चल रही विभिन्न प्रक्रिया द्वारा उपयोग की जाने वाली कुल मेमोरी देगी

ps -eo size,pid,user,command --sort -size | awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' | awk '{total=total + $1} END {print total}'

— Vineeth
स्रोत

5

अधिक "वास्तविक दुनिया" के उपयोग की एक अच्छी परीक्षा आवेदन को खोलना है, फिर vmstat -s"सक्रिय मेमोरी" सांख्यिकीय को चलाएं और जांचें। एप्लिकेशन को बंद करें, कुछ सेकंड प्रतीक्षा करें और vmstat -sफिर से चलाएं । हालांकि बहुत सक्रिय स्मृति को मुक्त कर दिया गया था जो जाहिर तौर पर ऐप द्वारा उपयोग में था।

— निक डब्ल्यू।
स्रोत

3

यह ps से बेहतर कैसे होगा ?? यह पीएस की सभी सीमा के साथ आता है और यह और भी अधिक गलत है ...

— लेस्टर चेउंग

एक विशिष्ट यूनिक्स प्रणाली में हर समय शुरू और परिष्करण की कई प्रक्रिया होती है। आप अपने मुफ़्त रैम की भविष्यवाणी नहीं कर सकते।

— राउल सालिनास-मोंटियागुडो 14

4

वैराग्य प्राप्त करो। इसे चलाने के लिए अपना कार्यक्रम दें, और यह आपको इसके मेमोरी उपयोग के बारे में बहुत कुछ बताएगा।

यह केवल उस प्रोग्राम के मामले के लिए लागू होगा जो कुछ समय के लिए चलता है और रुक जाता है। मुझे नहीं पता कि वैलग्राइंड अपने हाथों को पहले से चल रही प्रक्रिया पर प्राप्त कर सकता है या डेमॉन जैसी प्रक्रियाओं को रोकना नहीं चाहिए।

— DarenW
स्रोत

नहीं, यह संभव नहीं है कि एक चल रही प्रक्रिया को "संलग्न" करें। वह डिजाइन द्वारा है।

— दिमा तिस्नेक

3

संपादित करें: यह केवल 100% अच्छी तरह से काम करता है जब मेमोरी खपत बढ़ जाती है

यदि आप दी गई प्रक्रिया द्वारा मेमोरी उपयोग की निगरानी करना चाहते हैं (या संसाधित किए गए साझा नाम का समूह, उदाहरण के लिए google-chrome, आप मेरी बैश-स्क्रिप्ट का उपयोग कर सकते हैं:

while true; do ps aux | awk ‚{print $5, $11}’ | grep chrome | sort -n > /tmp/a.txt; sleep 1; diff /tmp/{b,a}.txt; mv /tmp/{a,b}.txt; done;

यह लगातार परिवर्तनों की तलाश करेगा और उन्हें प्रिंट करेगा।

यहां छवि विवरण दर्ज करें

— test30
स्रोत

3

यदि आप वाल्ग्रिंड के साथ प्रोफाइलिंग की तुलना में कुछ जल्दी चाहते हैं और आपकी कर्नेल बड़ी है और आप स्मैप का उपयोग नहीं कर सकते हैं, तो प्रक्रिया के निवासी सेट को दिखाने के लिए विकल्पों के साथ एक ps (साथ ps -o rss,command) आपको _aproximation_वास्तविक राशि का त्वरित और उचित लाभ दे सकता है गैर-स्वैप की गई मेमोरी का उपयोग किया जा रहा है।

— juanjux
स्रोत

3

मेरा सुझाव है कि आप सबसे ऊपर का उपयोग करें। आप इस पृष्ठ पर इसके बारे में सब कुछ पा सकते हैं । यह आपकी प्रक्रियाओं के लिए सभी आवश्यक KPI प्रदान करने में सक्षम है और यह एक फ़ाइल पर भी कब्जा कर सकता है।

— जैन रच
स्रोत

2

इस प्रक्रिया के PSIZE ["आनुपातिक मेमोरी साइज़ (या उपयोगकर्ता)] atop -Rको दिखाने के लिए लॉन्च करें । प्रति उपयोगकर्ता सारांश पुश दिखाने के लिए p, मेमोरी उपयोग पुश 'M' को छाँटने के लिए इसे atop के भीतर से सॉर्ट करें। यह smem की तुलना में समान संख्या देता है।

— मार्कस स्ट्रॉस

2

Linux में एप्लिकेशन द्वारा मेमोरी उपयोग की जांच के लिए शेल स्क्रिप्ट की जाँच करें । पेस्ट और बीसी के बिना भी गीथूब पर और एक संस्करण में उपलब्ध है ।

— बोबिन ज़चारी
स्रोत

1

के लिए एक और वोट valgrindयहां, लेकिन मैं यह जोड़ना चाहूंगा कि आप वैलेइंड द्वारा उत्पन्न परिणामों की व्याख्या करने में मदद करने के लिए एलेयूप जैसे उपकरण का उपयोग कर सकते हैं ।

मैं हर समय दो उपकरणों का उपयोग करता हूं और हमेशा इसके लिए गर्व करने के लिए दुबला, गैर-लीक कोड होता हूं;)

— सज्जन
स्रोत

1

हालांकि यह प्रश्न वर्तमान में चल रही प्रक्रियाओं की जांच के बारे में प्रतीत होता है, मैं शुरू से अंत तक एक एप्लिकेशन द्वारा उपयोग की जाने वाली शिखर मेमोरी को देखना चाहता था। वैलग्राइंड के अलावा, आप टैस्टिम का उपयोग कर सकते हैं , जो बहुत सरल है। यह "हाईवाटर" मेमोरी उपयोग (आरएसएस और वर्चुअल) को मापता है। से इस जवाब ।

— jtpereyda
स्रोत

अधिकांश अनुप्रयोग - अर्थात, जो लोग मॉलॉक () और मॉलोक जैसी मेमोरी लाइब्रेरी का उपयोग करते हैं - समाप्ति समाप्ति तक ओएस पर पृष्ठ वापस नहीं करते हैं। तो पीएस (या प्रक्रिया के ढेर में खुदाई नहीं करता है) के साथ आपके द्वारा देखी जाने वाली राशि उच्च जल चिह्न होगी।

— डेविड सी।

0

संबंधित प्रश्न के उत्तर के आधार पर ।

नेटवर्क में किसी विशेष डिवाइस में मेमोरी और सीपीयू प्रक्रिया को प्राप्त करने के लिए आप SNMP का उपयोग कर सकते हैं :)

आवश्यकताएँ:

प्रक्रिया को चलाने वाले उपकरण में स्नैम्प स्थापित होना चाहिए और चलना चाहिए
snmp को उन अनुरोधों को स्वीकार करने के लिए कॉन्फ़िगर किया जाना चाहिए जहां से आप नीचे दी गई स्क्रिप्ट को चलाएंगे (यह snmpd.conf में कॉन्फ़िगर किया जा सकता है)
आपको उस प्रक्रिया की प्रक्रिया आईडी (पीआईडी) पता होनी चाहिए जिसे आप मॉनिटर करना चाहते हैं

टिप्पणियाँ:

HOST-RESOURCES-MIB :: hrSWRunPerfCPU इस प्रणाली द्वारा खपत कुल सिस्टम CPU संसाधनों के सेंटी -सेकंड की संख्या है। ध्यान दें कि बहु-प्रोसेसर प्रणाली पर, यह मान वास्तविक (दीवार घड़ी) के एक सेंटी-सेकंड में एक सेंटी-सेकंड से अधिक की वृद्धि हो सकती है।
HOST-RESOURCES-MIB :: hrSWRunPerfMem इस प्रक्रिया के लिए आवंटित वास्तविक सिस्टम मेमोरी की कुल राशि है।

**

प्रक्रिया की निगरानी स्क्रिप्ट:

**

echo "IP: "
read ip
echo "specfiy pid: "
read pid
echo "interval in seconds:"
read interval

while [ 1 ]
do
    date
    snmpget -v2c -c public $ip HOST-RESOURCES-MIB::hrSWRunPerfCPU.$pid
    snmpget -v2c -c public $ip HOST-RESOURCES-MIB::hrSWRunPerfMem.$pid
    sleep $interval;
done

— रोजली वर्बो डोमिंगो
स्रोत

0

/ prox / xxx / numa_maps वहां कुछ जानकारी देता है: N0 = ??? एन 1 = ???। लेकिन यह परिणाम वास्तविक परिणाम से कम हो सकता है, क्योंकि यह केवल उन लोगों को गिनता है जिन्हें छुआ गया है।

— ptan
स्रोत

-1

Ubuntu में उपलब्ध इन -बिल्ट ' सिस्टम मॉनिटर ' GUI टूल का उपयोग करें

— Sudheesh.MS
स्रोत

1

कम से कम 16.04 से जो बहुत अच्छी तरह से काम करता है। यह बहुत ज्यादा पसंद है, हालांकि, इस्तेमाल की जाने वाली स्मृति बहुत सटीक नहीं है ...

— एलेक्सिस विलके

किसी एप्लिकेशन या प्रक्रिया का वास्तविक मेमोरी उपयोग कैसे मापें?

बाहर निकलने का समय: