स्मृति उपयोग द्वारा प्रक्रियाओं को क्रमबद्ध करना

128

मैं सभी प्रक्रियाओं की सूची और मेमोरी को देखने में सक्षम हूं

ps aux

और वीएसजेड और आरएसएस के माध्यम से जा रहा है

क्या RSS मूल्य पर अवरोही क्रम द्वारा इस कमांड के आउटपुट को क्रमबद्ध करने का कोई तरीका है?

linux memory

— user2817836
स्रोत

अपेक्षित आउटपुट क्या होगा? चेकps

— राहुल पाटिल

कैसे उपयोग करने के लिए के अतिरिक्त उदाहरणों में --sortयहां हैं: alvinalexander.com/linux/...

— SLM

1

सुपरसेट प्रश्न, किसी भी टूल का उपयोग करते हुए: stackoverflow.com/questions/4802481/…

— Ciro Santilli 中心 using using using ''

223

निम्नलिखित आदेश का उपयोग करें:

ps aux --sort -rss

अधिक लिनक्स प्रक्रिया मेमोरी उपयोग के लिए यहां देखें

— coffeMug
स्रोत

12

ध्यान दें - यदि आप शीर्ष परिणाम देखना चाहते हैं तो इसे पाइप करने में मददगार है headजैसेps aux --sort -rss | head -n15

— Yehosef

3

मुझे त्रुटि मिलती है ps: illegal option -- -

— मिगुएल मोटा

@MiguelMota इस तरह से क्या करें ps aux --sort=rss:?

— coffeMug

2

@coffeMug ने काम नहीं किया लेकिन यह कियाps aux | sort -rn -k 6

— मिगुएल मोटा

1

@coffeMug को यकीन नहीं है कि संस्करण कैसे खोजना है लेकिन मैं मैक ओएसएक्स पर हूं इसलिए शायद

— मिगुएल मोटा

24

एक त्वरित और गंदी विधि सिर्फ कमांड के आउटपुट को पाइप करने के ps auxलिए है sort:

$ ps aux | sort -rn -k 5,6

उदाहरण

$ ps aux | sort -rn -k 5,6
...
root      1584  0.0  0.0  22540  1236 ?        S    07:04   0:01 hald-addon-storage: polling /dev/sr0 (every 2 sec)
root      1575  0.0  0.0  22536   872 ?        S    07:04   0:00 /usr/libexec/hald-addon-generic-backlight
root      1574  0.0  0.0  22536   880 ?        S    07:04   0:00 /usr/libexec/hald-addon-leds
root      1565  0.0  0.0  22536   876 ?        S    07:04   0:00 /usr/libexec/hald-addon-rfkill-killswitch
saml      2507  0.0  0.0  22232   500 ?        S    07:05   0:00 dbus-launch --sh-syntax --exit-with-session
root      1671  0.0  0.0  22156   936 ?        Ss   07:04   0:00 xinetd -stayalive -pidfile /var/run/xinetd.pid
...

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

उदाहरण

root      1791  0.0  0.0   4140   536 tty2     Ss+  07:04   0:00 /sbin/mingetty /dev/tty2
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root       996  0.0  0.0      0     0 ?        S    07:04   0:01 [kdmflush]
root       982  0.0  0.0      0     0 ?        S    07:04   0:00 [kvm-irqfd-clean]

अधिक सुझाव

एक अतिरिक्त टिप इस तरह के रूप में एक और आदेश के लिए पूरे उत्पादन पाइप करने के लिए किया जाएगा less। यह आपको जानकारी को एक समय में एक पृष्ठ को देखने की अनुमति देता है और आउटपुट के माध्यम से आगे और पीछे स्क्रॉल करने के लिए तीर कुंजी और पेज अप / डाउन कुंजी का भी उपयोग करता है।

$ ps aux | sort -rn -k 5,6 | less

यदि आपका आउटपुट बहुत अधिक लपेट रहा है, तो आप -Sस्विच को कम करने के लिए भी उपयोग कर सकते हैं , जो सभी आउटपुट को एक लाइन पर रहने के लिए मजबूर करेगा। फिर आप इसे देखने के लिए अपने तीर कुंजी का उपयोग बाएं / दाएं / ऊपर / नीचे ले जाने के लिए कर सकते हैं।

$ ps aux | sort -rn -k 5,6 | less -S

पीएस के भीतर छंटनी

कुछ संस्करण psउपयोग करने की क्षमता प्रदान करते हैं --sort। यह स्विच तो कुंजी है कि या तो एक लगी होती हैं ले जा सकते हैं +या एक -कम से कम के लिए सबसे बड़ा या सबसे बड़ी करने के लिए सॉर्ट क्रम को निरूपित करने के ... कम से कम।

उदाहरण

vsz, -rss

$ ps aux --sort=vsz,-rss | head -5
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         2  0.0  0.0      0     0 ?        S    07:03   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S    07:03   0:00 [ksoftirqd/0]
root         4  0.0  0.0      0     0 ?        S    07:03   0:01 [migration/0]
root         5  0.0  0.0      0     0 ?        S    07:03   0:00 [watchdog/0]

+ Vsz, + आरएसएस

$ ps aux --sort=+vsz,+rss | head -5
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         2  0.0  0.0      0     0 ?        S    07:03   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S    07:03   0:00 [ksoftirqd/0]
root         4  0.0  0.0      0     0 ?        S    07:03   0:01 [migration/0]
root         5  0.0  0.0      0     0 ?        S    07:03   0:00 [watchdog/0]

-vsz, -rss

$ ps aux --sort=-vsz,-rss | head -5
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      1832  0.0  0.0 2088924 3312 ?        Sl   07:04   0:00 /usr/sbin/console-kit-daemon --no-daemon
saml      3517  0.2  1.2 2073196 100492 ?      Sl   07:06   0:34 /home/saml/.dropbox-dist/dropbox
saml      3516  0.0  0.8 2071032 67388 ?       Sl   07:06   0:07 /home/saml/.dropbox-dist/dropbox
saml      2657  0.1  0.7 1580936 57788 ?       Sl   07:05   0:27 nautilus

— slm
स्रोत

ps हमेशा कॉलम को उसी तरह से आउटपुट करेंगे जैसे आप sortउन्हें देखने / संसाधित करने की उम्मीद करते हैं?

— फेलिप अल्वारेज़

Ps का कौन सा संस्करण पर निर्भर करता है

— SLM

2

A ... | lessएक अच्छी सलाह है लेकिन कभी-कभी आपकी प्रक्रिया में एक बड़ी कमांड लाइन होती है और यह आउटपुट को बंद कर देती है। ऐसे मामलों में ... | less -Sबेहतर काम करता है।

— बर्बाद

@waste - अच्छा टिप, बस याद रखें कि ट्रंकट्स -Sऔर इसलिए आप कुछ खो सकते हैं जो आप देखना चाहते हैं, लेकिन अन्यथा अच्छी सलाह यदि आप केवल सबसे बाएं कॉलम में रुचि रखते हैं।

— slm

@ एसएलएम मुझे यकीन नहीं है कि यह मामला है less -S। जब आप lessदृश्य को बंद करते हैं तो सब कुछ गायब हो जाता है, लेकिन जब तक आप दृश्य में होते हैं, तो आप लंबवत लेकिन क्षैतिज रूप से भी स्क्रॉल कर सकते हैं। हालांकि नकल करना मुश्किल हो सकता है।

— बर्बाद

6

भले ही ps उपयोग की गई वास्तविक मेमोरी को प्रतिबिंबित न करता हो, लेकिन यह कमांड काफी मददगार है।

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 "" }'

— Pierozi
स्रोत

3

ps aux --sort -rs अच्छा है:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user     5984  0.8  7.4 1632488 296056 ?      Sl   06:30   6:18 /usr/lib/chromium-browser/chromium-browser --type=ren
user    23934 21.7  6.0 1565600 241228 ?      Sl   15:45  40:10 /opt/atom/atom --type=renderer --enable-experimental-
user     5533  0.9  5.1 3154096 206376 ?      SLl  06:30   6:47 /usr/lib/chromium-browser/chromium-browser --enable-p
user    17306  1.7  4.9 1360648 196124 ?      Sl   18:14   0:36 /usr/lib/chromium-browser/chromium-browser --type=ren
user    22272 30.1  4.6 1347784 185032 ?      Sl   18:43   1:54 /usr/lib/chromium-browser/chromium-browser --type=ren
user    19318  0.6  3.3 1304324 133452 ?      Sl   18:27   0:09 /usr/lib/chromium-browser/chromium-browser --type=ren
user    22098  1.0  3.3 1298500 133216 ?      Sl   18:43   0:04 /usr/lib/chromium-browser/chromium-browser --type=ren

लेकिन अगर आप एप्लिकेशन द्वारा मेमोरी और सीपीयू उपयोग देखना चाहते हैं (कमांड द्वारा समूहीकृत):

python3.6  sum_process_resources.py 
====   CPU%   ====
0. /opt/atom/atom | 27.8
1. /usr/lib/chromium-browser/chromium-browser | 11.2
2. python3.6 | 11.0
3. /opt/google/chrome/chrome | 1.6
4. /usr/lib/xorg/Xorg | 1.4
5. /opt/Franz/franz | 0.7
====   MEM%   ====
0. /usr/lib/chromium-browser/chromium-browser | 37.2
1. /opt/google/chrome/chrome | 11.3
2. /opt/Franz/franz | 10.6
3. /opt/atom/atom | 10.1
4. /usr/lib/xorg/Xorg | 2.0
5. com.google.android.gms.persistent | 1.4
====   RSS MB   ====
0. /usr/lib/chromium-browser/chromium-browser | 1475.07 MB
1. /opt/google/chrome/chrome | 461.35 MB
2. /opt/Franz/franz | 429.04 MB
3. /opt/atom/atom | 402.18 MB
4. /usr/lib/xorg/Xorg | 78.53 MB
5. com.google.android.gms.persistent | 58.02 MB

कोड:

#sum_process_resources.py
from collections import OrderedDict
import subprocess

def run_cmd(cmd_string):
    """Runs commands and saves output to variable"""
    cmd_list = cmd_string.split(" ")
    popen_obj = subprocess.Popen(cmd_list, stdout=subprocess.PIPE)
    output = popen_obj.stdout.read()
    output = output.decode("utf8")
    return output

def sum_process_resources():
    """Sums top X cpu and memory usages grouped by processes"""
    ps_memory, ps_cpu, ps_rss = {}, {}, {}
    top = 6
    output = run_cmd('ps aux').split("\n")
    for i, line in enumerate(output):
        cleaned_list = " ".join(line.split())
        line_list = cleaned_list.split(" ")
        if i > 0 and len(line_list) > 10:
            cpu = float(line_list[2])
            memory = float(line_list[3])
            rss = float(line_list[5])
            command = line_list[10]
            ps_cpu[command] = round(ps_cpu.get(command, 0) + cpu, 2)
            ps_memory[command] = round(ps_memory.get(command, 0) + memory, 2)
            ps_rss[command] = round(ps_rss.get(command, 0) + rss, 2)
    sorted_cpu = OrderedDict(sorted(ps_cpu.items(), key=lambda x: x[1], reverse=True))
    sorted_memory = OrderedDict(sorted(ps_memory.items(), key=lambda x: x[1], reverse=True))
    sorted_rss = OrderedDict(sorted(ps_rss.items(), key=lambda x: x[1], reverse=True))
    print("====   CPU%   ====")
    for i, k in enumerate(sorted_cpu.items()):
        if i < top:
            print("{}. {} | {}".format(i, k[0], k[1]))
    print("====   MEM%   ====")
    for i, k in enumerate(sorted_memory.items()):
        if i < top:
            print("{}. {} | {}".format(i, k[0], k[1]))
    print("====   RSS MB   ====")
    for i, k in enumerate(sorted_rss.items()):
        if i < top:
            print("{}. {} | {} MB".format(i, k[0], round((k[1]/1024), 2)))


if __name__ == '__main__':
    sum_process_resources()

— jturi
स्रोत

1

अन्य उत्तरों में दिखाए गए बीएसडी शैली के तर्कों के विकल्प के रूप में, कोई भी (डेबियन और उबंटू द्वारा भेज दिए गए कम से कम उपयोग करके, उपयोग कर सकता है):

ps -eF --sort=-rss

— user30747
स्रोत

1

सरल तरीका है htop स्थापित करना

उस में आप पीआईडी, प्रतिशत सीपीयू, एमईएम के आधार पर प्रक्रिया को सॉर्ट कर सकते हैं

और अधिक परिष्कृत

— Ayyanar
स्रोत

0

topकमांड चलाएं
Shift + F फ़ील्ड के आधार पर छाँटने के लिए (नीचे पूर्ण मेनू देखें)
nमेमोरी उपयोग के आधार पर छाँटने का चयन करें

n:% MEM = मेमोरी उपयोग (RES)

— सबरीना
स्रोत

0

प्रक्रिया नाम से कुल मेमोरी का उपयोग कैसे करें:

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

ps -e -orss=,args= |awk '{print $1 " " $2 }'| awk '{tot[$2]+=$1;count[$2]++} END {for (i in tot) {print tot[i],i,count[i]}}' | sort -n

उदा आउटपुट

9344 docker 1
9948 nginx: 4
22500 /usr/sbin/NetworkManager 1
24704 sleep 69
26436 /usr/sbin/sshd 15
34828 -bash 19
39268 sshd: 10
58384 /bin/su 28
59876 /bin/ksh 29
73408 /usr/bin/python 2
78176 /usr/bin/dockerd 1
134396 /bin/sh 84
5407132 bin/naughty_small_proc 1432
28061916 /usr/local/jdk/bin/java 7

— gaoithe
स्रोत