Comment obtenir l'utilisation actuelle du CPU et de la RAM en Python ?

Question

Quelle est votre méthode préférée pour obtenir l'état actuel du système (CPU actuel, RAM, espace disque libre, etc.) en Python ? Points bonus pour les plateformes *nix et Windows.

D'après mes recherches, il semble y avoir plusieurs façons d'extraire cette information :

1. En utilisant une bibliothèque telle que PSI (qui semble actuellement ne pas être développé activement et ne pas être supporté sur plusieurs plateformes) ou quelque chose comme pystatgrab (là encore, aucune activité depuis 2007, semble-t-il, et aucun support pour Windows).

2. L'utilisation d'un code spécifique à la plate-forme, comme l'utilisation d'un os.popen("ps") ou similaire pour les systèmes *nix et MEMORYSTATUS en ctypes.windll.kernel32 (voir cette recette sur ActiveState ) pour la plate-forme Windows. On pourrait créer une classe Python avec tous ces bouts de code.

Ce n'est pas que ces méthodes soient mauvaises, mais existe-t-il déjà un moyen multiplateforme et bien supporté de faire la même chose ?

Answer 1

Pour obtenir un ligne par ligne l'analyse de la mémoire et du temps de votre programme, je suggère d'utiliser memory_profiler y line_profiler .

Installation :

# Time profiler
$ pip install line_profiler
# Memory profiler
$ pip install memory_profiler
# Install the dependency for a faster analysis
$ pip install psutil

La partie commune est que vous spécifiez la fonction que vous voulez analyser en utilisant les décorateurs respectifs.

Exemple : J'ai plusieurs fonctions dans mon fichier Python main.py que je veux analyser. L'une d'entre elles est linearRegressionfit() . J'ai besoin d'utiliser le décorateur @profile qui m'aide à profiler le code par rapport aux deux : le temps et la mémoire.

Apportez les modifications suivantes à la définition de la fonction

@profile
def linearRegressionfit(Xt,Yt,Xts,Yts):
    lr=LinearRegression()
    model=lr.fit(Xt,Yt)
    predict=lr.predict(Xts)
    # More Code

Pour Profilage temporel ,

Cours :

$ kernprof -l -v main.py

Sortie

Total time: 0.181071 s
File: main.py
Function: linearRegressionfit at line 35

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    35                                           @profile
    36                                           def linearRegressionfit(Xt,Yt,Xts,Yts):
    37         1         52.0     52.0      0.1      lr=LinearRegression()
    38         1      28942.0  28942.0     75.2      model=lr.fit(Xt,Yt)
    39         1       1347.0   1347.0      3.5      predict=lr.predict(Xts)
    40                                           
    41         1       4924.0   4924.0     12.8      print("train Accuracy",lr.score(Xt,Yt))
    42         1       3242.0   3242.0      8.4      print("test Accuracy",lr.score(Xts,Yts))

Pour Profilage de la mémoire ,

Cours :

$ python -m memory_profiler main.py

Sortie

Filename: main.py

Line #    Mem usage    Increment   Line Contents
================================================
    35  125.992 MiB  125.992 MiB   @profile
    36                             def linearRegressionfit(Xt,Yt,Xts,Yts):
    37  125.992 MiB    0.000 MiB       lr=LinearRegression()
    38  130.547 MiB    4.555 MiB       model=lr.fit(Xt,Yt)
    39  130.547 MiB    0.000 MiB       predict=lr.predict(Xts)
    40                             
    41  130.547 MiB    0.000 MiB       print("train Accuracy",lr.score(Xt,Yt))
    42  130.547 MiB    0.000 MiB       print("test Accuracy",lr.score(Xts,Yts))

De plus, les résultats du profileur de mémoire peuvent également être tracés en utilisant matplotlib en utilisant

$ mprof run main.py
$ mprof plot

Note : Testé sur

line_profiler version == 3.0.2

memory_profiler version == 0.57.0

psutil version == 5.7.0

---

EDIT : Les résultats des profileurs peuvent être analysés à l'aide de la fonction TAMPPA paquet. En l'utilisant, nous pouvons obtenir des tracés souhaités ligne par ligne comme

Answer 2

Nous avons choisi d'utiliser la source d'information habituelle pour cela parce que nous pouvions trouver des fluctuations instantanées de la mémoire libre et que nous avions l'impression d'interroger la source d'information habituelle. meminfo source de données a été utile. Cela nous a également permis d'obtenir quelques paramètres connexes supplémentaires qui ont été pré-parsés.

Code

import os

linux_filepath = "/proc/meminfo"
meminfo = dict(
    (i.split()[0].rstrip(":"), int(i.split()[1]))
    for i in open(linux_filepath).readlines()
)
meminfo["memory_total_gb"] = meminfo["MemTotal"] / (2 ** 20)
meminfo["memory_free_gb"] = meminfo["MemFree"] / (2 ** 20)
meminfo["memory_available_gb"] = meminfo["MemAvailable"] / (2 ** 20)

Sortie pour référence (nous avons supprimé tous les retours à la ligne pour une analyse plus approfondie)

MemTotal : 1014500 kB MemFree : 562680 kB MemAvailable : 646364 kB Tampons : 15144 kB En cache : 210720 kB SwapCached : 0 kB Actif : 261476 kB Inactif : 128888 kB Actif(anon) : 167092 kB Inactif(anon) : 20888 kB Actif(fichier) : 94384 kB Inactif(fichier) : 108000 kB Invalide : 3652 kB Bloqué : 3652 kB SwapTotal : 0 kB SwapFree : 0 kB Dirty : 0 kB Writeback : 0 kB AnonPages : 168160 kB Mapped : 81352 kB Shmem : 21060 kB Slab : 34492 kB SReclaimable : 18044 kB SUnreclaim : 16448 kB KernelStack : 2672 kB PageTables : 8180 kB NFS_Unstable : 0 kB Bounce : 0 kB WritebackTmp : 0 kB CommitLimit : 507248 kB Committed_AS : 1038756 kB VmallocTotal : 34359738367 kB VmallocUsed : 0 kB VmallocChunk : 0 kB HardwareCorrupted : 0 kB AnonHugePages : 88064 kB CmaTotal : 0 kB CmaFree : 0 kB HugePages_Total : 0 HugePages_Free : 0 HugePages_Rsvd : 0 HugePages_Surp : 0 Hugepagesize : 2048 kB DirectMap4k : 43008 kB DirectMap2M : 1005568 kB

Answer 3

J'ai l'impression que ces réponses ont été écrites pour Python 2, et de toute façon personne n'a fait mention de la norme resource qui est disponible pour Python 3. Il fournit des commandes pour obtenir la ressource limites d'un processus donné (le processus Python appelant par défaut). Ce n'est pas la même chose que d'obtenir l'adresse courante du processus Python. utilisation de ressources par le système dans son ensemble, mais il pourrait résoudre certains des mêmes problèmes comme par exemple "Je veux m'assurer que je n'utilise que X de RAM avec ce script".

Answer 4

Cet agrégat contient toutes les bonnes choses : psutil + os pour obtenir la compatibilité Unix et Windows : Cela nous permet d'obtenir :

1. CPU
2. mémoire
3. disque

code :

import os
import psutil  # need: pip install psutil

In [32]: psutil.virtual_memory()
Out[32]: svmem(total=6247907328, available=2502328320, percent=59.9, used=3327135744, free=167067648, active=3671199744, inactive=1662668800,     buffers=844783616, cached=1908920320, shared=123912192, slab=613048320)

In [33]: psutil.virtual_memory().percent
Out[33]: 60.0

In [34]: psutil.cpu_percent()
Out[34]: 5.5

In [35]: os.sep
Out[35]: '/'

In [36]: psutil.disk_usage(os.sep)
Out[36]: sdiskusage(total=50190790656, used=41343860736, free=6467502080, percent=86.5)

In [37]: psutil.disk_usage(os.sep).percent
Out[37]: 86.5

Answer 5

"... l'état actuel du système (CPU actuel, RAM, espace disque libre, etc.)" Et "les plateformes *nix et Windows" peuvent être une combinaison difficile à réaliser.

Les systèmes d'exploitation sont fondamentalement différents dans la manière dont ils gèrent ces ressources. En effet, ils diffèrent dans des concepts fondamentaux comme la définition de ce qui compte comme temps système et ce qui compte comme temps d'application.

"Espace disque libre" ? Qu'est-ce qui compte comme "espace disque" ? Toutes les partitions de tous les périphériques ? Qu'en est-il des partitions étrangères dans un environnement multi-boot ?

Je ne pense pas qu'il y ait un consensus suffisamment clair entre Windows et *nix pour rendre cela possible. En fait, il se peut même qu'il n'y ait pas de consensus entre les différents systèmes d'exploitation appelés Windows. Existe-t-il une API Windows unique qui fonctionne à la fois pour XP et Vista ?