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)