visualize_heap_map.Parser Class Reference

Public Member Functions
	__init__ (self, str path)
list[Dump]	parse (self)
list[tuple[Dump, Dump]]	lock_pairs (self)

Data Fields
	path
	dumps = path, []

Static Public Attributes
dict	RE

Protected Member Functions
	_stats (self, str line, Dump d)
	_finalize (self, Dump d, list free_l, list alloc_l)
int	_unlocked (self, list lines, int start, Dump d)

Constructor & Destructor Documentation

__init__()

visualize_heap_map.Parser.__init__	(		self,
		str	path )

Member Function Documentation

parse()

list[Dump] visualize_heap_map.Parser.parse

(

self

)

_stats()

visualize_heap_map.Parser._stats ( self, str line, Dump d )

protected

_finalize()

visualize_heap_map.Parser._finalize ( self, Dump d, list free_l, list alloc_l )

protected

_unlocked()

int visualize_heap_map.Parser._unlocked ( self, list lines, int start, Dump d )

protected

lock_pairs()

list[tuple[Dump, Dump]] visualize_heap_map.Parser.lock_pairs

(

self

)

Field Documentation

RE

dict visualize_heap_map.Parser.RE

static

Initial value:

=  {
        'fail': re.compile(r'fail to allocate (\d+) bytes with (\d+) alignment', re.I),
        'total': re.compile(r'Total heap size: (\d+) bytes'),
        'used': re.compile(r'Used size: (\d+) bytes'),
        'free': re.compile(r'Free size: (\d+) bytes'),
        'mcb': re.compile(r'MCB size: (\d+) bytes(?:, align: (\d+) bytes)?'),
        'free_blk': re.compile(r'Free block: MCB=0x([0-9a-fA-F]+), buffer=0x([0-9a-fA-F]+), usable_size=(\d+) bytes'
                               r'(?:, caller=0x([0-9a-fA-F]+), idx=(\d+))?'),
        'alloc': re.compile(r'Allocated: MCB=0x([0-9a-fA-F]+), buffer_start=0x([0-9a-fA-F]+), '
                           r'max_size=(\d+) bytes, caller=0x([0-9a-fA-F]+), idx=(\d+), freed=(\d+)'),
        'locked': re.compile(r'heap locked on index (\d+)'),
        'unlocked': re.compile(r'heap unlocked on index (\d+)'),
    }

path

visualize_heap_map.Parser.path

dumps

visualize_heap_map.Parser.dumps = path, []