def __init__(self, node: kademlia.Node, wire: 'DiscoveryProtocol') -> None:
super(KademliaCrawlerProtocol, self).__init__(node, wire)
self.logger.debug("Kademlia Crawler Created")
self.tracker = ClassTracker()
self.myTree = btree.Tree(256)
self.tracker.track_object(self.myTree)
self.MAX_CONCURRENT = 64
def main():
tracker = ClassTracker()
tracker.track_class(Point)
tracker.track_class(Line)
tracker.create_snapshot()
points = [get_point(i) for i in xrange(1000000)]
lines = [get_line(i) for i in xrange(100000)]
tracker.create_snapshot()
tracker.stats.print_summary()
def run(self):
"""
Redirect bottle logging messages so it doesn't clutter the test output
and start the web GUI.
"""
tracker = ClassTracker()
tracker.track_class(Trash)
tracked_trash = Trash()
tracker.create_snapshot()
sys.stdout = StringIO()
sys.stderr = StringIO()
start_profiler(debug=True, quiet=True, tracker=tracker)
def process_request(self, request: HttpRequest) -> HttpResponse:
self._tracker = ClassTracker()
for cls in apps.get_models() + self.classes:
self._tracker.track_class(cls)
self._tracker.create_snapshot('before')
self.record_stats({'before': ProcessMemoryInfo()})
response = super(MemoryPanel, self).process_request(request)
self.record_stats({'after': ProcessMemoryInfo()})
self._tracker.create_snapshot('after')
stats = self._tracker.stats
stats.annotate()
self.record_stats({'stats': stats})
return response
def profile_memory():
from pympler.classtracker import ClassTracker
from pympler.asizeof import asizeof
from soap.common import Flyweight, _cache_map
from soap.expression import Expr
tracker = ClassTracker()
tracker.track_object(Flyweight._cache)
tracker.track_class(Expr)
yield
tracker.create_snapshot()
tracker.stats.print_summary()
print('Flyweight cache size', asizeof(Flyweight._cache))
print('Global cache size', asizeof(_cache_map))
def __init__(self, **kwargs):
super(GlobalContainer, self).__init__(**kwargs)
self._keyboard = None
self.request_keyboard()
self.working_dir = './'
self.tutorial = None
self.popup_stack = []
window.Window.bind(on_resize=self.on_resize)
if DEBUG:
self.tracker = ClassTracker()
self.tracker.track_object(MenuButton)
self.all_objects = muppy.get_objects()
def profiled_wrapper(*args, **kvs):
'''
wraps original class-definition callable
'''
from pympler.classtracker import ClassTracker
import atexit
tracker = ClassTracker()
tracker.track_class(cls)
# monkeypatch the original class __setattr__
# to take mem usage snapshots at setting attributes
original_setattr = cls.__setattr__
def __setattr__(self, attrname, value):
'''
snapshot mem usage at attrname access
'''
try:
tracker.create_snapshot(attrname)
except Exception as e:
pass
return original_setattr(self, attrname, value)
cls.__setattr__ = __setattr__
def dump_stats_atexit():
'''
dumps mem stats at program exit for each process separately
'''
import os
import tempfile
_, name = tempfile.mkstemp(prefix="mem-%s-%s-" %
(cls.__name__, os.getpid()),
suffix=".log")
tracker.stats.dump_stats(name)
# register the stats dumping
atexit.register(dump_stats_atexit)
# back to class instantiation
return cls(*args, **kvs)
def test_start_in_background(self):
"""Test server can be started in background mode."""
tracker = ClassTracker()
thread = start_in_background(port=64546, stats=tracker.stats)
self.assertEqual(thread.daemon, True)
def test_detach_on_close(self):
original_constructor = Foo.__init__
tracker = ClassTracker()
tracker.track_class(Foo)
tracker.close()
self.assertEqual(Foo.__init__, original_constructor)
def setUp(self):
self.tracker = ClassTracker()
def enable_instrumentation(self):
self._tracker = ClassTracker()
for cls in apps.get_models() + self.classes:
self._tracker.track_class(cls)
def process_request(self, request):
self._tracker = ClassTracker()
for cls in apps.get_models() + self.classes:
self._tracker.track_class(cls)
self._tracker.create_snapshot('before')
self.record_stats({'before': ProcessMemoryInfo()})
def process_request(self, request):
self._tracker = ClassTracker()
for cls in get_models() + self.classes:
self._tracker.track_class(cls, keep=True)
self._tracker.create_snapshot('before')
self._before = ProcessMemoryInfo()
def track_memory_wrapper(*args, **kwargs):
memory_info = {}
tracker = ClassTracker()
for cls in apps.get_models() + [Context, Template]:
# track all models from registered apps, plus some standard Django ones
tracker.track_class(cls)
try:
tracker.create_snapshot("before")
memory_info["before"] = ProcessMemoryInfo()
result = fn(*args, **kwargs)
memory_info["after"] = ProcessMemoryInfo()
tracker.create_snapshot("after")
memory_info["stats"] = tracker.stats
memory_info["stats"].annotate()
return result
finally:
# record a whole bunch of memory statistics...
resources = [
("resident set size", memory_info["after"].rss),
("virtual size", memory_info["after"].vsz),
]
resources.extend(memory_info["after"] - memory_info["before"])
resources = [(k, pp(v)) for k, v in resources]
resources.extend(memory_info["after"].os_specific)
# record each tracked class as of the final snapshot...
classes_stats = []
snapshot = memory_info["stats"].snapshots[-1]
for class_name in memory_info["stats"].tracked_classes:
# history is a list of tuples that is updated on every creation/deletions: (timestamp, n_instances)
history = [
n for _, n in memory_info["stats"].history[class_name]
]
if history:
classes_stats.append({
"name":
class_name,
"n_instances":
len(history),
"min_instances":
min(history),
"max_instances":
max(history),
"size":
pp(
snapshot.classes.get(class_name,
{}).get("sum", 0)),
})
if not path:
stream = sys.stdout
else:
stream = open(path, "w")
print("\nRESOURCES", file=stream)
for k, v in resources:
print(f"{k:<26}: {v:>10}", file=stream)
print("\nCLASSES", file=stream)
for class_stats in classes_stats:
print(
"{name}: created/deleted {n_instances} times for a min/max of {min_instances}/{max_instances} instances: {size:>10}"
.format(**class_stats),
file=stream,
)
stream.closed
tracker.detach_all_classes()
def setUp(self):
self.out = StringIO()
self.tracker = ClassTracker(stream=self.out)
def __init__(self, request):
self._tracker = ClassTracker()
self._tracker.track_class(Request)
self._tracker.track_class(Response)
def __init__(self, cls):
from pympler.classtracker import ClassTracker
tracker = ClassTracker()
tracker.track_class(cls)
self.tracker = tracker
'''
Wrapper of pympler tracker for memory profiling.
'''
try:
#Exception checked as pypy complains
from pympler.classtracker import ClassTracker
tracker = ClassTracker()
except:
tracker = None
def track_object(o):
if tracker != None:
tracker.track_object(o, resolution_level=2)
def track_class(c):
if tracker != None:
tracker.track_class(c, trace=1, resolution_level=1)
def create_snapshot(tag):
if tracker != None:
tracker.create_snapshot(tag)
