Python Process.memory_info方法代码示例

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
   def trace_memory_usage(self, frame, event, arg):
      """Callback for sys.settrace

      Args:
         frame: frame is the current stack frame
         event: event is a string: 'call', 'line', 'return', 'exception', 'c_call', 'c_return', or 'c_exception'
         arg: arg depends on the event type.

      Returns:
         function: wrap_func
      """
      if event in ('call', 'line', 'return') and frame.f_code in self.code_map:
         if event != 'call':
            # "call" event just saves the lineno but not the memory
            process = Process(getpid())
            mem = process.memory_info()[0] / float(2 ** 20)
            # if there is already a measurement for that line get the max
            old_mem = self.code_map[frame.f_code].get(self.prevline, 0)
            self.code_map[frame.f_code][self.prevline] = max(mem, old_mem)
         self.prevline = frame.f_lineno

      if self._original_trace_function is not None:
         self._original_trace_function(frame, event, arg)

      return self.trace_memory_usage

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
 def __memory_watcher(self, data):
     max_memory = 0
     try:
         p = Process(data[0])
         memory = 1
         while 0 < memory and max_memory <= self.__mem_lim:
             if os_name.lower() == 'linux':
                 memory = p.memory_info()[0] - p.memory_info_ex().shared
             elif os_name.lower() == 'darwin':
                 memory = p.memory_info()[0]
             elif os_name.lower() == 'windows':
                 memory = p.memory_info_ex().private
             if max_memory < memory:
                 max_memory = memory
         data[1]()
     except NoSuchProcess:
         pass
     finally:
         data.append(max_memory)

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
def process_with_stats(name, stdin, times=1):
    if times > 1:
        results = []
        for _ in xrange(0, times):
            results.append(process_with_stats(name, stdin, 1))

        result = {'execution': reduce(lambda a, c:
                                      a+c['execution']/float(times),
                                      results, 0),
                  'memory': reduce(lambda a, c:
                                   max(a, c['memory']), results, 0),
                  'output': results[0]['output'],
                  'status': results[0]['status']}

        return result

    process = Popen(name, stdin=PIPE, stdout=PIPE, stderr=DEVNULL,
                    close_fds=True)
    process.stdin.write(stdin.getvalue())
    process.stdin.close()

    stats = Process(process.pid)

    memory_usage = stats.memory_info().rss
    while process.poll() is None:
        try:
            memory_usage = max(memory_usage, stats.memory_info().rss)
        except:
            memory_usage = 0
        sleep(1/1000.0)

    execution_time = time() - stats.create_time()
    output = process.stdout.read()

    if memory_usage == 0 and process.returncode == 0:
        return process_with_stats(name, stdin)

    return {'execution': execution_time,
            'memory': memory_usage,
            'output': output,
            'status': process.returncode}

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
def get_memory(pid):
    # return the memory usage in MB, psutil should be 4.0 version
    from psutil import Process, __version__

    # if __version__ < '4.0.0':
    #     raise Exception('psutil module should be 4.0.0 version at least.')

    if pid_exists(pid):
        process = Process(pid)
        # mem = process.memory_full_info().uss / float(1024*1024)
        mem = process.memory_info().rss / float(1024*1024)
        return mem
    return 0

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
    def memory_usage(self):
        self._ensure_initialized()

        usage = 0
        agents = []

        for name, container in self._map_container_by_name().iteritems():
            info = self._docker.inspect_container(container)
            pid = info['State']['Pid']
            process = Process(pid)
            mem = process.memory_info()
            usage = usage + mem.rss
            agents.append({'name': name, 'memory_usage': mem.rss})

        avg = usage / len(agents) if len(agents) > 0 else 0

        return {'total_usage': usage, 'average_usage': avg, 'agents': agents}

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
def memory_usage():
    "Return the memory usage of this process in MB."
    p = Process(getpid())
    return p.memory_info()[0] / 2**20

# 需要导入模块: from psutil import Process [as 别名]
# 或者: from psutil.Process import memory_info [as 别名]
 def memory_usage(self):
     p = Process(self._process.pid)
     mem = p.memory_info()
     return mem.rss