Index: third_party/psutil/psutil/__init__.py |
diff --git a/third_party/psutil/psutil/__init__.py b/third_party/psutil/psutil/__init__.py |
index 09b7955f2434f32c32392723231e42ec95d188b4..93724fca1a97788acf6dcba48a57d255d329f8cd 100644 |
--- a/third_party/psutil/psutil/__init__.py |
+++ b/third_party/psutil/psutil/__init__.py |
@@ -1,26 +1,35 @@ |
#!/usr/bin/env python |
# |
-# $Id: __init__.py 806 2010-11-12 23:09:35Z g.rodola $ |
+# $Id: __init__.py 1142 2011-10-05 18:45:49Z g.rodola $ |
# |
+# Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved. |
+# Use of this source code is governed by a BSD-style license that can be |
+# found in the LICENSE file. |
"""psutil is a module providing convenience functions for managing |
-processes in a portable way by using Python. |
+processes and gather system information in a portable way by using |
+Python. |
""" |
-__version__ = "0.2.0" |
+__version__ = "0.3.1" |
version_info = tuple([int(num) for num in __version__.split('.')]) |
__all__ = [ |
# exceptions |
- "Error", "NoSuchProcess", "AccessDenied", |
+ "Error", "NoSuchProcess", "AccessDenied", "TimeoutExpired", |
# constants |
- "NUM_CPUS", "TOTAL_PHYMEM", "version_info", "__version__", |
+ "NUM_CPUS", "TOTAL_PHYMEM", "BOOT_TIME", |
+ "version_info", "__version__", |
+ "STATUS_RUNNING", "STATUS_IDLE", "STATUS_SLEEPING", "STATUS_DISK_SLEEP", |
+ "STATUS_STOPPED", "STATUS_TRACING_STOP", "STATUS_ZOMBIE", "STATUS_DEAD", |
+ "STATUS_WAKING", "STATUS_LOCKED", |
# classes |
- "Process", |
+ "Process", "Popen", |
# functions |
"test", "pid_exists", "get_pid_list", "process_iter", "get_process_list", |
- "avail_phymem", "used_phymem", "total_virtmem", "avail_virtmem", |
- "used_virtmem", "cpu_times", "cpu_percent", |
+ "phymem_usage", "virtmem_usage" |
+ "cpu_times", "per_cpu_times", "cpu_percent", "per_cpu_percent", |
+ "network_io_counters", "disk_io_counters", |
] |
import sys |
@@ -29,67 +38,58 @@ import time |
import signal |
import warnings |
import errno |
+import subprocess |
try: |
import pwd |
except ImportError: |
pwd = None |
-from psutil.error import Error, NoSuchProcess, AccessDenied |
+from psutil.error import Error, NoSuchProcess, AccessDenied, TimeoutExpired |
+from psutil._compat import property |
+from psutil._common import (STATUS_RUNNING, STATUS_IDLE, STATUS_SLEEPING, |
+ STATUS_DISK_SLEEP, STATUS_STOPPED, |
+ STATUS_TRACING_STOP, STATUS_ZOMBIE, STATUS_DEAD, |
+ STATUS_WAKING, STATUS_LOCKED |
+ ) |
# import the appropriate module for our platform only |
if sys.platform.lower().startswith("linux"): |
- from psutil._pslinux import * |
- __all__.extend(["cached_phymem", "phymem_buffers"]) |
+ import psutil._pslinux as _psplatform |
+ from psutil._pslinux import (phymem_buffers, |
+ cached_phymem, |
+ IOPRIO_CLASS_NONE, |
+ IOPRIO_CLASS_RT, |
+ IOPRIO_CLASS_BE, |
+ IOPRIO_CLASS_IDLE) |
+ phymem_buffers = _psplatform.phymem_buffers |
+ cached_phymem = _psplatform.cached_phymem |
elif sys.platform.lower().startswith("win32"): |
- from psutil._psmswindows import * |
+ import psutil._psmswindows as _psplatform |
+ from psutil._psmswindows import (ABOVE_NORMAL_PRIORITY_CLASS, |
+ BELOW_NORMAL_PRIORITY_CLASS, |
+ HIGH_PRIORITY_CLASS, |
+ IDLE_PRIORITY_CLASS, |
+ NORMAL_PRIORITY_CLASS, |
+ REALTIME_PRIORITY_CLASS) |
elif sys.platform.lower().startswith("darwin"): |
- from psutil._psosx import * |
+ import psutil._psosx as _psplatform |
elif sys.platform.lower().startswith("freebsd"): |
- from psutil._psbsd import * |
+ import psutil._psbsd as _psplatform |
else: |
raise NotImplementedError('platform %s is not supported' % sys.platform) |
+__all__.extend(_psplatform.__extra__all__) |
-class CPUTimes: |
- """This class contains information about CPU times. |
- It is not used directly but it's returned as an instance by |
- psutil.cpu_times() function. |
+NUM_CPUS = _psplatform.NUM_CPUS |
+BOOT_TIME = _psplatform.BOOT_TIME |
+TOTAL_PHYMEM = _psplatform.phymem_usage()[0] |
- Every CPU time is accessible in form of an attribute and represents |
- the time CPU has spent in the given mode. |
- |
- The attributes availability varies depending on the platform. |
- Here follows a list of all available attributes: |
- |
- - user |
- - system |
- - idle |
- - nice (UNIX) |
- - iowait (Linux) |
- - irq (Linux, FreeBSD) |
- - softirq (Linux) |
- """ |
- |
- def __init__(self, **kwargs): |
- self.__attrs = [] |
- for name in kwargs: |
- setattr(self, name, kwargs[name]) |
- self.__attrs.append(name) |
- |
- def __str__(self): |
- string = [] |
- for attr in self.__attrs: |
- value = getattr(self, attr) |
- string.append("%s=%s" %(attr, value)) |
- return '; '.join(string) |
- |
- def __iter__(self): |
- for attr in self.__attrs: |
- yield getattr(self, attr) |
+get_pid_list = _psplatform.get_pid_list |
+pid_exists = _psplatform.pid_exists |
class Process(object): |
@@ -98,15 +98,16 @@ class Process(object): |
def __init__(self, pid): |
"""Create a new Process object, raises NoSuchProcess if the PID |
does not exist, and ValueError if the parameter is not an |
- integer PID.""" |
+ integer PID. |
+ """ |
if not isinstance(pid, int): |
- raise ValueError("An integer is required") |
+ raise ValueError("an integer is required") |
if not pid_exists(pid): |
- raise NoSuchProcess(pid, None, "no process found with PID %s" % pid) |
+ raise NoSuchProcess(pid, None, "no process found with pid %s" % pid) |
self._pid = pid |
- # platform-specific modules define an PlatformProcess |
+ # platform-specific modules define an _psplatform.Process |
# implementation class |
- self._platform_impl = PlatformProcess(pid) |
+ self._platform_impl = _psplatform.Process(pid) |
self._last_sys_cpu_times = None |
self._last_proc_cpu_times = None |
@@ -114,30 +115,18 @@ class Process(object): |
try: |
pid = self.pid |
name = repr(self.name) |
- cmdline = self.cmdline and repr(' '.join(self.cmdline)) |
except NoSuchProcess: |
details = "(pid=%s (terminated))" % self.pid |
except AccessDenied: |
details = "(pid=%s)" % (self.pid) |
else: |
- if cmdline: |
- details = "(pid=%s, name=%s, cmdline=%s)" % (pid, name, cmdline) |
- else: |
- details = "(pid=%s, name=%s)" % (pid, name) |
- return "%s.%s %s" % (self.__class__.__module__, |
- self.__class__.__name__, details) |
+ details = "(pid=%s, name=%s)" % (pid, name) |
+ return "%s.%s%s" % (self.__class__.__module__, |
+ self.__class__.__name__, details) |
def __repr__(self): |
return "<%s at %s>" % (self.__str__(), id(self)) |
- def __eq__(self, other): |
- """Test for equality with another Process object based on pid |
- and creation time. |
- """ |
- h1 = (self.pid, self.create_time) |
- h2 = (other.pid, other.create_time) |
- return h1 == h2 |
- |
@property |
def pid(self): |
"""The process pid.""" |
@@ -150,11 +139,15 @@ class Process(object): |
@property |
def parent(self): |
- """Return the parent process as a Process object. If no ppid is |
- known then return None.""" |
- if self.ppid is not None: |
- return Process(self.ppid) |
- return None |
+ """Return the parent process as a Process object. If no parent |
+ pid is known return None. |
+ """ |
+ ppid = self.ppid |
+ if ppid is not None: |
+ try: |
+ return Process(ppid) |
+ except NoSuchProcess: |
+ pass |
@property |
def name(self): |
@@ -185,37 +178,63 @@ class Process(object): |
_exe = os.path.realpath(cmdline[0]) |
if os.path.isfile(_exe) and os.access(_exe, os.X_OK): |
return _exe |
+ if not exe: |
+ raise AccessDenied(self.pid, self._platform_impl._process_name) |
return exe |
@property |
- def path(self): |
- msg = "'path' property is deprecated; use 'os.path.dirname(exe)' instead" |
- warnings.warn(msg, DeprecationWarning) |
- return os.path.dirname(self.exe) |
- |
- @property |
def cmdline(self): |
"""The command line process has been called with.""" |
return self._platform_impl.get_process_cmdline() |
@property |
- def uid(self): |
- """The real user id of the current process.""" |
- return self._platform_impl.get_process_uid() |
+ def status(self): |
+ """The process current status as a STATUS_* constant.""" |
+ return self._platform_impl.get_process_status() |
@property |
- def gid(self): |
- """The real group id of the current process.""" |
- return self._platform_impl.get_process_gid() |
+ def nice(self): |
+ """Get or set process niceness (priority).""" |
+ return self._platform_impl.get_process_nice() |
+ |
+ @nice.setter |
+ def nice(self, value): |
+ # invoked on "p.nice = num"; change process niceness |
+ return self._platform_impl.set_process_nice(value) |
+ |
+ if os.name == 'posix': |
+ |
+ @property |
+ def uids(self): |
+ """Return a named tuple denoting the process real, |
+ effective, and saved user ids. |
+ """ |
+ return self._platform_impl.get_process_uids() |
+ |
+ @property |
+ def gids(self): |
+ """Return a named tuple denoting the process real, |
+ effective, and saved group ids. |
+ """ |
+ return self._platform_impl.get_process_gids() |
+ |
+ @property |
+ def terminal(self): |
+ """The terminal associated with this process, if any, |
+ else None. |
+ """ |
+ return self._platform_impl.get_process_terminal() |
@property |
def username(self): |
- """The name of the user that owns the process.""" |
+ """The name of the user that owns the process. |
+ On UNIX this is calculated by using *real* process uid. |
+ """ |
if os.name == 'posix': |
if pwd is None: |
- # might happen on compiled-from-sources python |
+ # might happen if python was installed from sources |
raise ImportError("requires pwd module shipped with standard python") |
- return pwd.getpwuid(self.uid).pw_name |
+ return pwd.getpwuid(self.uids.real).pw_name |
else: |
return self._platform_impl.get_process_username() |
@@ -227,17 +246,49 @@ class Process(object): |
return self._platform_impl.get_process_create_time() |
# available for Windows and Linux only |
- if hasattr(PlatformProcess, "get_process_cwd"): |
+ if hasattr(_psplatform.Process, "get_process_cwd"): |
+ |
def getcwd(self): |
"""Return a string representing the process current working |
directory. |
""" |
return self._platform_impl.get_process_cwd() |
+ # Linux, BSD and Windows only |
+ if hasattr(_psplatform.Process, "get_process_io_counters"): |
+ |
+ def get_io_counters(self): |
+ """Return process I/O statistics as a namedtuple including |
+ the number of read/write calls performed and the amount of |
+ bytes read and written by the process. |
+ """ |
+ return self._platform_impl.get_process_io_counters() |
+ |
+ # available only on Linux |
+ if hasattr(_psplatform.Process, "get_process_ionice"): |
+ |
+ def get_ionice(self): |
+ """Return process I/O niceness (priority) as a namedtuple.""" |
+ return self._platform_impl.get_process_ionice() |
+ |
+ def set_ionice(self, ioclass, value=None): |
+ """Set process I/O niceness (priority). |
+ ioclass is one of the IOPRIO_CLASS_* constants. |
+ iodata is a number which goes from 0 to 7. The higher the |
+ value, the lower the I/O priority of the process. |
+ """ |
+ return self._platform_impl.set_process_ionice(ioclass, value) |
+ |
def get_num_threads(self): |
"""Return the number of threads used by this process.""" |
return self._platform_impl.get_process_num_threads() |
+ def get_threads(self): |
+ """Return threads opened by process as a list of namedtuples |
+ including thread id and thread CPU times (user/system). |
+ """ |
+ return self._platform_impl.get_process_threads() |
+ |
def get_children(self): |
"""Return the children of this process as a list of Process |
objects. |
@@ -304,8 +355,7 @@ class Process(object): |
def get_cpu_times(self): |
"""Return a tuple whose values are process CPU user and system |
- time. These are the same first two values that os.times() |
- returns for the current process. |
+ times. The same as os.times() but per-process. |
""" |
return self._platform_impl.get_cpu_times() |
@@ -332,27 +382,34 @@ class Process(object): |
def get_open_files(self): |
"""Return files opened by process as a list of namedtuples |
- including absolute file name and file descriptor. |
+ including absolute file name and file descriptor number. |
""" |
return self._platform_impl.get_open_files() |
def get_connections(self): |
"""Return TCP and UPD connections opened by process as a list |
- of namedtuple/s. |
- For third party processes (!= os.getpid()) results can differ |
- depending on user privileges. |
+ of namedtuples. |
+ On BSD and OSX results for third party processes (!= os.getpid()) |
+ can differ depending on user privileges. |
""" |
return self._platform_impl.get_connections() |
def is_running(self): |
- """Return whether the current process is running in the current |
- process list. |
- """ |
+ """Return whether this process is running.""" |
try: |
- newproc = Process(self.pid) |
- return self == newproc |
+ # Test for equality with another Process object based |
+ # on pid and creation time. |
+ # This pair is supposed to indentify a Process instance |
+ # univocally over the time (the PID alone is not enough as |
+ # it might refer to a process which is gone in meantime |
+ # and its PID reused by another process). |
+ new_self = Process(self.pid) |
+ p1 = (self.pid, self.create_time) |
+ p2 = (new_self.pid, new_self.create_time) |
except NoSuchProcess: |
return False |
+ else: |
+ return p1 == p2 |
def send_signal(self, sig): |
"""Send a signal to process (see signal module constants). |
@@ -426,14 +483,66 @@ class Process(object): |
else: |
self._platform_impl.kill_process() |
+ def wait(self, timeout=None): |
+ """Wait for process to terminate and, if process is a children |
+ of the current one also return its exit code, else None. |
+ """ |
+ if timeout is not None and not timeout >= 0: |
+ raise ValueError("timeout must be a positive integer") |
+ return self._platform_impl.process_wait(timeout) |
+ |
+ |
+class Popen(Process): |
+ """A more convenient interface to stdlib subprocess module. |
+ It starts a sub process and deals with it exactly as when using |
+ subprocess.Popen class but in addition also provides all the |
+ property and methods of psutil.Process class in a unique interface: |
+ |
+ >>> import psutil |
+ >>> from subprocess import PIPE |
+ >>> p = psutil.Popen(["/usr/bin/python", "-c", "print 'hi'"], stdout=PIPE) |
+ >>> p.name |
+ 'python' |
+ >>> p.uids |
+ user(real=1000, effective=1000, saved=1000) |
+ >>> p.username |
+ 'giampaolo' |
+ >>> p.communicate() |
+ ('hi\n', None) |
+ >>> p.terminate() |
+ >>> p.wait(timeout=2) |
+ 0 |
+ >>> |
+ |
+ For method names common to both classes such as kill(), terminate() |
+ and wait(), psutil.Process implementation takes precedence. |
+ |
+ For a complete documentation refers to: |
+ http://docs.python.org/library/subprocess.html |
+ """ |
+ |
+ def __init__(self, *args, **kwargs): |
+ self.__subproc = subprocess.Popen(*args, **kwargs) |
+ Process.__init__(self, self.__subproc.pid) |
+ |
+ def __dir__(self): |
+ return list(set(dir(Popen) + dir(subprocess.Popen))) |
+ |
+ def __getattribute__(self, name): |
+ try: |
+ return object.__getattribute__(self, name) |
+ except AttributeError: |
+ try: |
+ return object.__getattribute__(self.__subproc, name) |
+ except AttributeError: |
+ raise AttributeError("%s instance has no attribute '%s'" |
+ %(self.__class__.__name__, name)) |
def process_iter(): |
"""Return an iterator yielding a Process class instances for all |
running processes on the local machine. |
""" |
pids = get_pid_list() |
- # for each PID, create a proxyied Process object |
- # it will lazy init it's name and path later if required |
for pid in pids: |
try: |
yield Process(pid) |
@@ -446,15 +555,34 @@ def get_process_list(): |
""" |
return list(process_iter()) |
-def cpu_times(): |
- """Return system CPU times as a CPUTimes object.""" |
- values = get_system_cpu_times() |
- return CPUTimes(**values) |
+def cpu_times(percpu=False): |
+ """Return system-wide CPU times as a namedtuple object. |
+ Every CPU time represents the time CPU has spent in the given mode. |
+ The attributes availability varies depending on the platform. |
+ Here follows a list of all available attributes: |
+ - user |
+ - system |
+ - idle |
+ - nice (UNIX) |
+ - iowait (Linux) |
+ - irq (Linux, FreeBSD) |
+ - softirq (Linux) |
+ |
+ When percpu is True return a list of nameduples for each CPU. |
+ First element of the list refers to first CPU, second element |
+ to second CPU and so on. |
+ The order of the list is consistent across calls. |
+ """ |
+ if not percpu: |
+ return _psplatform.get_system_cpu_times() |
+ else: |
+ return _psplatform.get_system_per_cpu_times() |
_last_cpu_times = cpu_times() |
+_last_per_cpu_times = cpu_times(percpu=True) |
-def cpu_percent(interval=0.1): |
+def cpu_percent(interval=0.1, percpu=False): |
"""Return a float representing the current system-wide CPU |
utilization as a percentage. |
@@ -465,33 +593,184 @@ def cpu_percent(interval=0.1): |
since last call or module import, returning immediately. |
In this case is recommended for accuracy that this function be |
called with at least 0.1 seconds between calls. |
+ |
+ When percpu is True returns a list of floats representing the |
+ utilization as a percentage for each CPU. |
+ First element of the list refers to first CPU, second element |
+ to second CPU and so on. |
+ The order of the list is consistent across calls. |
""" |
global _last_cpu_times |
- |
+ global _last_per_cpu_times |
blocking = interval is not None and interval > 0.0 |
- if blocking: |
- t1 = cpu_times() |
- time.sleep(interval) |
+ |
+ def calculate(t1, t2): |
+ t1_all = sum(t1) |
+ t1_busy = t1_all - t1.idle |
+ |
+ t2_all = sum(t2) |
+ t2_busy = t2_all - t2.idle |
+ |
+ # this usually indicates a float precision issue |
+ if t2_busy <= t1_busy: |
+ return 0.0 |
+ |
+ busy_delta = t2_busy - t1_busy |
+ all_delta = t2_all - t1_all |
+ busy_perc = (busy_delta / all_delta) * 100 |
+ return round(busy_perc, 1) |
+ |
+ # system-wide usage |
+ if not percpu: |
+ if blocking: |
+ t1 = cpu_times() |
+ time.sleep(interval) |
+ else: |
+ t1 = _last_cpu_times |
+ _last_cpu_times = cpu_times() |
+ return calculate(t1, _last_cpu_times) |
+ # per-cpu usage |
else: |
- t1 = _last_cpu_times |
+ ret = [] |
+ if blocking: |
+ tot1 = cpu_times(percpu=True) |
+ time.sleep(interval) |
+ else: |
+ tot1 = _last_per_cpu_times |
+ _last_per_cpu_times = cpu_times(percpu=True) |
+ for t1, t2 in zip(tot1, _last_per_cpu_times): |
+ ret.append(calculate(t1, t2)) |
+ return ret |
+ |
+def phymem_usage(): |
+ """Return the amount of total, used and free physical memory |
+ on the system in bytes plus the percentage usage. |
+ """ |
+ return _psplatform.phymem_usage() |
+ |
+def virtmem_usage(): |
+ """Return the amount of total, used and free virtual memory |
+ on the system in bytes plus the percentage usage. |
+ |
+ On Linux they match the values returned by free command line utility. |
+ On OS X and FreeBSD they represent the same values as returned by |
+ sysctl vm.vmtotal. On Windows they are determined by reading the |
+ PageFile values of MEMORYSTATUSEX structure. |
+ """ |
+ return _psplatform.virtmem_usage() |
- t1_all = sum(t1) |
- t1_busy = t1_all - t1.idle |
+def disk_usage(path): |
+ """Return disk usage statistics about the given path as a namedtuple |
+ including total, used and free space expressed in bytes plus the |
+ percentage usage. |
+ """ |
+ return _psplatform.get_disk_usage(path) |
- t2 = cpu_times() |
- t2_all = sum(t2) |
- t2_busy = t2_all - t2.idle |
+def disk_partitions(all=False): |
+ """Return mounted partitions as a list of namedtuples including |
+ device, mount point and filesystem type. |
- _last_cpu_times = t1 |
- # this usually indicates a float precision issue |
- if t2_busy <= t1_busy: |
- return 0.0 |
+ If "all" parameter is False return physical devices only and ignore |
+ all others. |
+ """ |
+ return _psplatform.disk_partitions(all) |
- busy_delta = t2_busy - t1_busy |
- all_delta = t2_all - t1_all |
- busy_perc = (busy_delta / all_delta) * 100 |
- return round(busy_perc, 1) |
+if hasattr(_psplatform, "network_io_counters"): |
+ def network_io_counters(pernic=False): |
+ """Return network I/O statistics as a namedtuple including: |
+ - number of bytes sent |
+ - number of bytes received |
+ - number of packets sent |
+ - number of packets received |
+ |
+ If pernic is True return the same information for every |
+ network interface installed on the system as a dictionary |
+ with network interface names as the keys and the namedtuple |
+ described above as the values. |
+ """ |
+ from psutil._common import ntuple_net_iostat |
+ rawdict = _psplatform.network_io_counters() |
+ if pernic: |
+ for nic, fields in rawdict.iteritems(): |
+ rawdict[nic] = ntuple_net_iostat(*fields) |
+ return rawdict |
+ else: |
+ bytes_sent, bytes_recv, packets_sent, packets_recv = 0, 0, 0, 0 |
+ for _, fields in rawdict.iteritems(): |
+ bytes_sent += fields[0] |
+ bytes_recv += fields[1] |
+ packets_sent += fields[2] |
+ packets_recv += fields[3] |
+ return ntuple_net_iostat(bytes_sent, bytes_recv, |
+ packets_sent, packets_recv) |
+ |
+if hasattr(_psplatform, "disk_io_counters"): |
+ |
+ def disk_io_counters(perdisk=False): |
+ """Return system disk I/O statistics as a namedtuple including: |
+ - number of bytes read |
+ - number of bytes written |
+ - number of reads |
+ - number of writes |
+ - time spent reading from disk (in nanoseconds) |
+ - time spent writing to disk (in nanoseconds) |
+ |
+ If perdisk is True return the same information for every |
+ physical disk installed on the system as a dictionary |
+ with partition names as the keys and the namedutuple |
+ described above as the values. |
+ """ |
+ from psutil._common import ntuple_disk_iostat |
+ rawdict = _psplatform.disk_io_counters() |
+ if perdisk: |
+ for disk, fields in rawdict.iteritems(): |
+ rawdict[disk] = ntuple_disk_iostat(*fields) |
+ return rawdict |
+ else: |
+ reads, writes, rbytes, wbytes, rtime, wtime = 0, 0, 0, 0, 0, 0 |
+ for _, fields in rawdict.iteritems(): |
+ reads += fields[0] |
+ writes += fields[1] |
+ rbytes += fields[2] |
+ wbytes += fields[3] |
+ rtime += fields[4] |
+ wtime += fields[5] |
+ return ntuple_disk_iostat(reads, writes, rbytes, wbytes, rtime, wtime) |
+ |
+ |
+def _deprecated(replacement): |
+ # a decorator which can be used to mark functions as deprecated |
+ def outer(fun): |
+ def inner(*args, **kwargs): |
+ msg = "psutil.%s is deprecated; use %s instead" \ |
+ % (fun.__name__, replacement) |
+ warnings.warn(msg, category=DeprecationWarning, stacklevel=2) |
+ return fun(*args, **kwargs) |
+ return inner |
+ return outer |
+ |
+# --- deprecated functions |
+ |
+@_deprecated("psutil.phymem_usage") |
+def avail_phymem(): |
+ return phymem_usage().free |
+ |
+@_deprecated("psutil.phymem_usage") |
+def used_phymem(): |
+ return phymem_usage().used |
+ |
+@_deprecated("psutil.virtmem_usage") |
+def total_virtmem(): |
+ return virtmem_usage().total |
+ |
+@_deprecated("psutil.virtmem_usage") |
+def used_virtmem(): |
+ return virtmem_usage().used |
+ |
+@_deprecated("psutil.virtmem_usage") |
+def avail_virtmem(): |
+ return virtmem_usage().free |
def test(): |
"""List info of all currently running processes emulating a |