def __exit__(self, e_type, e_value, e_trace):
print '%s\tself_postmaxrss_mb\t%0.1f' % (self.note, resource.getrusage(resource.RUSAGE_SELF)[2]/1e3)
print '%s\tchildren_postmaxrss_mb\t%0.1f' % (self.note, resource.getrusage(resource.RUSAGE_CHILDREN)[2]/1e3)
print '%s\telapsed_sec\t%d' % (self.note, time.time() - self.start)
sys.stdout.flush()
python类getrusage()的实例源码
def _get_time_times(timer=os.times):
t = timer()
return t[0] + t[1]
# Using getrusage(3) is better than clock(3) if available:
# on some systems (e.g. FreeBSD), getrusage has a higher resolution
# Furthermore, on a POSIX system, returns microseconds, which
# wrap around after 36min.
def read_cpu_time():
rusage = resource.getrusage(resource.RUSAGE_SELF)
return int((rusage.ru_utime + rusage.ru_stime) * 1e9) # nanoseconds
def read_max_rss():
rusage = resource.getrusage(resource.RUSAGE_SELF)
if runtime_info.OS_DARWIN:
return int(rusage.ru_maxrss / 1000) # KB
else:
return rusage.ru_maxrss # KB
def getrusage(who=0):
return [0.0, 0.0] # on non-UNIX platforms cpu_time always 0.0
def profiler(frame, event, arg):
if event not in ('call','return'): return profiler
#### gather stats ####
rusage = getrusage(RUSAGE_SELF)
t_cpu = rusage[0] + rusage[1] # user time + system time
code = frame.f_code
fun = (code.co_name, code.co_filename, code.co_firstlineno)
#### get stack with functions entry stats ####
ct = threading.currentThread()
try:
p_stack = ct.p_stack
except AttributeError:
ct.p_stack = deque()
p_stack = ct.p_stack
#### handle call and return ####
if event == 'call':
p_stack.append((time(), t_cpu, fun))
elif event == 'return':
try:
t,t_cpu_prev,f = p_stack.pop()
assert f == fun
except IndexError: # TODO investigate
t,t_cpu_prev,f = p_start_time, 0.0, None
call_cnt, t_sum, t_cpu_sum = p_stats.get(fun, (0, 0.0, 0.0))
p_stats[fun] = (call_cnt+1, t_sum+time()-t, t_cpu_sum+t_cpu-t_cpu_prev)
return profiler
def show_memory_use():
rusage_denom = 1024.
if sys.platform == 'darwin':
rusage_denom = rusage_denom * rusage_denom
ru = resource.getrusage(resource.RUSAGE_SELF)
total_memory = 1. * (ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss) / rusage_denom
strinfo = "\x1b[33m [Memory] Total Memory Use: %.4f MB \t Resident: %ld Shared: %ld UnshareData: %ld UnshareStack: %ld \x1b[0m" % \
(total_memory, ru.ru_maxrss, ru.ru_ixrss, ru.ru_idrss, ru.ru_isrss)
return strinfo
def show_memory_use():
rusage_denom = 1024.
if sys.platform == 'darwin':
rusage_denom = rusage_denom * rusage_denom
ru = resource.getrusage(resource.RUSAGE_SELF)
total_memory = 1. * (ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss) / rusage_denom
strinfo = "\x1b[33m [Memory] Total Memory Use: %.4f MB \t Resident: %ld Shared: %ld UnshareData: %ld UnshareStack: %ld \x1b[0m" % \
(total_memory, ru.ru_maxrss, ru.ru_ixrss, ru.ru_idrss, ru.ru_isrss)
return strinfo
def _get_time_times(timer=os.times):
t = timer()
return t[0] + t[1]
# Using getrusage(3) is better than clock(3) if available:
# on some systems (e.g. FreeBSD), getrusage has a higher resolution
# Furthermore, on a POSIX system, returns microseconds, which
# wrap around after 36min.
def get_daemon_statistics(self):
usage = resource.getrusage(resource.RUSAGE_SELF)
return {"type": "daemon-statistics",
"memory-used": getattr(usage, "ru_maxrss")}
def test_dumps_usage(self):
'''
repeatedly serialize, check that usage doesn't go up
'''
if cdumps is None:
logger.warn('no C dumps(), skipping test_dumps_usage')
return
start_usage = resource.getrusage(resource.RUSAGE_SELF)
usage_history = [start_usage]
for o in _range(_TEST_OUTER):
for i in _range(_TEST_COUNT):
ob = _randob()
blob = cdumps(ob)
# and silently drop the result. I hope the garbage collector works!
t_usage = resource.getrusage(resource.RUSAGE_SELF)
usage_history.append(t_usage)
end_usage = usage_history[-1]
dmaxrss = end_usage.ru_maxrss - start_usage.ru_maxrss
didrss = end_usage.ru_idrss - start_usage.ru_idrss
dmaxrsspct = ((end_usage.ru_maxrss != 0) and (dmaxrss / end_usage.ru_maxrss)) or 0
didrsspct = ((end_usage.ru_idrss != 0) and (didrss / end_usage.ru_idrss)) or 0
sys.stderr.write('maxrss: {} - {}, d={} ({:.2f}%)\n'.format(start_usage.ru_maxrss, end_usage.ru_maxrss, dmaxrss, dmaxrsspct * 100.0))
sys.stderr.write('idrss: {} - {}, d={} ({:.2f}%)\n'.format(start_usage.ru_idrss, end_usage.ru_idrss, didrss, didrsspct * 100.0))
assert (dmaxrsspct) < 0.05, [x.ru_maxrss for x in usage_history]
assert (didrsspct) < 0.05, [x.ru_idrss for x in usage_history]
def test_loads_usage(self):
'''
repeatedly serialize, check that usage doesn't go up
'''
if (cdumps is None) or (cloads is None):
logger.warn('no C fast CBOR, skipping test_loads_usage')
return
## Just a string passes!
#ob = 'sntaoheusnatoheusnaotehuasnoetuhaosentuhaoesnth'
## Just an array passes!
#ob = [1,2,3,4,5,6,7,8,9,12,12,13]
## Just a dict passes!
#ob = {'a':'b', 'c':'d', 'e':'f', 'g':'h'}
# dict of dict is doom!
#ob = {'a':{'b':'c', 'd':'e', 'f':'g'}, 'x':'p'}
ob = {'aoeu':[1,2,3,4],'foo':'bar','pants':{'foo':0xb44, 'pi':3.14}, 'flubber': [{'x':'y', 'z':[None, 2, []]}, 2, 'hello']}
blob = cdumps(ob)
start_usage = resource.getrusage(resource.RUSAGE_SELF)
usage_history = [start_usage]
for o in _range(_TEST_OUTER):
for i in _range(_TEST_COUNT):
dob = cloads(blob)
# and silently drop the result. I hope the garbage collector works!
t_usage = resource.getrusage(resource.RUSAGE_SELF)
usage_history.append(t_usage)
end_usage = usage_history[-1]
dmaxrss = end_usage.ru_maxrss - start_usage.ru_maxrss
didrss = end_usage.ru_idrss - start_usage.ru_idrss
dmaxrsspct = ((end_usage.ru_maxrss != 0) and (dmaxrss / end_usage.ru_maxrss)) or 0
didrsspct = ((end_usage.ru_idrss != 0) and (didrss / end_usage.ru_idrss)) or 0
sys.stderr.write('maxrss: {} - {}, d={} ({:.2f}%)\n'.format(start_usage.ru_maxrss, end_usage.ru_maxrss, dmaxrss, dmaxrsspct * 100.0))
sys.stderr.write('idrss: {} - {}, d={} ({:.2f}%)\n'.format(start_usage.ru_idrss, end_usage.ru_idrss, didrss, didrsspct * 100.0))
assert (dmaxrsspct) < 0.05, [x.ru_maxrss for x in usage_history]
assert (didrsspct) < 0.05, [x.ru_idrss for x in usage_history]
def _total_gb():
# given in KB so convert
my_usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / (1024**2)
# total_usage = mpiops.comm.reduce(my_usage, root=0)
total_usage = ls.mpiops.comm.allreduce(my_usage)
return total_usage
def memprofile():
import resource
import tracemalloc
tracemalloc.start()
ast = parse_file('/tmp/197.c')
print('Memory usage: %s (kb)' %
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
snapshot = tracemalloc.take_snapshot()
print("[ tracemalloc stats ]")
for stat in snapshot.statistics('lineno')[:20]:
print(stat)
def do_stats(self):
mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
return {'mem_usage': '%s MB' % (mem / 1024)}
def memory_usage_resource():
rusage_denom = 1024.
if sys.platform == 'darwin':
# ... it seems that in OSX the output is different units ...
rusage_denom = rusage_denom * rusage_denom
mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / rusage_denom
return mem
def info(self, ctx):
"""Display bot info, e.g. library versions."""
embed = discord.Embed()
embed.description = ctx.bot.description
embed.set_thumbnail(url=ctx.bot.user.avatar_url_as(format="png", size=128))
if k2:
embed.add_field(name="Version", value=k2.version)
ainfo = await ctx.bot.application_info()
owner = str(ainfo.owner)
embed.add_field(name="Owner", value=owner)
embed.add_field(name="# of commands", value=len(ctx.bot.commands))
if ctx.guild and ctx.bot.shard_count > 1:
embed.add_field(name="Shard", value=f"{ctx.guild.shard_id+1} of {ctx.bot.shard_count}")
num_guilds = len(ctx.bot.guilds)
num_users = sum(not member.bot for member in ctx.bot.get_all_members())
embed.add_field(name="Serving", value=f"{num_users} people in {num_guilds} guilds")
embed.add_field(name="Python", value="{0}.{1}.{2}".format(*sys.version_info))
embed.add_field(name="discord.py", value=discord.__version__)
usage_memory = round(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1000, 2)
embed.add_field(name="Cookies eaten", value=f"{usage_memory} megabites")
if k2:
embed.add_field(name="Github", value=k2.url, inline=False)
await ctx.send(embed=embed)
def logger(self, mssg="", decorate=1):
"""Logging function."""
head = "\n%s"%("#"*50,)
timestamp = "\n[%s]"% datetime.ctime(datetime.now())
memusage = "[%5i Mb] "%(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024, )
if self.log:
if decorate:
self.log.write("".join((head, timestamp, memusage, mssg)))
else:
self.log.write(mssg)
def clocku():
"""clocku() -> floating point number
Return the *USER* CPU time in seconds since the start of the process.
This is done via a call to resource.getrusage, so it avoids the
wraparound problems in time.clock()."""
return resource.getrusage(resource.RUSAGE_SELF)[0]
def clocks():
"""clocks() -> floating point number
Return the *SYSTEM* CPU time in seconds since the start of the process.
This is done via a call to resource.getrusage, so it avoids the
wraparound problems in time.clock()."""
return resource.getrusage(resource.RUSAGE_SELF)[1]
