class Debugger(Evenement): def __init__(self, jeu, gestionnaire, methode=False): print("start") super().__init__(jeu, gestionnaire) self._debugFait, self._methode = 0, methode if self._methode is not False: if self._methode == "Instance": self._tracker = ClassTracker() self._tracker.track_class(Evenement) self._tracker.create_snapshot("Initialisation") elif self._methode == "Fuites": self._tracker = pympler.tracker.SummaryTracker() self._tracker.print_diff() Horloge.initialiser(id(self), 1, 3000) def cmp(self, obj): return str(type(obj)) def traiter(self): if Horloge.sonner(id(self), 1) is True: if self._methode == "Instance": if self._debugFait < 3: self._tracker.create_snapshot("Etape n°" + str(self._debugFait)) self._debugFait += 1 Horloge.initialiser(id(self), 1, 3000) else: self._tracker.stats.print_summary() elif self._methode == "Fuites": self._tracker.print_diff() Horloge.initialiser(id(self), 1, 3000)
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 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()
class MemoryPanel(DebugPanel): name = 'pympler' has_content = True template = 'memory_panel.html' classes = [Context, Template] def process_request(self, request): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) self._tracker.create_snapshot('before') self._before = ProcessMemoryInfo() def process_response(self, request, response): self._after = ProcessMemoryInfo() self._tracker.create_snapshot('after') def title(self): return 'Memory' def nav_title(self): return 'Memory' def nav_subtitle(self): rss = self._after.rss delta = rss - self._before.rss delta = ('(+%s)' % pp(delta)) if delta > 0 else '' return "%s %s" % (pp(rss), delta) def url(self): return '' def get_stats(self): pass def content(self): stats = self._tracker.stats stats.annotate() context = self.context.copy() rows = [('Resident set size', self._after.rss), ('Virtual size', self._after.vsz), ] rows.extend(self._after - self._before) rows = [(key, pp(value)) for key, value in rows] rows.extend(self._after.os_specific) classes = [] snapshot = stats.snapshots[-1] for model in stats.tracked_classes: history = [cnt for _, cnt in stats.history[model]] size = snapshot.classes.get(model, {}).get('sum', 0) if cnt > 0: classes.append((model, history, pp(size))) context.update({'rows': rows, 'classes': classes}) return render_to_string(self.template, context)
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 __init__(self, jeu, gestionnaire, methode=False): print("start") super().__init__(jeu, gestionnaire) self._debugFait, self._methode = 0, methode if self._methode is not False: if self._methode == "Instance": self._tracker = ClassTracker() self._tracker.track_class(Evenement) self._tracker.create_snapshot("Initialisation") elif self._methode == "Fuites": self._tracker = pympler.tracker.SummaryTracker() self._tracker.print_diff() Horloge.initialiser(id(self), 1, 3000)
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)
class TrackClassTestCase(unittest.TestCase): def setUp(self): self.tracker = ClassTracker() def tearDown(self): self.tracker.stop_periodic_snapshots() self.tracker.clear() def test_type_errors(self): """Test invalid parameters for class tracking. """ i = 42 j = 'Foobar' k = [i, j] l = {i: j} foo = Foo() bar = Bar() self.assertRaises(TypeError, self.tracker.track_class, i) self.assertRaises(TypeError, self.tracker.track_class, j) self.assertRaises(TypeError, self.tracker.track_class, k) self.assertRaises(TypeError, self.tracker.track_class, l) self.assertRaises(TypeError, self.tracker.track_class, foo) self.assertRaises(TypeError, self.tracker.track_class, bar) self.assert_(id(i) not in self.tracker.objects) self.assert_(id(j) not in self.tracker.objects) self.assert_(id(k) not in self.tracker.objects) self.assert_(id(l) not in self.tracker.objects) def test_track_class(self): """Test tracking objects through classes. """ self.tracker.track_class(Foo) self.tracker.track_class(Bar) self.tracker.track_class(Empty) self.tracker.track_class(Foo) foo = Foo() bar = Bar() empty = Empty() self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) self.assert_(id(empty) in self.tracker.objects) def test_track_class_new(self): """Test tracking new style classes. """ self.tracker.track_class(FooNew) self.tracker.track_class(BarNew) foo = FooNew() bar = BarNew() self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) def test_track_by_name(self): """Test registering objects by name. """ self.tracker.track_class(Foo, name='Foobar') foo = Foo() self.assert_('Foobar' in self.tracker.index) self.assertEqual(self.tracker.index['Foobar'][0].ref(), foo) def test_keep(self): """Test lifetime of tracked objects. """ self.tracker.track_class(Foo, keep=1) self.tracker.track_class(Bar) foo = Foo() bar = Bar() idfoo = id(foo) idbar = id(bar) del foo del bar self.assert_(self.tracker.objects[idfoo].ref() is not None) self.assert_(self.tracker.objects[idbar].ref() is None) def test_trace(self): """Test instantiation tracing of tracked objects. """ from inspect import stack self.tracker.track_class(Foo, trace=True) self.tracker.track_class(BarNew, trace=True) foo = Foo() bar = BarNew() idfoo = id(foo) idbar = id(bar) trace = [] st = stack() try: for fr in st: trace.insert(0, fr[1:]) finally: del st self.assertEqual(self.tracker.objects[idfoo].trace[-1][3][0].strip(), "foo = Foo()") self.assertEqual(self.tracker.objects[idfoo].trace[:-1], trace[:-1], trace) self.assertEqual(self.tracker.objects[idbar].trace[:-1], trace[:-1], trace) def test_detach(self): """Test detaching from tracked classes. """ self.tracker.track_class(Foo) self.tracker.track_class(Bar) foo = Foo() bar = Bar() self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) self.tracker.detach_class(Foo) self.tracker.detach_class(Bar) foo2 = Foo() bar2 = Bar() self.assert_(id(foo2) not in self.tracker.objects) self.assert_(id(bar2) not in self.tracker.objects) self.assertRaises(KeyError, self.tracker.detach_class, Foo) def test_change_name(self): """Test modifying name. """ self.tracker.track_class(Foo, name='Foobar') self.tracker.track_class(Foo, name='Baz') foo = Foo() self.assert_('Foobar' not in self.tracker.index) self.assert_('Baz' in self.tracker.index) self.assertEqual(self.tracker.index['Baz'][0].ref(), foo)
class GlobalContainer(box.BoxLayout): graph_list = prop.ListProperty([]) active_graph = prop.ObjectProperty(None) name_manager = NameManager.Instance() show_sidepanel = prop.BooleanProperty(True) modestr = prop.StringProperty('insert') itemstr = prop.StringProperty('atom') modes = {'insert': asp.Mode.INSERT, 'select': asp.Mode.SELECT} items = {'atom': asp.Item.ATOM, 'ellipse': asp.Item.ELLIPSE, 'rectangle': asp.Item.SQUARE} 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 request_keyboard(self): self._keyboard = window.Window.request_keyboard(self._keyboard_release, self) self._keyboard.bind(on_key_down=self._on_keyboard_down) def _keyboard_catch(self): self._keyboard.bind(on_key_down=self._on_keyboard_down) def _keyboard_release(self): self._keyboard.unbind(on_key_down=self._on_keyboard_down) #self._keyboard = None def _on_keyboard_down(self, keyboard, keycode, text, modifiers): if keycode[1] == 'escape': base.stopTouchApp() elif keycode[1] == 'd': self.set_mode('insert') elif keycode[1] == 's': self.set_mode('select') elif keycode[1] == 'w': self.set_item('atom') elif keycode[1] == 'e': self.set_item('ellipse') elif keycode[1] == 'r': self.set_item('rectangle') elif keycode[1] == 'p': self.active_graph.show_tree(0) elif keycode[1] == 'o': self.view_symbolic_formula() elif keycode[1] == 'n': self.show_gringo_query() elif keycode[1] == 'g': self.show_save() elif keycode[1] == 'l': self.show_load() elif keycode[1] == 'y': print self.name_manager.get_all() print asp.Line.get_all_lines() elif keycode[1] == 't': self.toggle_sidepanel() elif keycode[1] == 'tab': if not self.show_sidepanel: self.toggle_sidepanel() self.ids.atom_input.focus = True elif keycode[1] == '.': if DEBUG: rb = refbrowser.InteractiveBrowser(self) rb.main() # self.all_objects = muppy.get_objects() # sum1 = summary.summarize(self.all_objects) # summary.print_(sum1) # self.tracker.create_snapshot() # self.tracker.stats.print_summary() return True def _focus_name_list(self, value): if value and (asp.AtomWidget.active_atom is not None): previous_name = asp.AtomWidget.active_atom.name for button in self.ids.name_list.children: if (button.text == previous_name) and (button.state != 'down'): button.trigger_action() elif value: if self.ids.name_list.children: self.ids.name_list.children[-1].trigger_action() else: for button in self.ids.name_list.children: if button.state == 'down': button.trigger_action() def on_resize(self, window, width, height): if self.show_sidepanel: self.ids.sidepanel.width = self.width * .15 self.active_graph.size = self.ids.stencilview.size def toggle_sidepanel(self): self.show_sidepanel = not self.show_sidepanel if self.show_sidepanel: width = self.width * .15 else: width = 0 anim.Animation(width=width, d=.15, t='out_quart').start( self.ids.sidepanel) if not self.show_sidepanel: self.ids.sidepanel.focus = False # Also release keyboard #self.update_sourcecode() def update_atom_editor(self, name): editor = self.ids.atom_editor if name == '': editor.disabled = True else: if editor.disabled: editor.disabled = False atom = self.name_manager.get(name) editor.update(atom) def update_atom(self, name, new_name='', new_hook_points=[], is_constant=False): atom = self.name_manager.get(name) if new_name <> '': atom.name = new_name if len(new_hook_points) == 4: atom.hook_points = new_hook_points # print id(atom.hook_points) atom.is_constant = is_constant def register_atom(self, name, hooks=[False, False, False, False], is_constant=False): if name == '': return children = self.ids.name_list.children new_button = None name_to_insert = name i = len(children) - 1 # If the name doesn't exist, register atom if self.name_manager.get(name) is None: self.name_manager.register(name, asp.Atom(name, hooks, is_constant)) # print id(self.name_manager.get(name).hook_points) # Insert in name_list sorted by name while i >= 0: if children[i].text < name_to_insert: #print children[i].text, '<', name_to_insert pass elif children[i].text == name_to_insert: # Already exists if children[i].state != 'down': children[i].trigger_action() return elif children[i].text > name_to_insert: #print children[i].text, '>', name_to_insert temp = children[i].text children[i].text = name_to_insert name_to_insert = temp if new_button == None: new_button = children[i] i -= 1 self.ids.name_list.add_widget(AtomSelectionButton(text=name_to_insert)) if new_button == None: new_button = children[0] if new_button.state == 'down': asp.AtomWidget.active_atom = self.name_manager.get(name) self.update_atom_editor(name) self.set_item('atom') else: new_button.trigger_action() def rename_atom(self, new_name): old_name = '' for button in self.ids.name_list.children: if button.state == 'down': old_name = button.text selected_button = button if (old_name != '') and (new_name != ''): try: atom = self.name_manager.get(old_name) exists = self.name_manager.get(new_name) assert atom is not None assert exists is None except AssertionError: #self.show_error('Name already exists.') print 'Name already exists.' return selected_button.text = new_name atom.name = new_name self.name_manager.unregister(old_name) self.name_manager.register(new_name, atom) self.update_atom_editor(new_name) def delete_atom(self): for button in self.ids.name_list.children: if button.state == 'down': self.name_manager.unregister(button.text) self.active_graph.delete_atom(button.text) asp.AtomWidget.active_atom = None self.ids.name_list.remove_widget(button) self.update_atom_editor('') def clear_atoms(self): self.ids.name_list.clear_widgets() self.name_manager.clear() self.update_atom_editor('') asp.AtomWidget.active_atom = None def new_graph(self): # TODO: Migrate to tab system asp.Line.clear_lines() self.clear_atoms() if self.active_graph is None: g = asp.RootWidget() self.graph_list.append(g) self.active_graph = g self.ids.stencilview.add_widget(g) else: self.active_graph.delete_tree() def close_graph(self): if self.active_graph is not None: asp.Line.clear_lines() self.active_graph.delete_tree() self.active_graph.delete_root() self.clear_atoms() self.graph_list.pop() self.active_graph = None def set_mode(self, mode): try: prev_mode = self.active_graph.mode new_mode = self.modes[mode] if new_mode == asp.Mode.INSERT: self.active_graph.show_hooks() else: if prev_mode == asp.Mode.INSERT: self.active_graph.hide_hooks() self.active_graph.mode = new_mode self.modestr = mode except KeyError as err: print 'ERROR: Invalid mode {0} requested.'.format(str(err)) def set_item(self, item): try: self.active_graph.item = self.items[item] self.itemstr = item except KeyError as err: print 'ERROR: Invalid item {0} requested.'.format(str(err)) except AttributeError: pass if item == 'atom': self._focus_name_list(True) else: self._focus_name_list(False) def push_popup(self, popup): self.popup_stack.append(popup) popup.open() def dismiss_popup(self): popup = self.popup_stack.pop() popup.dismiss() def show_rename_atom(self): content = TextInputDialog(caption="Enter new name", validate_callback=self.rename_atom, cancel=self.dismiss_popup) p = CustomPopup(self, title="Rename atom", content=content, size_hint=(0.4, 0.25)) self.push_popup(p) def show_load(self): content = LoadDialog(load=self.load, cancel=self.dismiss_popup) content.ids.filechooser.path = self.working_dir p = CustomPopup(self, title="Load file", content=content, size_hint=(0.9, 0.9)) self.push_popup(p) def show_save(self): content = SaveDialog(save=self.save, cancel=self.dismiss_popup) content.ids.filechooser.path = self.working_dir p = CustomPopup(self, title="Save file", content=content, size_hint=(0.9, 0.9)) self.push_popup(p) def show_export(self): content = ExportDialog(export=self.export, cancel=self.dismiss_popup) content.ids.filechooser.path = self.working_dir p = CustomPopup(self, title="Export file", content=content, size_hint=(0.9, 0.9)) self.push_popup(p) def show_gringo_query(self): caption = "Enter desired predicates separated by commas" content = TextInputDialog(caption=caption, validate_callback=self.gringo_query, dismiss_on_validate=False, focus=False, cancel=self.dismiss_popup) p = CustomPopup(self, title="Output predicates", content=content, size_hint=(0.4, 0.25)) self.push_popup(p) def show_stable_models(self, solver): models = solver.get_models() content = None if len(models) == 0: content = ErrorDialog('Unsatisfiable', cancel=self.dismiss_popup) else: solver.generate_graph(models[0]) content = StableModelDialog(solver, cancel=self.dismiss_popup) content.ids.img.reload() p = CustomPopup(self, catch_keyboard=False, title="Stable Models", content=content, size_hint=(0.9, 0.9)) self.push_popup(p) def show_error(self, err_str): content = ErrorDialog(err_str, cancel=self.dismiss_popup) p = CustomPopup(self, catch_keyboard=False, title="Error", content=content, size_hint=(0.4, 0.3)) self.push_popup(p) def show_about(self): content = AboutDialog(cancel=self.dismiss_popup) p = CustomPopup(self, catch_keyboard=False, title="About "+__title__, content=content, size_hint=(0.5, 0.5)) self.push_popup(p) def load(self, path, filename): self.close_graph() self.working_dir = path try: f = os.path.join(path, filename[0]) # Temporal line storage. Its contents are arranged as follows: # { line_id: (graph, hook_list) , ... } lines = {} with open(f, 'r') as stream: for line in stream: if line.startswith(NameParser.TOKENS['name']): name, hooks, is_constant = NameParser.parse_name(line) self.register_atom(name, hooks, is_constant) if line.startswith(NameParser.TOKENS['line']): line_id, graph = NameParser.parse_line(line) lines[line_id] = (graph, [None] * len(graph)) new_graph = lang.Builder.load_file(f) self.ids.stencilview.add_widget(new_graph) self.active_graph = new_graph #self.graph_list.pop() self.graph_list.append(new_graph) for w in self.active_graph.walk(restrict=True): if isinstance(w, asp.AtomWidget): w._deferred_init() for i in w.get_line_info(): line_id = i[0] hook_index = i[1] lines[line_id][1][hook_index] = i[2] elif isinstance(w, asp.NexusWidget): for i in w.line_info: line_id = i[0] hook_index = i[1] lines[line_id][1][hook_index] = w for line, info in lines.iteritems(): print line, info asp.Line.build_from_graph(info[0], info[1]) self.set_mode(self.modestr) self.set_item(self.itemstr) self.dismiss_popup() except (KeyboardInterrupt, SystemExit): raise except: self.dismiss_popup() self.close_graph() self.new_graph() self.show_error('Corrupted file.') def save(self, path, filename): self.working_dir = path with open(os.path.join(path, filename), 'w') as stream: stream.write('#:kivy 1.0.9\n\n') for (name, atom) in self.name_manager.get_all(): stream.write(NameParser.get_name_str(name, atom.hook_points, atom.is_constant)) for line in asp.Line.get_all_lines(): stream.write(NameParser.get_line_str(line.line_id, line.get_full_graph())) stream.write('\n') stream.write(self.active_graph.get_tree(0)) self.dismiss_popup() def export(self, path, filename): _, ext = os.path.splitext(filename) if ext == '.png': self.active_graph.export_to_png(os.path.join(path, filename)) elif ext == '.lp': rpn = self.active_graph.get_formula_RPN() constants = self.active_graph.get_constants() solver = eg_solver.Solver() solver.set_formula(rpn, constants) rules = solver.generate_asp_rules() with open(os.path.join(path, filename), 'w') as stream: for r in rules: stream.write(r) stream.write('\n') else: error_str = 'File extension not supported.' print error_str self.show_error(error_str) return self.dismiss_popup() def highlight_variables(self): self.active_graph.highlight_variables() def view_symbolic_formula(self): print self.active_graph.get_formula() def gringo_query(self, show_predicates): def generate_show_statements(predicates): pred_list = predicates.split(',') pred_list = map(lambda s: s.strip(), pred_list) n_args = (lambda name: self.name_manager.get(name).hook_points.count(True)) pred_list = [p + '/' + str(n_args(p)) for p in pred_list] show_list = ['#show {0}.'.format(p) for p in pred_list] return show_list self.dismiss_popup() rpn = self.active_graph.get_formula_RPN() rpn = norm.LIT.TRUE if rpn == '' else rpn constants = self.active_graph.get_constants() print 80 * '-' print 'RPN formula:\n', rpn solver = eg_solver.Solver() result = '' try: show_statements = [] if show_predicates: try: show_statements = generate_show_statements(show_predicates) except Exception: pass solver.set_formula(rpn, constants) result = solver.solve(show=show_statements) except norm.MalformedFormulaError: self.show_error('Malformed formula.') return except RuntimeError, e: print e self.show_error(str(e)) return self.show_stable_models(solver)
class TrackObjectTestCase(unittest.TestCase): def setUp(self): self.tracker = ClassTracker() def tearDown(self): self.tracker.detach_all() def test_track_object(self): """Test object registration. """ foo = Foo() bar = Bar() self.tracker.track_object(foo) self.tracker.track_object(bar) self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) self.assert_('Foo' in self.tracker.index) self.assert_('Bar' in self.tracker.index) self.assertEqual(self.tracker.objects[id(foo)].ref(), foo) self.assertEqual(self.tracker.objects[id(bar)].ref(), bar) def test_type_errors(self): """Test intrackable objects. """ i = 42 j = 'Foobar' k = [i, j] l = {i: j} self.assertRaises(TypeError, self.tracker.track_object, i) self.assertRaises(TypeError, self.tracker.track_object, j) self.assertRaises(TypeError, self.tracker.track_object, k) self.assertRaises(TypeError, self.tracker.track_object, l) self.assert_(id(i) not in self.tracker.objects) self.assert_(id(j) not in self.tracker.objects) self.assert_(id(k) not in self.tracker.objects) self.assert_(id(l) not in self.tracker.objects) def test_track_by_name(self): """Test registering objects by name. """ foo = Foo() self.tracker.track_object(foo, name='Foobar') self.assert_('Foobar' in self.tracker.index) self.assertEqual(self.tracker.index['Foobar'][0].ref(), foo) def test_keep(self): """Test lifetime of tracked objects. """ foo = Foo() bar = Bar() self.tracker.track_object(foo, keep=1) self.tracker.track_object(bar) idfoo = id(foo) idbar = id(bar) del foo del bar self.assert_(self.tracker.objects[idfoo].ref() is not None) self.assert_(self.tracker.objects[idbar].ref() is None) def test_mixed_tracking(self): """Test mixed instance and class tracking. """ foo = Foo() self.tracker.track_object(foo) self.tracker.create_snapshot() self.tracker.track_class(Foo) objs = [] for _ in range(10): objs.append(Foo()) self.tracker.create_snapshot() def test_recurse(self): """Test recursive sizing and saving of referents. """ foo = Foo() self.tracker.track_object(foo, resolution_level=1) self.tracker.create_snapshot() fp = self.tracker.objects[id(foo)].snapshots[-1] refs = fp[1].refs dref = [r for r in refs if r.name == '__dict__'] self.assertEqual(len(dref), 1) dref = dref[0] self.assert_(dref.size > 0, dref.size) self.assert_(dref.flat > 0, dref.flat) self.assertEqual(dref.refs, ()) # Test track_change and more fine-grained resolution self.tracker.track_change(foo, resolution_level=2) self.tracker.create_snapshot() fp = self.tracker.objects[id(foo)].snapshots[-1] refs = fp[1].refs dref = [r for r in refs if r.name == '__dict__'] self.assertEqual(len(dref), 1) dref = dref[0] namerefs = [r.name for r in dref.refs] self.assert_('[K] foo' in namerefs, namerefs) self.assert_("[V] foo: 'foo'" in namerefs, namerefs)
class SnapshotTestCase(unittest.TestCase): def setUp(self): self.tracker = ClassTracker() def tearDown(self): self.tracker.stop_periodic_snapshots() self.tracker.clear() def test_timestamp(self): """Test timestamp of snapshots. """ foo = Foo() bar = Bar() self.tracker.track_object(foo) self.tracker.track_object(bar) self.tracker.create_snapshot() self.tracker.create_snapshot() self.tracker.create_snapshot() refts = [fp.timestamp for fp in self.tracker.snapshots] for to in self.tracker.objects.values(): ts = [t for (t, sz) in to.snapshots[1:]] self.assertEqual(ts, refts) def test_snapshot_members(self): """Test existence and value of snapshot members. """ foo = Foo() self.tracker.track_object(foo) self.tracker.create_snapshot() self.tracker.create_snapshot(compute_total=True) fp = self.tracker.snapshots[0] fp_with_total = self.tracker.snapshots[1] self.assert_(fp.overhead > 0, fp.overhead) self.assert_(fp.tracked_total > 0, fp.tracked_total) self.assertEqual(fp.asizeof_total, 0) self.assert_(fp_with_total.asizeof_total > 0, fp_with_total.asizeof_total) self.assert_( fp_with_total.asizeof_total >= fp_with_total.tracked_total) if pympler.process.is_available(): procmem = fp.system_total self.assertEqual(fp.total, procmem.vsz) self.assert_(procmem.vsz > 0, procmem) self.assert_(procmem.rss > 0, procmem) self.assertTrue(procmem.vsz >= procmem.rss, procmem) self.assert_(procmem.vsz > fp.overhead, procmem) self.assert_(procmem.vsz > fp.tracked_total, procmem) self.assert_( fp_with_total.system_total.vsz > fp_with_total.asizeof_total) else: self.assertEqual(fp_with_total.total, fp_with_total.asizeof_total) self.assertEqual(fp.total, fp.tracked_total) def test_desc(self): """Test snapshot label. """ self.tracker.create_snapshot() self.tracker.create_snapshot('alpha') self.tracker.create_snapshot(description='beta') self.tracker.create_snapshot(42) self.assertEqual(len(self.tracker.snapshots), 4) self.assertEqual(self.tracker.snapshots[0].desc, '') self.assertEqual(self.tracker.snapshots[1].desc, 'alpha') self.assertEqual(self.tracker.snapshots[2].desc, 'beta') self.assertEqual(self.tracker.snapshots[3].desc, '42') snapshot = self.tracker.snapshots[0] self.assertEqual(snapshot.label, '%.3fs' % snapshot.timestamp) snapshot = self.tracker.snapshots[1] self.assertEqual(snapshot.label, 'alpha (%.3fs)' % snapshot.timestamp) snapshot = self.tracker.snapshots[3] self.assertEqual(snapshot.label, '42 (%.3fs)' % snapshot.timestamp) def test_background_monitoring(self): """Test background monitoring. """ self.tracker.start_periodic_snapshots(0.1) self.assertEqual(self.tracker._periodic_thread.interval, 0.1) self.assertEqual(self.tracker._periodic_thread.getName(), 'BackgroundMonitor') for x in range(10): # try to interfere self.tracker.create_snapshot(str(x)) time.sleep(0.5) self.tracker.start_periodic_snapshots(0.2) self.assertEqual(self.tracker._periodic_thread.interval, 0.2) self.tracker.stop_periodic_snapshots() self.assert_(self.tracker._periodic_thread is None) self.assert_(len(self.tracker.snapshots) > 10)
from partfinder import main, subset, scheme, config from pympler.classtracker import ClassTracker tracker = ClassTracker() # Plug it in here.. scheme.tracker = tracker scheme.tracker = tracker tracker.track_class(subset.Subset) tracker.track_class(scheme.Scheme) tracker.create_snapshot() main.call_main("DNA", "--raxml examples/nucleotide --cmd ' -T 2'" ) # main.call_main("DNA", "--raxml Li_2008") tracker.create_snapshot() tracker.stats.print_summary()
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 setUp(self): self.tracker = ClassTracker()
self.mutable = list(range(10)) self.immutable = tuple(range(10)) def create_data(tracker, iterations=20, obj_per_iteration=100): objects = [] for x in range(iterations): for y in range(obj_per_iteration): objects.append(Alpha()) objects.append(Beta()) objects.append(Gamma()) tracker.create_snapshot() return objects tracker = ClassTracker() tracker.track_class(Alpha) tracker.track_class(Beta) tracker.track_class(Gamma, trace=True, resolution_level=2) print ("Create data") tracker.create_snapshot() data = create_data(tracker) print ("Drop data") del data tracker.create_snapshot() web.start_profiler(debug=True, stats=tracker.stats)
class SnapshotTestCase(unittest.TestCase): def setUp(self): self.tracker = ClassTracker() def tearDown(self): self.tracker.stop_periodic_snapshots() self.tracker.clear() def test_timestamp(self): """Test timestamp of snapshots. """ foo = Foo() bar = Bar() self.tracker.track_object(foo) self.tracker.track_object(bar) self.tracker.create_snapshot() self.tracker.create_snapshot() self.tracker.create_snapshot() refts = [fp.timestamp for fp in self.tracker.snapshots] for to in self.tracker.objects.values(): ts = [t for (t,sz) in to.snapshots[1:]] self.assertEqual(ts,refts) def test_snapshot_members(self): """Test existence and value of snapshot members. """ foo = Foo() self.tracker.track_object(foo) self.tracker.create_snapshot() self.tracker.create_snapshot(compute_total=True) fp = self.tracker.snapshots[0] fp_with_total = self.tracker.snapshots[1] self.assert_(fp.overhead > 0, fp.overhead) self.assert_(fp.tracked_total > 0, fp.tracked_total) self.assertEqual(fp.asizeof_total, 0) self.assert_(fp_with_total.asizeof_total > 0, fp_with_total.asizeof_total) self.assert_(fp_with_total.asizeof_total >= fp_with_total.tracked_total) if pympler.process.is_available(): procmem = fp.system_total self.assertEqual(fp.total, procmem.vsz) self.assert_(procmem.vsz > 0, procmem) self.assert_(procmem.rss > 0, procmem) self.assertTrue(procmem.vsz >= procmem.rss, procmem) self.assert_(procmem.vsz > fp.overhead, procmem) self.assert_(procmem.vsz > fp.tracked_total, procmem) self.assert_(fp_with_total.system_total.vsz > fp_with_total.asizeof_total) else: self.assertEqual(fp_with_total.total, fp_with_total.asizeof_total) self.assertEqual(fp.total, fp.tracked_total) def test_desc(self): """Test snapshot label. """ self.tracker.create_snapshot() self.tracker.create_snapshot('alpha') self.tracker.create_snapshot(description='beta') self.tracker.create_snapshot(42) self.assertEqual(len(self.tracker.snapshots), 4) self.assertEqual(self.tracker.snapshots[0].desc, '') self.assertEqual(self.tracker.snapshots[1].desc, 'alpha') self.assertEqual(self.tracker.snapshots[2].desc, 'beta') self.assertEqual(self.tracker.snapshots[3].desc, '42') snapshot = self.tracker.snapshots[0] self.assertEqual(snapshot.label, '%.3fs' % snapshot.timestamp) snapshot = self.tracker.snapshots[1] self.assertEqual(snapshot.label, 'alpha (%.3fs)' % snapshot.timestamp) snapshot = self.tracker.snapshots[3] self.assertEqual(snapshot.label, '42 (%.3fs)' % snapshot.timestamp) def test_background_monitoring(self): """Test background monitoring. """ self.tracker.start_periodic_snapshots(0.1) self.assertEqual(self.tracker._periodic_thread.interval, 0.1) self.assertEqual(self.tracker._periodic_thread.getName(), 'BackgroundMonitor') for x in range(10): # try to interfere self.tracker.create_snapshot(str(x)) time.sleep(0.5) self.tracker.start_periodic_snapshots(0.2) self.assertEqual(self.tracker._periodic_thread.interval, 0.2) self.tracker.stop_periodic_snapshots() self.assert_(self.tracker._periodic_thread is None) self.assert_(len(self.tracker.snapshots) > 10)
'''Test the all of the solver links''' from minpower import optimization, config from test_utils import * from coopr import pyomo mem_tracking=False if mem_tracking: from pympler.classtracker import ClassTracker from pympler.classtracker_stats import HtmlStats import objgraph tracker=ClassTracker() for cls in [pyomo.ConcreteModel,pyomo.Var,pyomo.base.var._VarElement,pyomo.Constraint,optimization.OptimizationProblem]: tracker.track_class(cls) def simple_problem(): prob=optimization.OptimizationProblem() if mem_tracking: tracker.create_snapshot('prob. init') prob.add_variable('x',low=0,high=3) prob.add_variable('y',low=0,high=1) x=prob.get_component('x') y=prob.get_component('y') prob.add_objective(y-4*x) prob.add_constraint('ineq',x+y<=2) if mem_tracking: tracker.create_snapshot('prob. created') return prob def run_one_solver(solver_name): prob=simple_problem() orig_solver = config.user_config.solver
class LogTestCase(unittest.TestCase): def setUp(self): self.out = StringIO() self.tracker = ClassTracker(stream=self.out) @property def output(self): """Return output recorded in `ClassTracker` output stream.""" return self.out.getvalue() def tearDown(self): self.tracker.stop_periodic_snapshots() self.tracker.clear() def test_dump(self): """Test serialization of log data. """ foo = Foo() foo.data = range(1000) bar = Bar() self.tracker.track_object(foo, resolution_level=4) self.tracker.track_object(bar) self.tracker.create_snapshot('Footest') f1 = StringIO() f2 = StringIO() ConsoleStats(tracker=self.tracker, stream=f1).print_stats() tmp = BytesIO() Stats(tracker=self.tracker).dump_stats(tmp, close=False) self.tracker.clear() stats = ConsoleStats(stream=f2) self.assertEqual(stats.index, None) self.assertEqual(stats.snapshots, None) tmp.seek(0) stats.load_stats(tmp) tmp.close() self.assert_('Foo' in stats.index) stats.print_stats() self.assertEqual(f1.getvalue(), f2.getvalue()) # Test partial printing stats.stream = f3 = StringIO() stats.sort_stats() tolen = len(stats.sorted) stats.print_stats(clsname='Bar') self.assertEqual(len(stats.sorted), tolen) stats.print_summary() clsname = f3.getvalue().split('\n')[0] self.assertNotEqual(re.search('Bar', clsname), None, clsname) f1.close() f2.close() f3.close() def test_sort_stats(self): """Test sort_stats and reverse_order. """ self.tracker.track_class(Bar, name='Bar') foo = Foo() foo.data = list(range(1000)) bar1 = Bar() bar2 = Bar() self.tracker.track_object(foo, resolution_level=4) self.tracker.create_snapshot() stats = self.tracker.stats # Test sort_stats and reverse_order self.assertEqual(stats.sort_stats('size'), stats) self.assertEqual(stats.sorted[0].classname, 'Foo') stats.reverse_order() self.assertEqual(stats.sorted[0].classname, 'Bar') stats.sort_stats('classname', 'birth') self.assertEqual(stats.sorted[0].classname, 'Bar') self.assertRaises(ValueError, stats.sort_stats, 'name', 42, 'classn') stats.sort_stats('classname') def test_dump_load_with_filename(self): """Test serialization with filename. """ foo = Foo() self.tracker.track_object(foo, resolution_level=2) self.tracker.create_snapshot() fhandle, fname = mkstemp(prefix='pympler_test_dump') os.close(fhandle) try: self.tracker.stats.dump_stats(fname) output = StringIO() stats = ConsoleStats(filename=fname, stream=output) stats.print_stats() self.assertTrue('<Foo>' in output.getvalue(), output.getvalue()) # Check if a Stats loaded from a dump can be dumped again stats.dump_stats(fname) finally: os.unlink(fname) def test_tracked_classes(self): """Test listing tracked classes. """ self.tracker.track_class(Foo, name='Foo') self.tracker.track_class(Bar, name='Bar') foo = Foo() self.tracker.create_snapshot() bar = Bar() self.tracker.create_snapshot() foo = FooNew() self.tracker.track_object(foo) self.tracker.create_snapshot() stats = self.tracker.stats self.assertEqual(stats.tracked_classes, ['Bar', 'Foo', 'FooNew']) stats.print_summary() def test_print_stats(self): """Test printing class-filtered statistics. """ self.tracker.track_class(Foo, name='Foo', trace=True) self.tracker.track_class(Bar, name='Bar') foo = Foo() bar = Bar() self.tracker.create_snapshot() stats = self.tracker.stats stats.print_stats(clsname='Foo') self.assertTrue('Foo' in self.output, self.output) self.assertFalse('Bar' in self.output, self.output) self.assertTrue('foo = Foo()' in self.output, self.output) def test_print_stats_limit(self): """Test printing limited statistics. """ self.tracker.track_class(Foo, name='Foo') foo = [Foo() for _ in range(10)] self.tracker.create_snapshot() stats = self.tracker.stats stats.print_stats(limit=3) self.assertEqual(self.output.count('<Foo>'), 3) self.out.seek(0) self.out.truncate() stats.print_stats(limit=0.5) self.assertEqual(self.output.count('<Foo>'), 5) def test_snapshots(self): """Test multiple snapshots. """ self.tracker.track_class(Foo, name='Foo') self.tracker.track_class(Bar, name='Bar') self.tracker.track_class(FooNew, name='FooNew') self.tracker.create_snapshot() f1 = Foo() self.tracker.create_snapshot() f2 = Foo() f3 = FooNew() self.tracker.create_snapshot() b = Bar() del b self.tracker.create_snapshot() stats = self.tracker.stats stats.print_stats() stats.print_summary() def test_merge(self): """Test merging of reference trees. """ self.tracker.track_class(FooNew, name='Foo', resolution_level=2) f1 = FooNew() f1.a = list(range(1000)) f2 = FooNew() f2.a = list(range(100)) f2.b = 'This is some stupid spam.' self.tracker.create_snapshot('Merge test') sizer = Asizer() sz1 = sizer.asized(f1) sz2 = sizer.asized(f2) stats = self.tracker.stats for fp in stats.snapshots: if fp.desc == 'Merge test': stats.annotate_snapshot(fp) self.assert_(hasattr(fp, 'classes')) classes = fp.classes stats.annotate_snapshot(fp) self.assertEqual(fp.classes, classes) self.assert_('Foo' in fp.classes, fp.classes) self.assert_('merged' in fp.classes['Foo']) fm = fp.classes['Foo']['merged'] self.assertEqual(fm.size, sz1.size + sz2.size, (fm.size, str(sz1), str(sz2))) refs = {} for ref in fm.refs: refs[ref.name] = ref self.assert_('__dict__' in refs.keys(), refs.keys()) refs2 = {} for ref in refs['__dict__'].refs: refs2[ref.name] = ref self.assert_('[V] a' in refs2.keys(), refs2.keys()) self.assert_('[V] b' in refs2.keys(), refs2.keys()) self.assertEqual(refs2['[V] a'].size, asizeof(f1.a, f2.a)) def test_html(self): """Test emitting HTML statistics.""" self.tracker.track_class(Foo, name='Foo', resolution_level=2) self.tracker.track_class(Bar, name='Bar', trace=True) f1 = Foo() f1.a = list(range(100000)) f2 = Foo() f2.a = list(range(1000)) f2.b = 'This is some stupid spam.' f1 = Bar() self.tracker.create_snapshot('Merge test') stats = HtmlStats(tracker=self.tracker) try: target = mkdtemp(prefix='pympler_test') output = os.path.join(target, 'footest.html') stats.create_html(output) source = open(output).read() # Ensure relative links are used fname = os.path.join('footest_files', 'Foo.html') self.assertTrue('<a href="%s">' % fname in source, (fname, source)) finally: rmtree(target) def test_charts(self): """Test emitting graphic charts.""" self.tracker.track_class(Foo, name='Foo', resolution_level=2) f1 = Foo() f1.a = list(range(1000)) f2 = Foo() f2.a = list(range(100)) f2.b = 'This is some stupid spam.' self.tracker.create_snapshot('Merge test') from pympler import charts try: target = mkdtemp(prefix='pympler_test') output = os.path.join(target, 'timespace.png') charts.tracker_timespace(output, self.tracker.stats) finally: rmtree(target)
def enable_instrumentation(self): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls)
def process_request(self, request): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) self._tracker.create_snapshot('before') self.record_stats({'before': ProcessMemoryInfo()})
class MemoryPanel(Panel): name = 'pympler' title = 'Memory' template = 'memory_panel.html' classes = [Context, Template] def process_request(self, request): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) self._tracker.create_snapshot('before') self.record_stats({'before': ProcessMemoryInfo()}) def process_response(self, request, response): self.record_stats({'after': ProcessMemoryInfo()}) self._tracker.create_snapshot('after') stats = self._tracker.stats stats.annotate() self.record_stats({'stats': stats}) def enable_instrumentation(self): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) def disable_instrumentation(self): self._tracker.detach_all_classes() def nav_subtitle(self): context = self.get_stats() before = context['before'] after = context['after'] rss = after.rss delta = rss - before.rss delta = ('(+%s)' % pp(delta)) if delta > 0 else '' return "%s %s" % (pp(rss), delta) @property def content(self): context = self.get_stats() before = context['before'] after = context['after'] stats = context['stats'] rows = [ ('Resident set size', after.rss), ('Virtual size', after.vsz), ] rows.extend(after - before) rows = [(key, pp(value)) for key, value in rows] rows.extend(after.os_specific) classes = [] snapshot = stats.snapshots[-1] for model in stats.tracked_classes: history = [cnt for _, cnt in stats.history[model]] size = snapshot.classes.get(model, {}).get('sum', 0) if history and history[-1] > 0: classes.append((model, history, pp(size))) context.update({'rows': rows, 'classes': classes}) return render_to_string(self.template, context)
def create_data(tracker, iterations=100, obj_per_iteration=100): objects = [] for j, x in enumerate(list(range(iterations))): # Generate a waypoint list wplist = WaypointList("WPL #%i" % j) for i, y in enumerate(list(range(obj_per_iteration))): wp = Waypoint("Point %i" % i, "%3.5fN" % (52.3 + (random() * 2 - 1)), "%3.5fE" % (52.3 + (random() * 2 -1))) wplist.append(wp) objects.append(wplist) # tracker.create_snapshot() return objects tracker = ClassTracker() tracker.track_class(Waypoint) tracker.track_class(WaypointList) #tracker.track_class(Gamma, trace=True, resolution_level=2) print ("Create data") tracker.create_snapshot() data = create_data(tracker) print(data) print ("Drop data") for item in data: del item del data tracker.create_snapshot()
class TrackObjectTestCase(unittest.TestCase): def setUp(self): self.tracker = ClassTracker() def tearDown(self): self.tracker.detach_all() def test_track_object(self): """Test object registration. """ foo = Foo() bar = Bar() self.tracker.track_object(foo) self.tracker.track_object(bar) self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) self.assert_('Foo' in self.tracker.index) self.assert_('Bar' in self.tracker.index) self.assertEqual(self.tracker.objects[id(foo)].ref(),foo) self.assertEqual(self.tracker.objects[id(bar)].ref(),bar) def test_type_errors(self): """Test intrackable objects. """ i = 42 j = 'Foobar' k = [i,j] l = {i: j} self.assertRaises(TypeError, self.tracker.track_object, i) self.assertRaises(TypeError, self.tracker.track_object, j) self.assertRaises(TypeError, self.tracker.track_object, k) self.assertRaises(TypeError, self.tracker.track_object, l) self.assert_(id(i) not in self.tracker.objects) self.assert_(id(j) not in self.tracker.objects) self.assert_(id(k) not in self.tracker.objects) self.assert_(id(l) not in self.tracker.objects) def test_track_by_name(self): """Test registering objects by name. """ foo = Foo() self.tracker.track_object(foo, name='Foobar') self.assert_('Foobar' in self.tracker.index ) self.assertEqual(self.tracker.index['Foobar'][0].ref(),foo) def test_keep(self): """Test lifetime of tracked objects. """ foo = Foo() bar = Bar() self.tracker.track_object(foo, keep=1) self.tracker.track_object(bar) idfoo = id(foo) idbar = id(bar) del foo del bar self.assert_(self.tracker.objects[idfoo].ref() is not None) self.assert_(self.tracker.objects[idbar].ref() is None) def test_mixed_tracking(self): """Test mixed instance and class tracking. """ foo = Foo() self.tracker.track_object(foo) self.tracker.create_snapshot() self.tracker.track_class(Foo) objs = [] for _ in range(10): objs.append(Foo()) self.tracker.create_snapshot() def test_recurse(self): """Test recursive sizing and saving of referents. """ foo = Foo() self.tracker.track_object(foo, resolution_level=1) self.tracker.create_snapshot() fp = self.tracker.objects[id(foo)].snapshots[-1] refs = fp[1].refs dref = [r for r in refs if r.name == '__dict__'] self.assertEqual(len(dref),1) dref = dref[0] self.assert_(dref.size > 0, dref.size) self.assert_(dref.flat > 0, dref.flat) self.assertEqual(dref.refs,()) # Test track_change and more fine-grained resolution self.tracker.track_change(foo, resolution_level=2) self.tracker.create_snapshot() fp = self.tracker.objects[id(foo)].snapshots[-1] refs = fp[1].refs dref = [r for r in refs if r.name == '__dict__'] self.assertEqual(len(dref),1) dref = dref[0] namerefs = [r.name for r in dref.refs] self.assert_('[K] foo' in namerefs, namerefs) self.assert_("[V] foo: 'foo'" in namerefs, namerefs)
'''Test the all of the solver links''' from minpower import optimization, config from test_utils import * from coopr import pyomo mem_tracking = False if mem_tracking: from pympler.classtracker import ClassTracker from pympler.classtracker_stats import HtmlStats import objgraph tracker = ClassTracker() for cls in [ pyomo.ConcreteModel, pyomo.Var, pyomo.base.var._VarElement, pyomo.Constraint, optimization.OptimizationProblem ]: tracker.track_class(cls) def simple_problem(): prob = optimization.OptimizationProblem() if mem_tracking: tracker.create_snapshot('prob. init') prob.add_variable('x', low=0, high=3) prob.add_variable('y', low=0, high=1) x = prob.get_component('x') y = prob.get_component('y') prob.add_objective(y - 4 * x) prob.add_constraint('ineq', x + y <= 2) if mem_tracking: tracker.create_snapshot('prob. created') return prob
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 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 setUp(self): self.out = StringIO() self.tracker = ClassTracker(stream=self.out)
import os import warnings import bisect from pytmatrix import tmatrix, psd, refractive, radar from pytmatrix import tmatrix_aux as tm_aux # general configuration DEBUG = False locale.setlocale(locale.LC_ALL, 'C') if DEBUG: from memprof import * from pympler.classtracker import ClassTracker tracker = ClassTracker() warnings.simplefilter('default') warnings.simplefilter('error', category=FutureWarning) else: warnings.simplefilter('ignore') TAU = 2*np.pi RHO_W = 1000 def ordinal(n): if 10 <= n % 100 < 20: return str(n) + 'th' else: return str(n) + {1 : 'st', 2 : 'nd', 3 : 'rd'}.get(n % 10, "th")
class MemoryPanel(Panel): name = 'pympler' title = 'Memory' template = 'memory_panel.html' classes = [Context, Template] def process_request(self, request): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) self._tracker.create_snapshot('before') self.record_stats({'before': ProcessMemoryInfo()}) def process_response(self, request, response): self.record_stats({'after': ProcessMemoryInfo()}) self._tracker.create_snapshot('after') stats = self._tracker.stats stats.annotate() self.record_stats({'stats': stats}) def enable_instrumentation(self): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) def disable_instrumentation(self): self._tracker.detach_all_classes() def nav_subtitle(self): context = self.get_stats() before = context['before'] after = context['after'] rss = after.rss delta = rss - before.rss delta = ('(+%s)' % pp(delta)) if delta > 0 else '' return "%s %s" % (pp(rss), delta) @property def content(self): context = self.get_stats() before = context['before'] after = context['after'] stats = context['stats'] rows = [('Resident set size', after.rss), ('Virtual size', after.vsz), ] rows.extend(after - before) rows = [(key, pp(value)) for key, value in rows] rows.extend(after.os_specific) classes = [] snapshot = stats.snapshots[-1] for model in stats.tracked_classes: history = [cnt for _, cnt in stats.history[model]] size = snapshot.classes.get(model, {}).get('sum', 0) if cnt > 0: classes.append((model, history, pp(size))) context.update({'rows': rows, 'classes': classes}) return render_to_string(self.template, context)
class TrackClassTestCase(unittest.TestCase): def setUp(self): self.tracker = ClassTracker() def tearDown(self): self.tracker.stop_periodic_snapshots() self.tracker.clear() def test_type_errors(self): """Test invalid parameters for class tracking. """ i = 42 j = 'Foobar' k = [i,j] l = {i: j} foo = Foo() bar = Bar() self.assertRaises(TypeError, self.tracker.track_class, i) self.assertRaises(TypeError, self.tracker.track_class, j) self.assertRaises(TypeError, self.tracker.track_class, k) self.assertRaises(TypeError, self.tracker.track_class, l) self.assertRaises(TypeError, self.tracker.track_class, foo) self.assertRaises(TypeError, self.tracker.track_class, bar) self.assert_(id(i) not in self.tracker.objects) self.assert_(id(j) not in self.tracker.objects) self.assert_(id(k) not in self.tracker.objects) self.assert_(id(l) not in self.tracker.objects) def test_track_class(self): """Test tracking objects through classes. """ self.tracker.track_class(Foo) self.tracker.track_class(Bar) self.tracker.track_class(Empty) self.tracker.track_class(Foo) foo = Foo() bar = Bar() empty = Empty() self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) self.assert_(id(empty) in self.tracker.objects) def test_track_class_new(self): """Test tracking new style classes. """ self.tracker.track_class(FooNew) self.tracker.track_class(BarNew) foo = FooNew() bar = BarNew() self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) def test_track_by_name(self): """Test registering objects by name. """ self.tracker.track_class(Foo, name='Foobar') foo = Foo() self.assert_('Foobar' in self.tracker.index ) self.assertEqual(self.tracker.index['Foobar'][0].ref(),foo) def test_keep(self): """Test lifetime of tracked objects. """ self.tracker.track_class(Foo, keep=1) self.tracker.track_class(Bar) foo = Foo() bar = Bar() idfoo = id(foo) idbar = id(bar) del foo del bar self.assert_(self.tracker.objects[idfoo].ref() is not None) self.assert_(self.tracker.objects[idbar].ref() is None) def test_class_history(self): """Test instance history of tracked class. """ self.tracker.track_class(Foo, name='Foo') f1 = Foo() f2 = Foo() f3 = Foo() del f1 del f2 f4 = Foo() del f3 del f4 instances = [cnt for _, cnt in self.tracker.history['Foo']] self.assertEqual(instances, [1, 2, 3, 2, 1, 2, 1, 0]) def test_trace(self): """Test instantiation tracing of tracked objects. """ from inspect import stack self.tracker.track_class(Foo, trace=True) self.tracker.track_class(BarNew, trace=True) foo = Foo() bar = BarNew() idfoo = id(foo) idbar = id(bar) trace = [] st = stack() try: for fr in st: trace.insert(0, fr[1:]) finally: del st self.assertEqual(self.tracker.objects[idfoo].trace[-1][3][0].strip(),"foo = Foo()") self.assertEqual(self.tracker.objects[idfoo].trace[:-1],trace[:-1], trace) self.assertEqual(self.tracker.objects[idbar].trace[:-1],trace[:-1], trace) def test_detach(self): """Test detaching from tracked classes. """ self.tracker.track_class(Foo) self.tracker.track_class(Bar) foo = Foo() bar = Bar() self.assert_(id(foo) in self.tracker.objects) self.assert_(id(bar) in self.tracker.objects) self.tracker.detach_class(Foo) self.tracker.detach_class(Bar) foo2 = Foo() bar2 = Bar() self.assert_(id(foo2) not in self.tracker.objects) self.assert_(id(bar2) not in self.tracker.objects) self.assertRaises(KeyError, self.tracker.detach_class, Foo) def test_change_name(self): """Test modifying name. """ self.tracker.track_class(Foo, name='Foobar') self.tracker.track_class(Foo, name='Baz') foo = Foo() self.assert_('Foobar' not in self.tracker.index) self.assert_('Baz' in self.tracker.index) self.assertEqual(self.tracker.index['Baz'][0].ref(),foo)
def __init__(self, cls): from pympler.classtracker import ClassTracker tracker = ClassTracker() tracker.track_class(cls) self.tracker = tracker
def process_request(self, request): self._tracker = ClassTracker() for cls in get_models() + self.classes: self._tracker.track_class(cls) self._tracker.create_snapshot('before') self._before = ProcessMemoryInfo()
from partfinder import main, subset, scheme, config from pympler.classtracker import ClassTracker tracker = ClassTracker() # Plug it in here.. scheme.tracker = tracker scheme.tracker = tracker tracker.track_class(subset.Subset) tracker.track_class(scheme.Scheme) tracker.create_snapshot() main.call_main("DNA", "--raxml examples/nucleotide --cmd ' -T 2'") # main.call_main("DNA", "--raxml Li_2008") tracker.create_snapshot() tracker.stats.print_summary()