mirror of
https://github.com/taroved/pol
synced 2025-05-16 06:10:09 -07:00
250 lines
8.4 KiB
Python
250 lines
8.4 KiB
Python
import gc
|
|
import time, sys
|
|
from twisted.logger import Logger
|
|
|
|
log = Logger()
|
|
|
|
class bcolors:
|
|
HEADER = '\033[95m'
|
|
OKBLUE = '\033[94m'
|
|
OKGREEN = '\033[92m'
|
|
WARNING = '\033[93m'
|
|
FAIL = '\033[91m'
|
|
ENDC = '\033[0m'
|
|
BOLD = '\033[1m'
|
|
UNDERLINE = '\033[4m'
|
|
|
|
GC_PERIOD_SECONDS = 1#3 * 60 * 60 # 3 hours
|
|
|
|
def is_hist_obj(tpe, _str_or_o):
|
|
for t in pgc.id_types:
|
|
if type(t) is str:
|
|
return t == tpe
|
|
elif tpe == t[0] and (_str_or_o if type(_str_or_o) is str else str(_str_or_o)).startswith(t[1]): # [type, val_start]
|
|
return True
|
|
return False
|
|
|
|
class Stat:
|
|
def __init__(self, count, size, objects):
|
|
self.count = count
|
|
self.size = size
|
|
self.objects = objects
|
|
|
|
def get_gc_stats():
|
|
go = {}
|
|
for o in gc.garbage:
|
|
tpe = type_str(o)
|
|
if tpe not in go:
|
|
go[tpe] = Stat(1, sys.getsizeof(o), [])
|
|
else:
|
|
go[tpe].count += 1
|
|
go[tpe].size += sys.getsizeof(o)
|
|
go[tpe].objects.append((id(o), str(o)))
|
|
allo = {}
|
|
for o in gc.get_objects():
|
|
tpe = type_str(o)
|
|
if tpe not in allo:
|
|
allo[tpe] = Stat(1, sys.getsizeof(o), [])
|
|
else:
|
|
allo[tpe].count += 1
|
|
allo[tpe].size += sys.getsizeof(o)
|
|
if is_hist_obj(tpe, o):
|
|
allo[tpe].objects.append((id(o), str(o)[:180]))
|
|
return [go, allo]
|
|
|
|
def stats_str(stat):
|
|
tpe, count, size = stat
|
|
prev_diff = [0, 0]
|
|
|
|
if tpe in pgc.prev_stats:
|
|
prev_diff[0] = count - pgc.prev_stats[tpe].count
|
|
prev_diff[1] = size - pgc.prev_stats[tpe].size
|
|
|
|
first_diff = [0, 0]
|
|
|
|
if tpe in pgc.first_stats:
|
|
first_diff[0] = count - pgc.first_stats[tpe].count
|
|
first_diff[1] = size - pgc.first_stats[tpe].size
|
|
|
|
prev_count_sigh = ''
|
|
if prev_diff[0] > 0:
|
|
prev_count_sigh = '+'
|
|
|
|
first_count_sigh = ''
|
|
if first_diff[0] > 0:
|
|
first_count_sigh = '+'
|
|
|
|
prev_size_sigh = ''
|
|
if prev_diff[1] > 0:
|
|
prev_size_sigh = '+'
|
|
|
|
first_size_sigh = ''
|
|
if first_diff[1] > 0:
|
|
first_size_sigh = '+'
|
|
|
|
s = "%s: %s,%s%s,%s%s %s,%s%s,%s%s" % (tpe, count, prev_count_sigh, prev_diff[0], first_count_sigh, first_diff[0], size, prev_size_sigh, prev_diff[1], first_size_sigh, first_diff[1])
|
|
|
|
if prev_diff[0] != 0 or prev_diff[1] != 0 or first_diff[0] != 0 or first_diff[1] != 0:
|
|
if prev_diff[0] > 0 or prev_diff[1] > 0:
|
|
return bcolors.WARNING + s + bcolors.ENDC
|
|
elif prev_diff[0] < 0 or prev_diff[1] < 0:
|
|
return bcolors.OKGREEN + s + bcolors.ENDC
|
|
else:
|
|
return bcolors.OKBLUE + s + bcolors.ENDC
|
|
else:
|
|
return None #s # not changed
|
|
|
|
def pgc(none): # periodical_garbage_collect
|
|
#global pool
|
|
#pool.closeCachedConnections()
|
|
|
|
tm = int(time.time())
|
|
if tm - pgc.time >= GC_PERIOD_SECONDS:
|
|
log.info('GC: COLLECTED: %s' % gc.collect())
|
|
go, allo = get_gc_stats()
|
|
log.info("GC: GARBAGE OBJECTS STATS (%s)" % len(go))
|
|
for tpe, stats in sorted(go.iteritems(), key=lambda t: t[0]):
|
|
log.info("GC: %s: %s, %s" % (tpe, stats.count. stats.size))
|
|
|
|
log.info("GC: ALL OBJECTS STATS (%s)" % len(allo))
|
|
|
|
if not pgc.first_stats:
|
|
pgc.first_stats = allo
|
|
|
|
size = 0
|
|
cur_ids = []
|
|
cur_values = []
|
|
for tpe, stats in sorted(allo.iteritems(), key=lambda t: t[0]):
|
|
scount = stats.count
|
|
ssize = stats.size
|
|
objects = stats.objects
|
|
sstr = stats_str([tpe, scount, ssize])
|
|
if sstr:
|
|
log.info("GC: %s" % sstr)
|
|
size += ssize
|
|
for _id, _str in objects:
|
|
if is_hist_obj(tpe, _str):
|
|
cur_ids.append(_id)
|
|
cur_values.append(_str)
|
|
if not pgc.first_size:
|
|
pgc.first_size = size
|
|
pgc.prev_size = size
|
|
log.info('GC: ALL OBJECT SIZE: %s,%s,%s' % (size, size - pgc.prev_size, size - pgc.first_size))
|
|
|
|
if pgc.ids:
|
|
new_ids = []
|
|
for tpe_filter in pgc.id_types:
|
|
#import pdb;pdb.set_trace()
|
|
if type(tpe_filter) is str:
|
|
tpe = tpe_filter
|
|
else:
|
|
tpe = tpe_filter[0]
|
|
objects = allo[tpe].objects
|
|
count = 0
|
|
for _id, _str in objects:
|
|
if is_hist_obj(tpe, _str) and _id not in pgc.ids and (not pgc.filter_by_value or _str not in pgc.values):
|
|
log.info('GC new obj %s(%s): {str!r}' % (tpe, _id), str=_str)
|
|
count += 1
|
|
new_ids.append(_id)
|
|
log.info('GC new obj %s: %s items' % (tpe, count))
|
|
|
|
step = -1
|
|
for ids in pgc.hist_ids:
|
|
step_ids = []
|
|
for tpe_filter in pgc.id_types:
|
|
if type(tpe_filter) is str:
|
|
tpe = tpe_filter
|
|
else:
|
|
tpe = tpe_filter[0]
|
|
objects = allo[tpe].objects
|
|
count = 0
|
|
for _id, _str in objects:
|
|
if _id in ids and is_hist_obj(tpe, _str) and (not pgc.filter_by_value or _str not in pgc.values):
|
|
log.info('GC %s new obj %s(%s): {str!r}' % (step, tpe, _id), str = _str)
|
|
count += 1
|
|
step_ids.append(_id)
|
|
break
|
|
log.info('GC %s new obj %s: %s items' % (step, tpe, count))
|
|
step -= 1
|
|
ids[:] = [] #clear list
|
|
ids.extend(step_ids) # add evailable
|
|
if step_ids:
|
|
pgc.oldest_id = step_ids[-1]
|
|
pgc.hist_ids.insert(0, new_ids)
|
|
pgc.hist_ids[:] = pgc.hist_ids[0:3]
|
|
log.info('GC oldest id %s' % pgc.oldest_id)
|
|
#if pgc.oldest_id:
|
|
# print_obj_id_refs(pgc.oldest_id)
|
|
|
|
|
|
pgc.ids = cur_ids
|
|
pgc.values = cur_values
|
|
pgc.prev_stats = allo
|
|
pgc.prev_size = size
|
|
|
|
pgc.time = tm
|
|
|
|
OLDEST_OBJ_DEPTH = 1
|
|
|
|
def print_obj_ref(depth, os):
|
|
for o in os:
|
|
refs = gc.get_referrers(o)
|
|
log.info('GC oldest %s ref cnt:%s %s(%s): %s' % ('*' * depth, len(refs), str(type(o)), id(o), str(o)[:500]))
|
|
if depth < OLDEST_OBJ_DEPTH:
|
|
print_obj_ref(depth+1, refs)
|
|
|
|
def get_obj_by_id(o_id):
|
|
return [o for o in gc.get_objects() if id(o)==o_id][0]
|
|
|
|
def print_obj_id_refs(o_id):
|
|
#print_obj_ref(0, (get_obj_by_id(o_id),))
|
|
o = get_obj_by_id(o_id)
|
|
refs = gc.get_referrers(o)
|
|
log.info('gc oldest obj cnt:%s %s(%s): {str!r}' % (len(refs), str(type(o)), id(o)), {'str': str(o)[:500]})
|
|
#import types
|
|
first = True
|
|
for r in refs:
|
|
# import pdb;pdb.set_trace()
|
|
log.info('gc oldest %s ref cnt:%s %s(%s): {str!r}' % ('*', -1, str(type(r)), id(r)), {'str': str(r)[:500].replace(hex(o_id), bcolors.WARNING + str(hex(o_id)) + bcolors.ENDC)})
|
|
if first and type(r) is dict:
|
|
refs2 = gc.get_referrers(r)
|
|
for r2 in refs2:
|
|
log.info('gc oldest %s ref cnt:%s %s(%s): {str!r}' % ('**', -2, str(type(r2)), id(r2)), {'str': str(r2)[:500].replace(hex(id(r)), bcolors.WARNING + str(hex(id(r))) + bcolors.ENDC)})
|
|
if str(type(r2)) == "<type 'collections.deque'>":
|
|
refs3= gc.get_referrers(r2)
|
|
for r3 in refs3:
|
|
log.info('gc oldest %s ref cnt:%s %s(%s): {str!r}' % ('**', -3, str(type(r3)), id(r3)), {'str': str(r3)[:500].replace(hex(id(r2)), bcolors.WARNING + str(hex(id(r2))) + bcolors.ENDC)})
|
|
|
|
first = False
|
|
|
|
|
|
pgc.first_stats = None
|
|
pgc.prev_stats = {}
|
|
pgc.first_size = None
|
|
pgc.prev_size = None
|
|
|
|
pgc.oldest_id = None
|
|
pgc.hist_ids = []
|
|
|
|
|
|
def type_str(obj):
|
|
switcher = {
|
|
"<type 'instance'>": lambda o: str(type(o)) + '(' + o.__class__.__name__ + ')',
|
|
"<type 'instancemethod'>": lambda o: str(type(o)) + '(' + str(o) + ')'
|
|
}
|
|
func = switcher.get(str(type(obj)), lambda o: str(type(o)))
|
|
return func(obj)
|
|
|
|
pgc.ids = []
|
|
pgc.id_types = [
|
|
#["<type 'instance'>", "<twisted.web.client._HTTP11ClientFactory instance"],
|
|
#"<type 'instancemethod'>",
|
|
#"<type 'instance'>(DelayedCall)",
|
|
#"<class 'twisted.logger._logger.Logger'>",
|
|
#"<type 'list'>"
|
|
]
|
|
pgc.values = []
|
|
pgc.filter_by_value = False
|
|
|
|
pgc.time = int(time.time())
|