Déterminer la RAM libre en Python

Je voudrais que mon script python pour utiliser toute la RAM disponible, mais pas plus (pour des raisons d'efficacité). Je peux contrôler cela par la lecture en seulement une quantité limitée de données, mais j'ai besoin de savoir combien de RAM est libre au moment de l'exécution pour obtenir ce droit. Il sera exécuté sur une variété de systèmes Linux. Est-il possible de déterminer la libérer de la mémoire vive au moment de l'exécution?

OriginalL'auteur marshall | 2013-07-18

memory-management python

6

Vous pouvez simplement lire /proc/meminfo. Être conscient que le "libérer de la mémoire" est en général assez faible, comme le système d'exploitation largement utilise gratuit, de la mémoire inutilisée pour la mise en cache.

Aussi, il est préférable si vous n'essayez pas d'être plus malin que vos OS de la gestion de la mémoire. Qui habituellement juste se termine dans les larmes (ou plus lent, des programmes). Mieux il suffit de prendre de la RAM dont vous avez besoin. Si vous souhaitez utiliser autant que vous le pouvez sur une machine avec un inconnu auparavant quantité de mémoire, je serais probablement vérifier la quantité de mémoire RAM installée (MemTotal dans /proc/meminfo), laisser une certaine somme pour l'OS et que la marge de sécurité (disons 1 GO) et utiliser le reste.

certains systèmes *nix, sans /proc si 🙁
avec la configuration actuelle des valeurs de est disponible depuis au moins Linux 2.6. Qui devrait être assez longue.
Il existe d'autres systèmes *nix, que Linux, donc pour le but de generalisibility cela mérite d'être mentionné.
L'OP a précisé qu'elle allait être exécuté sur une variété de systèmes Linux.
Vrai. Peut-être que nous pouvons être d'accord sur voir mon commentaire que bizarre curiosa pour le lecteur intéressé, alors? 🙂

OriginalL'auteur Carsten
19

Sur les systèmes Linux, j'utilise de temps en temps:
```
def memory():
    """
    Get node total memory and memory usage
    """
    with open('/proc/meminfo', 'r') as mem:
        ret = {}
        tmp = 0
        for i in mem:
            sline = i.split()
            if str(sline[0]) == 'MemTotal:':
                ret['total'] = int(sline[1])
            elif str(sline[0]) in ('MemFree:', 'Buffers:', 'Cached:'):
                tmp += int(sline[1])
        ret['free'] = tmp
        ret['used'] = int(ret['total']) - int(ret['free'])
    return ret
```
Vous pouvez exécuter lorsque votre script de démarrage. La RAM est généralement utilisée et libéré assez fréquemment sur un système occupé, de sorte que vous devriez prendre cela en compte avant de décider quelle quantité de RAM à utiliser. Aussi, la plupart des systèmes linux ont un swappiness valeur de 60. Lors de l'utilisation de la mémoire, les pages qui sont le moins fréquemment utilisé sera échangé. Vous pouvez trouver vous-même à l'aide de SWAP plutôt que de la mémoire.

Espère que cette aide.

Que fait un swappiness valeur de 60 signifie?
href="http://askubuntu.com/questions/103915/how-do-i-configure-swappiness" title="comment puis-je configurer swappiness">askubuntu.com/questions/103915/how-do-i-configure-swappiness donne un compte rendu juste.
Son la probabilité que le noyau de remplacement de pages. Les valeurs vont de 0 à 100, où 0 est le moins enclin à échanger (généralement cela pour éviter une condition de mémoire) et 100 est agressif échange.

OriginalL'auteur Gabriel Samfira

Depuis l'affiche originale a écrit le code doit s'exécuter sur une variété de Linux système, je suis de poster ici un Objet orienté solution pour Linux Mémoire de requête. psutil est une grande bibliothèque, mais si vous ne pouvez pas l'installer, pour une raison quelconque, vous pouvez simplement utiliser la solution suivante:

Exemple d'utilisation:

>>> f = FreeMemLinux()
>>> print f.total, f.used,  f.user_free
8029212 3765960 4464816
>>>
>>> f_mb = FreeMemLinux(unit='MB')
>>> print f_mb.total, f_mb.used,  f_mb.user_free
7841.02734375 3677.6953125 4360.171875
>>>
>>> f_percent = FreeMemLinux(unit='%')
>>> print f_percent.total, f_percent.used, f_percent.user_free
100.0 46.9032328453 55.60715049

Code:

class FreeMemLinux(object):
"""
Non-cross platform way to get free memory on Linux. Note that this code
uses the `with ... as`, which is conditionally Python 2.5 compatible!
If for some reason you still have Python 2.5 on your system add in the
head of your code, before all imports:
from __future__ import with_statement
"""
def __init__(self, unit='kB'):
with open('/proc/meminfo', 'r') as mem:
lines = mem.readlines()
self._tot = int(lines[0].split()[1])
self._free = int(lines[1].split()[1])
self._buff = int(lines[2].split()[1])
self._cached = int(lines[3].split()[1])
self._shared = int(lines[20].split()[1])
self._swapt = int(lines[14].split()[1])
self._swapf = int(lines[15].split()[1])
self._swapu = self._swapt - self._swapf
self.unit = unit
self._convert = self._factor()
def _factor(self):
"""determine the convertion factor"""
if self.unit == 'kB':
return 1
if self.unit == 'k':
return 1024.0
if self.unit == 'MB':
return 1/1024.0
if self.unit == 'GB':
return 1/1024.0/1024.0
if self.unit == '%':
return 1.0/self._tot
else:
raise Exception("Unit not understood")
@property
def total(self):
return self._convert * self._tot
@property
def used(self):
return self._convert * (self._tot - self._free)
@property
def used_real(self):
"""memory used which is not cache or buffers"""
return self._convert * (self._tot - self._free -
self._buff - self._cached)
@property
def shared(self):
return self._convert * (self._tot - self._free)
@property
def buffers(self):
return self._convert * (self._buff)
@property
def cached(self):
return self._convert * self._cached
@property
def user_free(self):
"""This is the free memory available for the user"""
return self._convert *(self._free + self._buff + self._cached)
@property
def swap(self):
return self._convert * self._swapt
@property
def swap_free(self):
return self._convert * self._swapf
@property
def swap_used(self):
return self._convert * self._swapu

OriginalL'auteur Oz123

1

Une autre option est de l'intégré dans le paquet Python psutil:
```
stats = psutil.virtual_memory()  # returns a named tuple
available = getattr(stats, 'available')
print(available)
```
Selon la la documentation, le available champ "est calculée en additionnant les différentes valeurs de la mémoire en fonction de la plate-forme et il est censé être utilisé pour surveiller l'utilisation réelle de la mémoire dans un de la croix-plate-forme de la mode."

Note la valeur de retour sera en octets

OriginalL'auteur Addison Klinke
0

Je suppose que vous pourriez utiliser gratuit (http://www.cyberciti.biz/faq/linux-check-memory-usage/), ps ou peut-être la MemoryMonitor classe à partir de la soi-fil placé tout en bas de ma réponse pour ce faire. Juste couper un peu de mou et de laisser une petite quantité de ram inutilisée pour d'autres processus, en cas de besoin urgent de yo éviter les écritures sur le disque en leur nom.

Vous aurez besoin d'analyser les données en sortie gratuit ou ps si vous l'utiliser, mais qui ne devrait pas être dur. Rappelez-vous que vous avez besoin pour analyser la quantité de ram disponible en temps réel, de sorte que vous pouvez ajuster si un autre processus est la mémoire de la faim pour une certaine raison.

aussi, voir ce fil:
Comment obtenir de l'UC et de l'utilisation de la RAM en Python?

OriginalL'auteur nic

Vous devez vous connecter pour publier un commentaire.