| # Copyright (c) 2013 ARM Limited |
| # All rights reserved |
| # |
| # The license below extends only to copyright in the software and shall |
| # not be construed as granting a license to any other intellectual |
| # property including but not limited to intellectual property relating |
| # to a hardware implementation of the functionality of the software |
| # licensed hereunder. You may use the software subject to the license |
| # terms below provided that you ensure that this notice is replicated |
| # unmodified and in its entirety in all distributions of the software, |
| # modified or unmodified, in source code or in binary form. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer; |
| # redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution; |
| # neither the name of the copyright holders nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| # Authors: Andrew Bardsley |
| |
| import parse |
| import colours |
| from colours import unknownColour |
| from point import Point |
| import re |
| import blobs |
| from time import time as wall_time |
| import os |
| |
| id_parts = "TSPLFE" |
| |
| all_ids = set(id_parts) |
| no_ids = set([]) |
| |
| class BlobDataSelect(object): |
| """Represents which data is displayed for Ided object""" |
| def __init__(self): |
| # Copy all_ids |
| self.ids = set(all_ids) |
| |
| def __and__(self, rhs): |
| """And for filtering""" |
| ret = BlobDataSelect() |
| ret.ids = self.ids.intersection(rhs.ids) |
| return ret |
| |
| class BlobVisualData(object): |
| """Super class for block data colouring""" |
| def to_striped_block(self, select): |
| """Return an array of colours to use for a striped block""" |
| return unknownColour |
| |
| def get_inst(self): |
| """Get an instruction Id (if any) from this data""" |
| return None |
| |
| def get_line(self): |
| """Get a line Id (if any) from this data""" |
| return None |
| |
| def __repr__(self): |
| return self.__class__.__name__ + '().from_string(' + \ |
| self.__str__() + ')' |
| |
| def __str__(self): |
| return '' |
| |
| class Id(BlobVisualData): |
| """A line or instruction id""" |
| def __init__(self): |
| self.isFault = False |
| self.threadId = 0 |
| self.streamSeqNum = 0 |
| self.predictionSeqNum = 0 |
| self.lineSeqNum = 0 |
| self.fetchSeqNum = 0 |
| self.execSeqNum = 0 |
| |
| def as_list(self): |
| return [self.threadId, self.streamSeqNum, self.predictionSeqNum, |
| self.lineSeqNum, self.fetchSeqNum, self.execSeqNum] |
| |
| def __cmp__(self, right): |
| return cmp(self.as_list(), right.as_list()) |
| |
| def from_string(self, string): |
| m = re.match('^(F;)?(\d+)/(\d+)\.(\d+)/(\d+)(/(\d+)(\.(\d+))?)?', |
| string) |
| |
| def seqnum_from_string(string): |
| if string is None: |
| return 0 |
| else: |
| return int(string) |
| |
| if m is None: |
| print 'Invalid Id string', string |
| else: |
| elems = m.groups() |
| |
| if elems[0] is not None: |
| self.isFault = True |
| else: |
| self.isFault = False |
| |
| self.threadId = seqnum_from_string(elems[1]) |
| self.streamSeqNum = seqnum_from_string(elems[2]) |
| self.predictionSeqNum = seqnum_from_string(elems[3]) |
| self.lineSeqNum = seqnum_from_string(elems[4]) |
| self.fetchSeqNum = seqnum_from_string(elems[6]) |
| self.execSeqNum = seqnum_from_string(elems[8]) |
| return self |
| |
| def get_inst(self): |
| if self.fetchSeqNum != 0: |
| return self |
| else: |
| return None |
| |
| def get_line(self): |
| return self |
| |
| def __str__(self): |
| """Returns the usual id T/S.P/L/F.E string""" |
| return ( |
| str(self.threadId) + '/' + |
| str(self.streamSeqNum) + '.' + |
| str(self.predictionSeqNum) + '/' + |
| str(self.lineSeqNum) + '/' + |
| str(self.fetchSeqNum) + '.' + |
| str(self.execSeqNum)) |
| |
| def to_striped_block(self, select): |
| ret = [] |
| |
| if self.isFault: |
| ret.append(colours.faultColour) |
| |
| if 'T' in select.ids: |
| ret.append(colours.number_to_colour(self.threadId)) |
| if 'S' in select.ids: |
| ret.append(colours.number_to_colour(self.streamSeqNum)) |
| if 'P' in select.ids: |
| ret.append(colours.number_to_colour(self.predictionSeqNum)) |
| if 'L' in select.ids: |
| ret.append(colours.number_to_colour(self.lineSeqNum)) |
| if self.fetchSeqNum != 0 and 'F' in select.ids: |
| ret.append(colours.number_to_colour(self.fetchSeqNum)) |
| if self.execSeqNum != 0 and 'E' in select.ids: |
| ret.append(colours.number_to_colour(self.execSeqNum)) |
| |
| if len(ret) == 0: |
| ret = [colours.unknownColour] |
| |
| if self.isFault: |
| ret.append(colours.faultColour) |
| |
| return ret |
| |
| class Branch(BlobVisualData): |
| """Branch data new stream and prediction sequence numbers, a branch |
| reason and a new PC""" |
| def __init__(self): |
| self.newStreamSeqNum = 0 |
| self.newPredictionSeqNum = 0 |
| self.newPC = 0 |
| self.reason = "NoBranch" |
| self.id = Id() |
| |
| def from_string(self, string): |
| m = re.match('^(\w+);(\d+)\.(\d+);([0-9a-fA-Fx]+);(.*)$', string) |
| |
| if m is not None: |
| self.reason, newStreamSeqNum, newPredictionSeqNum, \ |
| newPC, id = m.groups() |
| |
| self.newStreamSeqNum = int(newStreamSeqNum) |
| self.newPredictionSeqNum = int(newPredictionSeqNum) |
| self.newPC = int(newPC, 0) |
| self.id = special_view_decoder(Id)(id) |
| # self.branch = special_view_decoder(Branch)(branch) |
| else: |
| print "Bad Branch data:", string |
| return self |
| |
| def to_striped_block(self, select): |
| return [colours.number_to_colour(self.newStreamSeqNum), |
| colours.number_to_colour(self.newPredictionSeqNum), |
| colours.number_to_colour(self.newPC)] |
| |
| class Counts(BlobVisualData): |
| """Treat the input data as just a /-separated list of count values (or |
| just a single value)""" |
| def __init__(self): |
| self.counts = [] |
| |
| def from_string(self, string): |
| self.counts = map(int, re.split('/', string)) |
| return self |
| |
| def to_striped_block(self, select): |
| return map(colours.number_to_colour, self.counts) |
| |
| class Colour(BlobVisualData): |
| """A fixed colour block, used for special colour decoding""" |
| def __init__(self, colour): |
| self.colour = colour |
| |
| def to_striped_block(self, select): |
| return [self.colour] |
| |
| class DcacheAccess(BlobVisualData): |
| """Data cache accesses [RW];id""" |
| def __init__(self): |
| self.direc = 'R' |
| self.id = Id() |
| |
| def from_string(self, string): |
| self.direc, id = re.match('^([RW]);([^;]*);.*$', string).groups() |
| self.id.from_string(id) |
| return self |
| |
| def get_inst(self): |
| return self.id |
| |
| def to_striped_block(self, select): |
| if self.direc == 'R': |
| direc_colour = colours.readColour |
| elif self.direc == 'R': |
| direc_colour = colours.writeColour |
| else: |
| direc_colour = colours.errorColour |
| return [direc_colour] + self.id.to_striped_block(select) |
| |
| class ColourPattern(object): |
| """Super class for decoders that make 2D grids rather than just single |
| striped blocks""" |
| def elems(self): |
| return [] |
| |
| def to_striped_block(self, select): |
| return [[[colours.errorColour]]] |
| |
| def special_view_decoder(class_): |
| """Generate a decode function that checks for special character |
| arguments first (and generates a fixed colour) before building a |
| BlobVisualData of the given class""" |
| def decode(symbol): |
| if symbol in special_state_colours: |
| return Colour(special_state_colours[symbol]) |
| else: |
| return class_().from_string(symbol) |
| return decode |
| |
| class TwoDColours(ColourPattern): |
| """A 2D grid pattern decoder""" |
| def __init__(self, blockss): |
| self.blockss = blockss |
| |
| @classmethod |
| def decoder(class_, elemClass, dataName): |
| """Factory for making decoders for particular block types""" |
| def decode(pairs): |
| if dataName not in pairs: |
| print 'TwoDColours: no event data called:', \ |
| dataName, 'in:', pairs |
| return class_([[Colour(colours.errorColour)]]) |
| else: |
| parsed = parse.list_parser(pairs[dataName]) |
| return class_(parse.map2(special_view_decoder(elemClass), \ |
| parsed)) |
| return decode |
| |
| @classmethod |
| def indexed_decoder(class_, elemClass, dataName, picPairs): |
| """Factory for making decoders for particular block types but |
| where the list elements are pairs of (index, data) and |
| strip and stripelems counts are picked up from the pair |
| data on the decoder's picture file. This gives a 2D layout |
| of the values with index 0 at strip=0, elem=0 and index 1 |
| at strip=0, elem=1""" |
| def decode(pairs): |
| if dataName not in pairs: |
| print 'TwoDColours: no event data called:', \ |
| dataName, 'in:', pairs |
| return class_([[Colour(colours.errorColour)]]) |
| else: |
| strips = int(picPairs['strips']) |
| strip_elems = int(picPairs['stripelems']) |
| |
| raw_iv_pairs = pairs[dataName] |
| |
| parsed = parse.parse_indexed_list(raw_iv_pairs) |
| |
| array = [[Colour(colours.emptySlotColour) |
| for i in xrange(0, strip_elems)] |
| for j in xrange(0, strips)] |
| |
| for index, value in parsed: |
| try: |
| array[index % strips][index / strips] = \ |
| special_view_decoder(elemClass)(value) |
| except: |
| print "Element out of range strips: %d," \ |
| " stripelems %d, index: %d" % (strips, |
| strip_elems, index) |
| |
| # return class_(array) |
| return class_(array) |
| return decode |
| |
| def elems(self): |
| """Get a flat list of all elements""" |
| ret = [] |
| for blocks in self.blockss: |
| ret += blocks |
| return ret |
| |
| def to_striped_block(self, select): |
| return parse.map2(lambda d: d.to_striped_block(select), self.blockss) |
| |
| class FrameColours(ColourPattern): |
| """Decode to a 2D grid which has a single occupied row from the event |
| data and some blank rows forming a frame with the occupied row as a |
| 'title' coloured stripe""" |
| def __init__(self, block, numBlankSlots): |
| self.numBlankSlots = numBlankSlots |
| self.block = block |
| |
| @classmethod |
| def decoder(class_, elemClass, numBlankSlots, dataName): |
| """Factory for element type""" |
| def decode(pairs): |
| if dataName not in pairs: |
| print 'FrameColours: no event data called:', dataName, \ |
| 'in:', pairs |
| return class_([Colour(colours.errorColour)]) |
| else: |
| parsed = parse.list_parser(pairs[dataName]) |
| return class_(special_view_decoder(elemClass) |
| (parsed[0][0]), numBlankSlots) |
| return decode |
| |
| def elems(self): |
| return [self.block] |
| |
| def to_striped_block(self, select): |
| return ([[self.block.to_striped_block(select)]] + |
| (self.numBlankSlots * [[[colours.backgroundColour]]])) |
| |
| special_state_colours = { |
| 'U': colours.unknownColour, |
| 'B': colours.blockedColour, |
| '-': colours.bubbleColour, |
| '': colours.emptySlotColour, |
| 'E': colours.emptySlotColour, |
| 'R': colours.reservedSlotColour, |
| 'X': colours.errorColour, |
| 'F': colours.faultColour, |
| 'r': colours.readColour, |
| 'w': colours.writeColour |
| } |
| |
| special_state_names = { |
| 'U': '(U)nknown', |
| 'B': '(B)locked', |
| '-': '(-)Bubble', |
| '': '()Empty', |
| 'E': '(E)mpty', |
| 'R': '(R)eserved', |
| 'X': '(X)Error', |
| 'F': '(F)ault', |
| 'r': '(r)ead', |
| 'w': '(w)rite' |
| } |
| |
| special_state_chars = special_state_colours.keys() |
| |
| # The complete set of available block data types |
| decoder_element_classes = { |
| 'insts': Id, |
| 'lines': Id, |
| 'branch': Branch, |
| 'dcache': DcacheAccess, |
| 'counts': Counts |
| } |
| |
| indexed_decoder_element_classes = { |
| 'indexedCounts' : Counts |
| } |
| |
| def find_colour_decoder(stripSpace, decoderName, dataName, picPairs): |
| """Make a colour decoder from some picture file blob attributes""" |
| if decoderName == 'frame': |
| return FrameColours.decoder(Counts, stripSpace, dataName) |
| elif decoderName in decoder_element_classes: |
| return TwoDColours.decoder(decoder_element_classes[decoderName], |
| dataName) |
| elif decoderName in indexed_decoder_element_classes: |
| return TwoDColours.indexed_decoder( |
| indexed_decoder_element_classes[decoderName], dataName, picPairs) |
| else: |
| return None |
| |
| class IdedObj(object): |
| """An object identified by an Id carrying paired data. |
| The super class for Inst and Line""" |
| |
| def __init__(self, id, pairs={}): |
| self.id = id |
| self.pairs = pairs |
| |
| def __cmp__(self, right): |
| return cmp(self.id, right.id) |
| |
| def table_line(self): |
| """Represent the object as a list of table row data""" |
| return [] |
| |
| # FIXME, add a table column titles? |
| |
| def __repr__(self): |
| return ' '.join(self.table_line()) |
| |
| class Inst(IdedObj): |
| """A non-fault instruction""" |
| def __init__(self, id, disassembly, addr, pairs={}): |
| super(Inst,self).__init__(id, pairs) |
| if 'nextAddr' in pairs: |
| self.nextAddr = int(pairs['nextAddr'], 0) |
| del pairs['nextAddr'] |
| else: |
| self.nextAddr = None |
| self.disassembly = disassembly |
| self.addr = addr |
| |
| def table_line(self): |
| if self.nextAddr is not None: |
| addrStr = '0x%x->0x%x' % (self.addr, self.nextAddr) |
| else: |
| addrStr = '0x%x' % self.addr |
| ret = [addrStr, self.disassembly] |
| for name, value in self.pairs.iteritems(): |
| ret.append("%s=%s" % (name, str(value))) |
| return ret |
| |
| class InstFault(IdedObj): |
| """A fault instruction""" |
| def __init__(self, id, fault, addr, pairs={}): |
| super(InstFault,self).__init__(id, pairs) |
| self.fault = fault |
| self.addr = addr |
| |
| def table_line(self): |
| ret = ["0x%x" % self.addr, self.fault] |
| for name, value in self.pairs: |
| ret.append("%s=%s", name, str(value)) |
| return ret |
| |
| class Line(IdedObj): |
| """A fetched line""" |
| def __init__(self, id, vaddr, paddr, size, pairs={}): |
| super(Line,self).__init__(id, pairs) |
| self.vaddr = vaddr |
| self.paddr = paddr |
| self.size = size |
| |
| def table_line(self): |
| ret = ["0x%x/0x%x" % (self.vaddr, self.paddr), "%d" % self.size] |
| for name, value in self.pairs: |
| ret.append("%s=%s", name, str(value)) |
| return ret |
| |
| class LineFault(IdedObj): |
| """A faulting line""" |
| def __init__(self, id, fault, vaddr, pairs={}): |
| super(LineFault,self).__init__(id, pairs) |
| self.vaddr = vaddr |
| self.fault = fault |
| |
| def table_line(self): |
| ret = ["0x%x" % self.vaddr, self.fault] |
| for name, value in self.pairs: |
| ret.append("%s=%s", name, str(value)) |
| return ret |
| |
| class BlobEvent(object): |
| """Time event for a single blob""" |
| def __init__(self, unit, time, pairs = {}): |
| # blob's unit name |
| self.unit = unit |
| self.time = time |
| # dict of picChar (blob name) to visual data |
| self.visuals = {} |
| # Miscellaneous unparsed MinorTrace line data |
| self.pairs = pairs |
| # Non-MinorTrace debug printout for this unit at this time |
| self.comments = [] |
| |
| def find_ided_objects(self, model, picChar, includeInstLines): |
| """Find instructions/lines mentioned in the blob's event |
| data""" |
| ret = [] |
| if picChar in self.visuals: |
| blocks = self.visuals[picChar].elems() |
| def find_inst(data): |
| instId = data.get_inst() |
| lineId = data.get_line() |
| if instId is not None: |
| inst = model.find_inst(instId) |
| line = model.find_line(instId) |
| if inst is not None: |
| ret.append(inst) |
| if includeInstLines and line is not None: |
| ret.append(line) |
| elif lineId is not None: |
| line = model.find_line(lineId) |
| if line is not None: |
| ret.append(line) |
| map(find_inst, blocks) |
| return sorted(ret) |
| |
| class BlobModel(object): |
| """Model bringing together blob definitions and parsed events""" |
| def __init__(self, unitNamePrefix=''): |
| self.blobs = [] |
| self.unitNameToBlobs = {} |
| self.unitEvents = {} |
| self.clear_events() |
| self.picSize = Point(20,10) |
| self.lastTime = 0 |
| self.unitNamePrefix = unitNamePrefix |
| |
| def clear_events(self): |
| """Drop all events and times""" |
| self.lastTime = 0 |
| self.times = [] |
| self.insts = {} |
| self.lines = {} |
| self.numEvents = 0 |
| |
| for unit, events in self.unitEvents.iteritems(): |
| self.unitEvents[unit] = [] |
| |
| def add_blob(self, blob): |
| """Add a parsed blob to the model""" |
| self.blobs.append(blob) |
| if blob.unit not in self.unitNameToBlobs: |
| self.unitNameToBlobs[blob.unit] = [] |
| |
| self.unitNameToBlobs[blob.unit].append(blob) |
| |
| def add_inst(self, inst): |
| """Add a MinorInst instruction definition to the model""" |
| # Is this a non micro-op instruction. Microops (usually) get their |
| # fetchSeqNum == 0 varient stored first |
| macroop_key = (inst.id.fetchSeqNum, 0) |
| full_key = (inst.id.fetchSeqNum, inst.id.execSeqNum) |
| |
| if inst.id.execSeqNum != 0 and macroop_key not in self.insts: |
| self.insts[macroop_key] = inst |
| |
| self.insts[full_key] = inst |
| |
| def find_inst(self, id): |
| """Find an instruction either as a microop or macroop""" |
| macroop_key = (id.fetchSeqNum, 0) |
| full_key = (id.fetchSeqNum, id.execSeqNum) |
| |
| if full_key in self.insts: |
| return self.insts[full_key] |
| elif macroop_key in self.insts: |
| return self.insts[macroop_key] |
| else: |
| return None |
| |
| def add_line(self, line): |
| """Add a MinorLine line to the model""" |
| self.lines[line.id.lineSeqNum] = line |
| |
| def add_unit_event(self, event): |
| """Add a single event to the model. This must be an event at a |
| time >= the current maximum time""" |
| if event.unit in self.unitEvents: |
| events = self.unitEvents[event.unit] |
| if len(events) > 0 and events[len(events)-1].time > event.time: |
| print "Bad event ordering" |
| events.append(event) |
| self.numEvents += 1 |
| self.lastTime = max(self.lastTime, event.time) |
| |
| def extract_times(self): |
| """Extract a list of all the times from the seen events. Call after |
| reading events to give a safe index list to use for time indices""" |
| times = {} |
| for unitEvents in self.unitEvents.itervalues(): |
| for event in unitEvents: |
| times[event.time] = 1 |
| self.times = times.keys() |
| self.times.sort() |
| |
| def find_line(self, id): |
| """Find a line by id""" |
| key = id.lineSeqNum |
| return self.lines.get(key, None) |
| |
| def find_event_bisection(self, unit, time, events, |
| lower_index, upper_index): |
| """Find an event by binary search on time indices""" |
| while lower_index <= upper_index: |
| pivot = (upper_index + lower_index) / 2 |
| pivotEvent = events[pivot] |
| event_equal = (pivotEvent.time == time or |
| (pivotEvent.time < time and |
| (pivot == len(events) - 1 or |
| events[pivot + 1].time > time))) |
| |
| if event_equal: |
| return pivotEvent |
| elif time > pivotEvent.time: |
| if pivot == upper_index: |
| return None |
| else: |
| lower_index = pivot + 1 |
| elif time < pivotEvent.time: |
| if pivot == lower_index: |
| return None |
| else: |
| upper_index = pivot - 1 |
| else: |
| return None |
| return None |
| |
| def find_unit_event_by_time(self, unit, time): |
| """Find the last event for the given unit at time <= time""" |
| if unit in self.unitEvents: |
| events = self.unitEvents[unit] |
| ret = self.find_event_bisection(unit, time, events, |
| 0, len(events)-1) |
| |
| return ret |
| else: |
| return None |
| |
| def find_time_index(self, time): |
| """Find a time index close to the given time (where |
| times[return] <= time and times[return+1] > time""" |
| ret = 0 |
| lastIndex = len(self.times) - 1 |
| while ret < lastIndex and self.times[ret + 1] <= time: |
| ret += 1 |
| return ret |
| |
| def add_minor_inst(self, rest): |
| """Parse and add a MinorInst line to the model""" |
| pairs = parse.parse_pairs(rest) |
| other_pairs = dict(pairs) |
| |
| id = Id().from_string(pairs['id']) |
| del other_pairs['id'] |
| |
| addr = int(pairs['addr'], 0) |
| del other_pairs['addr'] |
| |
| if 'inst' in other_pairs: |
| del other_pairs['inst'] |
| |
| # Collapse unnecessary spaces in disassembly |
| disassembly = re.sub(' *', ' ', |
| re.sub('^ *', '', pairs['inst'])) |
| |
| inst = Inst(id, disassembly, addr, other_pairs) |
| self.add_inst(inst) |
| elif 'fault' in other_pairs: |
| del other_pairs['fault'] |
| |
| inst = InstFault(id, pairs['fault'], addr, other_pairs) |
| |
| self.add_inst(inst) |
| |
| def add_minor_line(self, rest): |
| """Parse and add a MinorLine line to the model""" |
| pairs = parse.parse_pairs(rest) |
| other_pairs = dict(pairs) |
| |
| id = Id().from_string(pairs['id']) |
| del other_pairs['id'] |
| |
| vaddr = int(pairs['vaddr'], 0) |
| del other_pairs['vaddr'] |
| |
| if 'paddr' in other_pairs: |
| del other_pairs['paddr'] |
| del other_pairs['size'] |
| paddr = int(pairs['paddr'], 0) |
| size = int(pairs['size'], 0) |
| |
| self.add_line(Line(id, |
| vaddr, paddr, size, other_pairs)) |
| elif 'fault' in other_pairs: |
| del other_pairs['fault'] |
| |
| self.add_line(LineFault(id, pairs['fault'], vaddr, other_pairs)) |
| |
| def load_events(self, file, startTime=0, endTime=None): |
| """Load an event file and add everything to this model""" |
| def update_comments(comments, time): |
| # Add a list of comments to an existing event, if there is one at |
| # the given time, or create a new, correctly-timed, event from |
| # the last event and attach the comments to that |
| for commentUnit, commentRest in comments: |
| event = self.find_unit_event_by_time(commentUnit, time) |
| # Find an event to which this comment can be attached |
| if event is None: |
| # No older event, make a new empty one |
| event = BlobEvent(commentUnit, time, {}) |
| self.add_unit_event(event) |
| elif event.time != time: |
| # Copy the old event and make a new one with the right |
| # time and comment |
| newEvent = BlobEvent(commentUnit, time, event.pairs) |
| newEvent.visuals = dict(event.visuals) |
| event = newEvent |
| self.add_unit_event(event) |
| event.comments.append(commentRest) |
| |
| self.clear_events() |
| |
| # A negative time will *always* be different from an event time |
| time = -1 |
| time_events = {} |
| last_time_lines = {} |
| minor_trace_line_count = 0 |
| comments = [] |
| |
| default_colour = [[colours.unknownColour]] |
| next_progress_print_event_count = 1000 |
| |
| if not os.access(file, os.R_OK): |
| print 'Can\'t open file', file |
| exit(1) |
| else: |
| print 'Opening file', file |
| |
| f = open(file) |
| |
| start_wall_time = wall_time() |
| |
| # Skip leading events |
| still_skipping = True |
| l = f.readline() |
| while l and still_skipping: |
| match = re.match('^\s*(\d+):', l) |
| if match is not None: |
| event_time = match.groups() |
| if int(event_time[0]) >= startTime: |
| still_skipping = False |
| else: |
| l = f.readline() |
| else: |
| l = f.readline() |
| |
| match_line_re = re.compile( |
| '^\s*(\d+):\s*([\w\.]+):\s*(Minor\w+:)?\s*(.*)$') |
| |
| # Parse each line of the events file, accumulating comments to be |
| # attached to MinorTrace events when the time changes |
| reached_end_time = False |
| while not reached_end_time and l: |
| match = match_line_re.match(l) |
| if match is not None: |
| event_time, unit, line_type, rest = match.groups() |
| event_time = int(event_time) |
| |
| unit = re.sub('^' + self.unitNamePrefix + '\.?(.*)$', |
| '\\1', unit) |
| |
| # When the time changes, resolve comments |
| if event_time != time: |
| if self.numEvents > next_progress_print_event_count: |
| print ('Parsed to time: %d' % event_time) |
| next_progress_print_event_count = ( |
| self.numEvents + 1000) |
| update_comments(comments, time) |
| comments = [] |
| time = event_time |
| |
| if line_type is None: |
| # Treat this line as just a 'comment' |
| comments.append((unit, rest)) |
| elif line_type == 'MinorTrace:': |
| minor_trace_line_count += 1 |
| |
| # Only insert this event if it's not the same as |
| # the last event we saw for this unit |
| if last_time_lines.get(unit, None) != rest: |
| event = BlobEvent(unit, event_time, {}) |
| pairs = parse.parse_pairs(rest) |
| event.pairs = pairs |
| |
| # Try to decode the colour data for this event |
| blobs = self.unitNameToBlobs.get(unit, []) |
| for blob in blobs: |
| if blob.visualDecoder is not None: |
| event.visuals[blob.picChar] = ( |
| blob.visualDecoder(pairs)) |
| |
| self.add_unit_event(event) |
| last_time_lines[unit] = rest |
| elif line_type == 'MinorInst:': |
| self.add_minor_inst(rest) |
| elif line_type == 'MinorLine:': |
| self.add_minor_line(rest) |
| |
| if endTime is not None and time > endTime: |
| reached_end_time = True |
| |
| l = f.readline() |
| |
| update_comments(comments, time) |
| self.extract_times() |
| f.close() |
| |
| end_wall_time = wall_time() |
| |
| print 'Total events:', minor_trace_line_count, 'unique events:', \ |
| self.numEvents |
| print 'Time to parse:', end_wall_time - start_wall_time |
| |
| def add_blob_picture(self, offset, pic, nameDict): |
| """Add a parsed ASCII-art pipeline markup to the model""" |
| pic_width = 0 |
| for line in pic: |
| pic_width = max(pic_width, len(line)) |
| pic_height = len(pic) |
| |
| # Number of horizontal characters per 'pixel'. Should be 2 |
| charsPerPixel = 2 |
| |
| # Clean up pic_width to a multiple of charsPerPixel |
| pic_width = (pic_width + charsPerPixel - 1) // 2 |
| |
| self.picSize = Point(pic_width, pic_height) |
| |
| def pic_at(point): |
| """Return the char pair at the given point. |
| Returns None for characters off the picture""" |
| x, y = point.to_pair() |
| x *= 2 |
| if y >= len(pic) or x >= len(pic[y]): |
| return None |
| else: |
| return pic[y][x:x + charsPerPixel] |
| |
| def clear_pic_at(point): |
| """Clear the chars at point so we don't trip over them again""" |
| line = pic[point.y] |
| x = point.x * charsPerPixel |
| pic[point.y] = line[0:x] + (' ' * charsPerPixel) + \ |
| line[x + charsPerPixel:] |
| |
| def skip_same_char(start, increment): |
| """Skip characters which match pic_at(start)""" |
| char = pic_at(start) |
| hunt = start |
| while pic_at(hunt) == char: |
| hunt += increment |
| return hunt |
| |
| def find_size(start): |
| """Find the size of a rectangle with top left hand corner at |
| start consisting of (at least) a -. shaped corner describing |
| the top right corner of a rectangle of the same char""" |
| char = pic_at(start) |
| hunt_x = skip_same_char(start, Point(1,0)) |
| hunt_y = skip_same_char(start, Point(0,1)) |
| off_bottom_right = (hunt_x * Point(1,0)) + (hunt_y * Point(0,1)) |
| return off_bottom_right - start |
| |
| def point_return(point): |
| """Carriage return, line feed""" |
| return Point(0, point.y + 1) |
| |
| def find_arrow(start): |
| """Find a simple 1-char wide arrow""" |
| |
| def body(endChar, contChar, direc): |
| arrow_point = start |
| arrow_point += Point(0, 1) |
| clear_pic_at(start) |
| while pic_at(arrow_point) == contChar: |
| clear_pic_at(arrow_point) |
| arrow_point += Point(0, 1) |
| |
| if pic_at(arrow_point) == endChar: |
| clear_pic_at(arrow_point) |
| self.add_blob(blobs.Arrow('_', start + offset, |
| direc = direc, |
| size = (Point(1, 1) + arrow_point - start))) |
| else: |
| print 'Bad arrow', start |
| |
| char = pic_at(start) |
| if char == '-\\': |
| body('-/', ' :', 'right') |
| elif char == '/-': |
| body('\\-', ': ', 'left') |
| |
| blank_chars = [' ', ' :', ': '] |
| |
| # Traverse the picture left to right, top to bottom to find blobs |
| seen_dict = {} |
| point = Point(0,0) |
| while pic_at(point) is not None: |
| while pic_at(point) is not None: |
| char = pic_at(point) |
| if char == '->': |
| self.add_blob(blobs.Arrow('_', point + offset, |
| direc = 'right')) |
| elif char == '<-': |
| self.add_blob(blobs.Arrow('_', point + offset, |
| direc = 'left')) |
| elif char == '-\\' or char == '/-': |
| find_arrow(point) |
| elif char in blank_chars: |
| pass |
| else: |
| if char not in seen_dict: |
| size = find_size(point) |
| topLeft = point + offset |
| if char not in nameDict: |
| # Unnamed blobs |
| self.add_blob(blobs.Block(char, |
| nameDict.get(char, '_'), |
| topLeft, size = size)) |
| else: |
| # Named blobs, set visual info. |
| blob = nameDict[char] |
| blob.size = size |
| blob.topLeft = topLeft |
| self.add_blob(blob) |
| seen_dict[char] = True |
| point = skip_same_char(point, Point(1,0)) |
| point = point_return(point) |
| |
| def load_picture(self, filename): |
| """Load a picture file into the model""" |
| def parse_blob_description(char, unit, macros, pairsList): |
| # Parse the name value pairs in a blob-describing line |
| def expand_macros(pairs, newPairs): |
| # Recursively expand macros |
| for name, value in newPairs: |
| if name in macros: |
| expand_macros(pairs, macros[name]) |
| else: |
| pairs[name] = value |
| return pairs |
| |
| pairs = expand_macros({}, pairsList) |
| |
| ret = None |
| |
| typ = pairs.get('type', 'block') |
| colour = colours.name_to_colour(pairs.get('colour', 'black')) |
| |
| if typ == 'key': |
| ret = blobs.Key(char, unit, Point(0,0), colour) |
| elif typ == 'block': |
| ret = blobs.Block(char, unit, Point(0,0), colour) |
| else: |
| print "Bad picture blog type:", typ |
| |
| if 'hideId' in pairs: |
| hide = pairs['hideId'] |
| ret.dataSelect.ids -= set(hide) |
| |
| if typ == 'block': |
| ret.displayName = pairs.get('name', unit) |
| ret.nameLoc = pairs.get('nameLoc', 'top') |
| ret.shape = pairs.get('shape', 'box') |
| ret.stripDir = pairs.get('stripDir', 'horiz') |
| ret.stripOrd = pairs.get('stripOrd', 'LR') |
| ret.blankStrips = int(pairs.get('blankStrips', '0')) |
| ret.shorten = int(pairs.get('shorten', '0')) |
| |
| if 'decoder' in pairs: |
| decoderName = pairs['decoder'] |
| dataElement = pairs.get('dataElement', decoderName) |
| |
| decoder = find_colour_decoder(ret.blankStrips, |
| decoderName, dataElement, pairs) |
| if decoder is not None: |
| ret.visualDecoder = decoder |
| else: |
| print 'Bad visualDecoder requested:', decoderName |
| |
| if 'border' in pairs: |
| border = pairs['border'] |
| if border == 'thin': |
| ret.border = 0.2 |
| elif border == 'mid': |
| ret.border = 0.5 |
| else: |
| ret.border = 1.0 |
| elif typ == 'key': |
| ret.colours = pairs.get('colours', ret.colours) |
| |
| return ret |
| |
| def line_is_comment(line): |
| """Returns true if a line starts with #, returns False |
| for lines which are None""" |
| return line is not None \ |
| and re.match('^\s*#', line) is not None |
| |
| def get_line(f): |
| """Get a line from file f extending that line if it ends in |
| '\' and dropping lines that start with '#'s""" |
| ret = f.readline() |
| |
| # Discard comment lines |
| while line_is_comment(ret): |
| ret = f.readline() |
| |
| if ret is not None: |
| extend_match = re.match('^(.*)\\\\$', ret) |
| |
| while extend_match is not None: |
| new_line = f.readline() |
| |
| if new_line is not None and not line_is_comment(new_line): |
| line_wo_backslash, = extend_match.groups() |
| ret = line_wo_backslash + new_line |
| extend_match = re.match('^(.*)\\\\$', ret) |
| else: |
| extend_match = None |
| |
| return ret |
| |
| # Macros are recursively expanded into name=value pairs |
| macros = {} |
| |
| if not os.access(filename, os.R_OK): |
| print 'Can\'t open file', filename |
| exit(1) |
| else: |
| print 'Opening file', filename |
| |
| f = open(filename) |
| l = get_line(f) |
| picture = [] |
| blob_char_dict = {} |
| |
| self.unitEvents = {} |
| self.clear_events() |
| |
| # Actually parse the file |
| in_picture = False |
| while l: |
| l = parse.remove_trailing_ws(l) |
| l = re.sub('#.*', '', l) |
| |
| if re.match("^\s*$", l) is not None: |
| pass |
| elif l == '<<<': |
| in_picture = True |
| elif l == '>>>': |
| in_picture = False |
| elif in_picture: |
| picture.append(re.sub('\s*$', '', l)) |
| else: |
| line_match = re.match( |
| '^([a-zA-Z0-9][a-zA-Z0-9]):\s+([\w.]+)\s*(.*)', l) |
| macro_match = re.match('macro\s+(\w+):(.*)', l) |
| |
| if macro_match is not None: |
| name, defn = macro_match.groups() |
| macros[name] = parse.parse_pairs_list(defn) |
| elif line_match is not None: |
| char, unit, pairs = line_match.groups() |
| blob = parse_blob_description(char, unit, macros, |
| parse.parse_pairs_list(pairs)) |
| blob_char_dict[char] = blob |
| # Setup the events structure |
| self.unitEvents[unit] = [] |
| else: |
| print 'Problem with Blob line:', l |
| |
| l = get_line(f) |
| |
| self.blobs = [] |
| self.add_blob_picture(Point(0,1), picture, blob_char_dict) |
