| | ''' |
| | Logging service for tracking dr tree changes from root objective |
| | and record every step that incrementally changes the dr tree |
| | |
| | ''' |
| | import os, sys, time |
| | import json |
| | import psutil |
| |
|
| | import scipy.sparse as sp |
| | import numpy as np |
| | from . import reordering |
| |
|
| | _TWO_20 = float(2 **20) |
| |
|
| | ''' |
| | memory utils |
| | |
| | ''' |
| | def pdb_mem(): |
| | from .monitor import get_current_memory |
| | mem = get_current_memory() |
| | if mem > 7000: |
| | import pdb;pdb.set_trace() |
| |
|
| | def get_peak_mem(): |
| | ''' |
| | this returns peak memory use since process starts till the moment its called |
| | ''' |
| | import resource |
| | rusage_denom = 1024. |
| | if sys.platform == 'darwin': |
| | |
| | rusage_denom = rusage_denom * rusage_denom |
| | mem = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / rusage_denom |
| | return mem |
| |
|
| | def get_current_memory(): |
| | p = psutil.Process(os.getpid()) |
| | mem = p.memory_info()[0]/_TWO_20 |
| |
|
| | return mem |
| |
|
| | ''' |
| | Helper for Profiler |
| | ''' |
| |
|
| | def build_cache_info(k, v, info_dict): |
| | if v is not None: |
| | issparse = sp.issparse(v) |
| | size = v.size |
| | if issparse: |
| | nonzero = len(v.data) |
| | else: |
| | nonzero = np.count_nonzero(v) |
| | info_dict[k.short_name] = { |
| | 'sparse': issparse, |
| | 'size' : str(size), |
| | 'nonzero' : nonzero, |
| | } |
| |
|
| |
|
| | def cache_info(ch_node): |
| | result = {} |
| | if isinstance(ch_node, reordering.Concatenate) and hasattr(ch_node, 'dr_cached') and len(ch_node.dr_cached) > 0: |
| | for k, v in ch_node.dr_cached.items(): |
| | build_cache_info(k, v, result) |
| | elif len(ch_node._cache['drs']) > 0: |
| | for k, v in ch_node._cache['drs'].items(): |
| | build_cache_info(k, v, result) |
| |
|
| | return result |
| |
|
| | class DrWrtProfiler(object): |
| | base_path = os.path.abspath('profiles') |
| | |
| | def __init__(self, root, base_path=None): |
| | self.root = root.obj |
| | self.history = [] |
| |
|
| | ts = time.time() |
| | if base_path: |
| | self.base_path = base_path |
| | |
| | self.path = os.path.join(self.base_path, 'profile_%s.json' % str(ts)) |
| | self.root_path = os.path.join(self.base_path, 'root_%s.json' % str(ts)) |
| |
|
| | |
| | with open(self.root_path, 'w') as f: |
| | json.dump(self.dump_tree(self.root), f, indent=4) |
| |
|
| | def dump_tree(self, node): |
| | if not hasattr(node, 'dterms'): |
| | return [] |
| |
|
| | node_dict = self.serialize_node(node, verbose=False) |
| | if hasattr(node, 'visited') and node.visited: |
| | node_dict.update({'indirect':True}) |
| | return node_dict |
| |
|
| | node.visited = True |
| | children_list = [] |
| | for dterm in node.dterms: |
| | if hasattr(node, dterm): |
| | child = getattr(node, dterm) |
| | if hasattr(child, 'dterms') or hasattr(child, 'terms'): |
| | children_list.append(self.dump_tree(child)) |
| | node_dict.update({'children':children_list}) |
| | return node_dict |
| |
|
| | def serialize_node(self, ch_node, verbose=True): |
| | node_id = id(ch_node) |
| | name = ch_node.short_name |
| | ts = time.time() |
| | status = ch_node._status |
| | mem = get_current_memory() |
| | node_cache_info = cache_info(ch_node) |
| |
|
| | rec = { |
| | 'id': str(node_id), |
| | 'indirect' : False, |
| | } |
| | if verbose: |
| | rec.update({ |
| | 'name':name, |
| | 'ts' : ts, |
| | 'status':status, |
| | 'mem': mem, |
| | 'cache': node_cache_info, |
| | }) |
| | return rec |
| |
|
| | def show_tree(self, label): |
| | ''' |
| | show tree from the root node |
| | ''' |
| | self.root.show_tree_cache(label) |
| |
|
| | def record(self, ch_node): |
| | ''' |
| | Incremental changes |
| | ''' |
| | rec = self.serialize_node(ch_node) |
| | self.history.append(rec) |
| |
|
| | def harvest(self): |
| | print('collecting and dump to file %s' % self.path) |
| | with open(self.path, 'w') as f: |
| | json.dump(self.history, f, indent=4) |
