दिलचस्प पोस्ट
आईडीई के बिना एक सैमसंग स्मार्ट टीवी ऐप बनाने और तैनात करने का तरीका (उदाहरण: लिनक्स पर) C ++ में रिटर्न स्टेटमेंट को छोड़कर Windows बैच स्क्रिप्ट (.bat) में दिए गए तर्कों की सूची प्राप्त करें @ प्री-अपेट और @ क्रेपरिसिस्ट हाइबरनेट / जेपीए (सत्र का उपयोग कर) Internet Explorer में Mozilla's toSource () विधि को लागू करना .NET में दो बाइट सरणियों की तुलना करना जावास्क्रिप्ट के पैरासेन्ट अष्टक व्यवहार के आसपास मैं कैसे काम करूं? ScrollView प्रोग्राम को अक्षम करें? उथले क्लोन और विरल चेकआउट में सेट करें Git submodule? जब मैं अपनी वेबसाइट को रीफ़्रेश करता हूं मुझे 404 मिलता है। यह अंगुलर 2 और फायरबेस के साथ है जावा वेबस्टार्ट के माध्यम से चलने के दौरान आउटलुकेटर में NullPointerException स्विफ्ट 3 में क्लोजर अपडेट करना – @capcaping क्वेरीस्ट्रिंग के बिना यूआरएल प्राप्त करें HtmlUnit चेतावनियां बंद करना आईडी द्वारा लाखों पंक्तियों को हटाने का सर्वोत्तम तरीका

लिनक्स में कौन से प्रक्रियाएं गमागमन कर रही हैं यह कैसे पता चलेगा?

लिनक्स के अंतर्गत, मैं कैसे पता लगा सकता हूँ कि कौन सा प्रक्रिया स्वैप स्पेस का उपयोग कर रही है?

Solutions Collecting From Web of "लिनक्स में कौन से प्रक्रियाएं गमागमन कर रही हैं यह कैसे पता चलेगा?"

शीर्ष पर जाएं तो पी दर्ज करें दबाएं । अब प्रक्रियाओं को उनके स्वैप उपयोग के आधार पर क्रमबद्ध किया जाना चाहिए।

यहां एक अपडेट है, जैसा कि मेरे मूल उत्तर में टिप्पणी में बताया गया समस्या के बारे में सटीक उत्तर नहीं दिया गया है। Htop से पूछे जाने वाले प्रश्न से :

प्रसंस्करण के प्रयुक्त स्वैप स्पेस के सटीक आकार को प्राप्त करना संभव नहीं है। शीर्ष इस जानकारी को SWAP = VIRT – RES द्वारा बनाते हैं, लेकिन यह एक अच्छी मीट्रिक नहीं है, क्योंकि वीडियो मेमोरी जैसे अन्य सामान के रूप में अच्छी तरह से वीरटी पर गिना जाता है (उदाहरण के लिए: शीर्ष कहते हैं कि मेरी एक्स प्रक्रिया 81 एम स्वैप का उपयोग कर रही है, लेकिन यह भी मेरी प्रणाली पूरी तरह से केवल 2 एम स्वैप का उपयोग कर रही है इसलिए मैं एक ऐसी स्वैप कॉलम को एचटीपी में नहीं जोड़ूंगा क्योंकि मुझे यह जानकारी प्राप्त करने का एक विश्वसनीय तरीका नहीं है (वास्तव में, मुझे नहीं लगता कि यह संभव है साझा किए गए पृष्ठों की वजह से सटीक नंबर)

मैंने पाया सबसे अच्छी स्क्रिप्ट इस पृष्ठ पर है: http://northernmost.org/blog/find-out-what-is-using-your-swap/

यहां स्क्रिप्ट का एक प्रकार है और इसकी जरूरी आवश्यकता नहीं है:

#!/bin/bash # Get current swap usage for all running processes # Erik Ljungstrom 27/05/2011 # Modified by Mikko Rantalainen 2012-08-09 # Pipe the output to "sort -nk3" to get sorted output # Modified by Marc Methot 2014-09-18 # removed the need for sudo SUM=0 OVERALL=0 for DIR in `find /proc/ -maxdepth 1 -type d -regex "^/proc/[0-9]+"` do PID=`echo $DIR | cut -d / -f 3` PROGNAME=`ps -p $PID -o comm --no-headers` for SWAP in `grep VmSwap $DIR/status 2>/dev/null | awk '{ print $2 }'` do let SUM=$SUM+$SWAP done if (( $SUM > 0 )); then echo "PID=$PID swapped $SUM KB ($PROGNAME)" fi let OVERALL=$OVERALL+$SUM SUM=0 done echo "Overall swap used: $OVERALL KB" 

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

 #!/bin/bash # find-out-what-is-using-your-swap.sh # -- Get current swap usage for all running processes # -- # -- rev.0.3, 2012-09-03, Jan Smid - alignment and intendation, sorting # -- rev.0.2, 2012-08-09, Mikko Rantalainen - pipe the output to "sort -nk3" to get sorted output # -- rev.0.1, 2011-05-27, Erik Ljungstrom - initial version SCRIPT_NAME=`basename $0`; SORT="kb"; # {pid|kB|name} as first parameter, [default: kb] [ "$1" != "" ] && { SORT="$1"; } [ ! -x `which mktemp` ] && { echo "ERROR: mktemp is not available!"; exit; } MKTEMP=`which mktemp`; TMP=`${MKTEMP} -d`; [ ! -d "${TMP}" ] && { echo "ERROR: unable to create temp dir!"; exit; } >${TMP}/${SCRIPT_NAME}.pid; >${TMP}/${SCRIPT_NAME}.kb; >${TMP}/${SCRIPT_NAME}.name; SUM=0; OVERALL=0; echo "${OVERALL}" > ${TMP}/${SCRIPT_NAME}.overal; for DIR in `find /proc/ -maxdepth 1 -type d -regex "^/proc/[0-9]+"`; do PID=`echo $DIR | cut -d / -f 3` PROGNAME=`ps -p $PID -o comm --no-headers` for SWAP in `grep Swap $DIR/smaps 2>/dev/null| awk '{ print $2 }'` do let SUM=$SUM+$SWAP done if (( $SUM > 0 )); then echo -n "."; echo -e "${PID}\t${SUM}\t${PROGNAME}" >> ${TMP}/${SCRIPT_NAME}.pid; echo -e "${SUM}\t${PID}\t${PROGNAME}" >> ${TMP}/${SCRIPT_NAME}.kb; echo -e "${PROGNAME}\t${SUM}\t${PID}" >> ${TMP}/${SCRIPT_NAME}.name; fi let OVERALL=$OVERALL+$SUM SUM=0 done echo "${OVERALL}" > ${TMP}/${SCRIPT_NAME}.overal; echo; echo "Overall swap used: ${OVERALL} kB"; echo "========================================"; case "${SORT}" in name ) echo -e "name\tkB\tpid"; echo "========================================"; cat ${TMP}/${SCRIPT_NAME}.name|sort -r; ;; kb ) echo -e "kB\tpid\tname"; echo "========================================"; cat ${TMP}/${SCRIPT_NAME}.kb|sort -rh; ;; pid | * ) echo -e "pid\tkB\tname"; echo "========================================"; cat ${TMP}/${SCRIPT_NAME}.pid|sort -rh; ;; esac rm -fR "${TMP}/"; 

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

पहले के लिए आप स्वैप (प्रेस 'ओप') के top और क्रम चला सकते हैं, बाद में आप vmstat चला सकते हैं और 'ऐसा' के लिए गैर-शून्य प्रविष्टियों की खोज कर सकते हैं।

मैंने देखा है कि यह धागा बहुत पुराना है, लेकिन अगर आप उस पर ठोकर खाते हैं, जैसा मैंने किया था, एक और जवाब है: smem का उपयोग करें

यहां एक लिंक है जो आपको बताता है कि यह कैसे स्थापित करें और इसे कैसे उपयोग करें:

http://www.cyberciti.biz/faq/linux-which-process-is-using-swap/

शीर्ष आदेश में एक प्रक्रिया के लिए पृष्ठ दोष की संख्या को प्रदर्शित करने के लिए एक फ़ील्ड भी शामिल है। अधिकतम पृष्ठ दोष के साथ प्रक्रिया सबसे ज्यादा गमागमन की प्रक्रिया होगी। लंबे समय से चलाने वाले डेमन्स के लिए यह हो सकता है कि शुरुआत में बड़ी संख्या में पेज दोष होते हैं और संख्या बाद में बढ़ती नहीं है। तो हमें यह देखना होगा कि पृष्ठ दोष बढ़ रहे हैं या नहीं।

शेल में लूप से बचने वाला एक अन्य स्क्रिप्ट संस्करण:

 #!/bin/bash grep VmSwap /proc/[0-9]*/status | awk -F':' -v sort="$1" ' { split($1,pid,"/") # Split first field on / split($3,swp," ") # Split third field on space cmdlinefile = "/proc/"pid[3]"/cmdline" # Build the cmdline filepath getline pname[pid[3]] < cmdlinefile # Get the command line from pid swap[pid[3]] = sprintf("%6i %s",swp[1],swp[2]) # Store the swap used (with unit to avoid rebuilding at print) sum+=swp[1] # Sum the swap } END { OFS="\t" # Change the output separator to tabulation print "Pid","Swap used","Command line" # Print header if(sort) { getline max_pid < "/proc/sys/kernel/pid_max" for(p=1;p<=max_pid;p++) { if(p in pname) print p,swap[p],pname[p] # print the values } } else { for(p in pname) { # Loop over all pids found print p,swap[p],pname[p] # print the values } } print "Total swap used:",sum # print the sum }' 

मानक उपयोग script.sh है script.sh प्रयोग हर प्रोग्राम को यादृच्छिक क्रम के साथ प्राप्त करने के लिए करता है (नीचे से कैसे अपने script.sh 1 स्टोर करता है) या script.sh 1 द्वारा आउटपुट को सॉर्ट करने के लिए script.sh 1

मुझे उम्मीद है कि मैंने यह कोड को पर्याप्त बता दिया है कि यह क्या करता है।

अभी तक एक शैल संस्करण! (केवल बाश नहीं)

यह लोलोटक्स स्क्रिप्ट की तुलना में बिल्कुल समान है, लेकिन grep , awk या ps लिए किसी भी कांटा के बिना यह बहुत तेज है!

और जैसा कि बैश प्रदर्शन के बारे में सबसे गरीब शेल में से एक है, यह सुनिश्चित करने के लिए थोड़ा काम किया गया था कि यह स्क्रिप्ट डैश , बिडीबॉक्स और कुछ अन्य के तहत अच्छी तरह से चलाए जा सके फिर, ( स्टीफन चज़ेलस के लिए धन्यवाद ), फिर से बहुत तेज हो गया!

 #!/bin/sh # Get current swap usage for all running processes # Felix Hauri 2016-08-05 # Rewritted without fork. Inspired by first stuff from # Erik Ljungstrom 27/05/2011 # Modified by Mikko Rantalainen 2012-08-09 # Pipe the output to "sort -nk3" to get sorted output # Modified by Marc Methot 2014-09-18 # removed the need for sudo OVERALL=0 rifs=`printf ': \t'` for FILE in /proc/[0-9]*/status ;do SUM=0 while IFS="$rifs" read FIELD VALUE ;do case $FIELD in Pid ) PID=$VALUE ;; Name ) PROGNAME="$VALUE" ;; VmSwap ) SUM=$((SUM=${VALUE% *})) ;; esac done <$FILE [ $SUM -gt 0 ] && printf "PID: %9d swapped: %11d KB (%s)\n" $PID $SUM "$PROGNAME" OVERALL=$((OVERALL+SUM)) done printf "Total swapped memory: %14u KB\n" $OVERALL 

"$PROGNAME" बोली को दोहरा नहीं "$PROGNAME" ! स्टीफन चाजेलस की टिप्पणी देखें:

 read FIELD PROGNAME < <( perl -ne 'BEGIN{$0="/*/*/../../*/*"} print if /^Name/' /proc/self/status ) echo $FIELD "$PROGNAME" 

समझदार प्रणाली पर डबल उद्धरण के बिना echo $PROGNAME कोशिश मत करो, और इससे पहले मौजूदा शेल को मारने के लिए तैयार रहें!

पर्ल संस्करण

चूंकि यह एक इतनी सरल लिपि नहीं बनती है, समय और अधिक कुशल भाषा का उपयोग करके एक समर्पित उपकरण लिखने का समय आ रहा है।

 #!/usr/bin/perl -w use strict; use Getopt::Std; my ($tot,$mtot)=(0,0); my %procs; my %opts; getopt('', \%opts); sub sortres { return $a <=> $b if $opts{'p'}; return $procs{$a}->{'cmd'} cmp $procs{$b}->{'cmd'} if $opts{'c'}; return $procs{$a}->{'mswap'} <=> $procs{$b}->{'mswap'} if $opts{'m'}; return $procs{$a}->{'swap'} <=> $procs{$b}->{'swap'}; }; opendir my $dh,"/proc"; for my $pid (grep {/^\d+$/} readdir $dh) { if (open my $fh,"</proc/$pid/status") { my ($sum,$nam)=(0,""); while (<$fh>) { $sum+=$1 if /^VmSwap:\s+(\d+)\s/; $nam=$1 if /^Name:\s+(\S+)/; } if ($sum) { $tot+=$sum; $procs{$pid}->{'swap'}=$sum; $procs{$pid}->{'cmd'}=$nam; close $fh; if (open my $fh,"</proc/$pid/smaps") { $sum=0; while (<$fh>) { $sum+=$1 if /^Swap:\s+(\d+)\s/; }; }; $mtot+=$sum; $procs{$pid}->{'mswap'}=$sum; } else { close $fh; }; }; }; map { printf "PID: %9d swapped: %11d (%11d) KB (%s)\n", $_, $procs{$_}->{'swap'}, $procs{$_}->{'mswap'}, $procs{$_}->{'cmd'}; } sort sortres keys %procs; printf "Total swapped memory: %14u (%11u) KB\n", $tot,$mtot; 

एक के साथ चला सकते हैं

 -c sort by command name -p sort by pid -m sort by smap values by default, output is sorted by status's vmsize 

मुझे लगता है कि आप top चलने और बहुत सारी मेमोरी का उपयोग करके सक्रिय प्रक्रियाओं की तलाश करके एक अच्छा अनुमान प्राप्त कर सकते हैं। इस प्रोग्राम को करना कठिन है — बस लिनक्स ओओएम किलर ह्यूरिस्टिक्स के बारे में अंतहीन बहस देखें।

स्वैपिंग सक्रिय मेमोरी से अधिष्ठापन की तुलना में अधिक सक्रिय होने का एक कार्य है, इसलिए इसे एक प्रक्रिया पर दोष देना आमतौर पर मुश्किल होता है। यदि यह एक सतत समस्या है, तो सबसे अच्छा समाधान अधिक स्मृति स्थापित करना है, या अन्य सिस्टमिक परिवर्तन करना है

मुझे किसी भी प्रत्यक्ष उत्तर के बारे में नहीं पता है कि स्वैप स्पेस का उपयोग किस प्रकार किया जा सकता है, हालांकि, यह लिंक सहायक हो सकता है एक और अच्छा एक यहाँ पर है

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

मैकओएसएक्स पर, आप शीर्ष कमांड भी चलाते हैं, लेकिन "ओ" टाइप करने की आवश्यकता है, फिर "बनाम" और फिर एंटर करें

iotop एक बहुत ही उपयोगी उपकरण है iotop यह I / O के लाइव आँकड़े देता है और प्रति प्रक्रिया / धागा स्वैप उपयोग करता है। डिफ़ॉल्ट रूप से यह प्रति धागा दिखाता है लेकिन आप प्रति प्रक्रिया जानकारी प्राप्त करने के लिए iotop -P कर सकते हैं। यह डिफ़ॉल्ट रूप से उपलब्ध नहीं है आपको आरपीएम / एपीटी द्वारा स्थापित करना पड़ सकता है

मैंने इस लंबे एक-लाइनर के लिए वेब पर एक अलग स्क्रिप्ट को अनुकूलित किया है:

  { date;for f in /proc/[0-9]*/status; do awk '{k[$1]=$2} END { if (k["VmSwap:"]) print k["Pid:"],k["Name:"],k["VmSwap:"];}' $f 2>/dev/null; done | sort -n ; } 

जो मैं फिर एक क्रोनबोज़ में फेंकता हूं और आउटपुट को लॉगफ़ाइल में रीडायरेक्ट करता हूं। यहां दी गई जानकारी Swap: जमा करने के समान है Swap: smaps फ़ाइल में प्रविष्टियां, लेकिन यदि आप सुनिश्चित करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

 { date;for m in /proc/*/smaps;do awk '/^Swap/ {s+=$2} END { if (s) print FILENAME,s }' $m 2>/dev/null; done | tr -dc ' [0-9]\n' |sort -k 1n; } 

इस संस्करण का उत्पादन दो कॉलम में है: पीआईडी, स्वैप राशि उपरोक्त संस्करण में, tr गैर-संख्यात्मक घटकों को स्ट्रिप्स करता है। दोनों ही मामलों में, आउटपुट को pid ​​द्वारा संख्यात्मक रूप से सॉर्ट किया जाता है।