0e8a90f06b
This patch contains a new CPU model named `Minor'. Minor models a four
stage in-order execution pipeline (fetch lines, decompose into
macroops, decompose macroops into microops, execute).
The model was developed to support the ARM ISA but should be fixable
to support all the remaining gem5 ISAs. It currently also works for
Alpha, and regressions are included for ARM and Alpha (including Linux
boot).
Documentation for the model can be found in src/doc/inside-minor.doxygen and
its internal operations can be visualised using the Minorview tool
utils/minorview.py.
Minor was designed to be fairly simple and not to engage in a lot of
instruction annotation. As such, it currently has very few gathered
stats and may lack other gem5 features.
Minor is faster than the o3 model. Sample results:
Benchmark | Stat host_seconds (s)
---------------+--------v--------v--------
(on ARM, opt) | simple | o3 | minor
| timing | timing | timing
---------------+--------+--------+--------
10.linux-boot | 169 | 1883 | 1075
10.mcf | 117 | 967 | 491
20.parser | 668 | 6315 | 3146
30.eon | 542 | 3413 | 2414
40.perlbmk | 2339 | 20905 | 11532
50.vortex | 122 | 1094 | 588
60.bzip2 | 2045 | 18061 | 9662
70.twolf | 207 | 2736 | 1036
524 lines
18 KiB
Python
524 lines
18 KiB
Python
# 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 pygtk
|
|
pygtk.require('2.0')
|
|
import gtk
|
|
import gobject
|
|
import cairo
|
|
import re
|
|
|
|
from point import Point
|
|
import parse
|
|
import colours
|
|
import model
|
|
from model import Id, BlobModel, BlobDataSelect, special_state_chars
|
|
import blobs
|
|
|
|
class BlobView(object):
|
|
"""The canvas view of the pipeline"""
|
|
def __init__(self, model):
|
|
# A unit blob will appear at size blobSize inside a space of
|
|
# size pitch.
|
|
self.blobSize = Point(45.0, 45.0)
|
|
self.pitch = Point(60.0, 60.0)
|
|
self.origin = Point(50.0, 50.0)
|
|
# Some common line definitions to cut down on arbitrary
|
|
# set_line_widths
|
|
self.thickLineWidth = 10.0
|
|
self.thinLineWidth = 4.0
|
|
self.midLineWidth = 6.0
|
|
# The scale from the units of pitch to device units (nominally
|
|
# pixels for 1.0 to 1.0
|
|
self.masterScale = Point(1.0,1.0)
|
|
self.model = model
|
|
self.fillColour = colours.emptySlotColour
|
|
self.timeIndex = 0
|
|
self.time = 0
|
|
self.positions = []
|
|
self.controlbar = None
|
|
# The sequence number selector state
|
|
self.dataSelect = BlobDataSelect()
|
|
# Offset of this view's time from self.time used for miniviews
|
|
# This is actually an offset of the index into the array of times
|
|
# seen in the event file)
|
|
self.timeOffset = 0
|
|
# Maximum view size for initial window mapping
|
|
self.initialHeight = 600.0
|
|
|
|
# Overlays are speech bubbles explaining blob data
|
|
self.overlays = []
|
|
|
|
self.da = gtk.DrawingArea()
|
|
def draw(arg1, arg2):
|
|
self.redraw()
|
|
self.da.connect('expose_event', draw)
|
|
|
|
# Handy offsets from the blob size
|
|
self.blobIndent = (self.pitch - self.blobSize).scale(0.5)
|
|
self.blobIndentFactor = self.blobIndent / self.pitch
|
|
|
|
def add_control_bar(self, controlbar):
|
|
"""Add a BlobController to this view"""
|
|
self.controlbar = controlbar
|
|
|
|
def draw_to_png(self, filename):
|
|
"""Draw the view to a PNG file"""
|
|
surface = cairo.ImageSurface(
|
|
cairo.FORMAT_ARGB32,
|
|
self.da.get_allocation().width,
|
|
self.da.get_allocation().height)
|
|
cr = gtk.gdk.CairoContext(cairo.Context(surface))
|
|
self.draw_to_cr(cr)
|
|
surface.write_to_png(filename)
|
|
|
|
def draw_to_cr(self, cr):
|
|
"""Draw to a given CairoContext"""
|
|
cr.set_source_color(colours.backgroundColour)
|
|
cr.set_line_width(self.thickLineWidth)
|
|
cr.paint()
|
|
cr.save()
|
|
cr.scale(*self.masterScale.to_pair())
|
|
cr.translate(*self.origin.to_pair())
|
|
|
|
positions = [] # {}
|
|
|
|
# Draw each blob
|
|
for blob in self.model.blobs:
|
|
blob_event = self.model.find_unit_event_by_time(
|
|
blob.unit, self.time)
|
|
|
|
cr.save()
|
|
pos = blob.render(cr, self, blob_event, self.dataSelect,
|
|
self.time)
|
|
cr.restore()
|
|
if pos is not None:
|
|
(centre, size) = pos
|
|
positions.append((blob, centre, size))
|
|
|
|
# Draw all the overlays over the top
|
|
for overlay in self.overlays:
|
|
overlay.show(cr)
|
|
|
|
cr.restore()
|
|
|
|
return positions
|
|
|
|
def redraw(self):
|
|
"""Redraw the whole view"""
|
|
buffer = cairo.ImageSurface(
|
|
cairo.FORMAT_ARGB32,
|
|
self.da.get_allocation().width,
|
|
self.da.get_allocation().height)
|
|
|
|
cr = gtk.gdk.CairoContext(cairo.Context(buffer))
|
|
positions = self.draw_to_cr(cr)
|
|
|
|
# Assume that blobs are in order for depth so we want to
|
|
# hit the frontmost blob first if we search by position
|
|
positions.reverse()
|
|
self.positions = positions
|
|
|
|
# Paint the drawn buffer onto the DrawingArea
|
|
dacr = self.da.window.cairo_create()
|
|
dacr.set_source_surface(buffer, 0.0, 0.0)
|
|
dacr.paint()
|
|
|
|
buffer.finish()
|
|
|
|
def set_time_index(self, time):
|
|
"""Set the time index for the view. A time index is an index into
|
|
the model's times array of seen event times"""
|
|
self.timeIndex = time + self.timeOffset
|
|
if len(self.model.times) != 0:
|
|
if self.timeIndex >= len(self.model.times):
|
|
self.time = self.model.times[len(self.model.times) - 1]
|
|
else:
|
|
self.time = self.model.times[self.timeIndex]
|
|
else:
|
|
self.time = 0
|
|
|
|
def get_pic_size(self):
|
|
"""Return the size of ASCII-art picture of the pipeline scaled by
|
|
the blob pitch"""
|
|
return (self.origin + self.pitch *
|
|
(self.model.picSize + Point(1.0,1.0)))
|
|
|
|
def set_da_size(self):
|
|
"""Set the DrawingArea size after scaling"""
|
|
self.da.set_size_request(10 , int(self.initialHeight))
|
|
|
|
class BlobController(object):
|
|
"""The controller bar for the viewer"""
|
|
def __init__(self, model, view,
|
|
defaultEventFile="", defaultPictureFile=""):
|
|
self.model = model
|
|
self.view = view
|
|
self.playTimer = None
|
|
self.filenameEntry = gtk.Entry()
|
|
self.filenameEntry.set_text(defaultEventFile)
|
|
self.pictureEntry = gtk.Entry()
|
|
self.pictureEntry.set_text(defaultPictureFile)
|
|
self.timeEntry = None
|
|
self.defaultEventFile = defaultEventFile
|
|
self.startTime = None
|
|
self.endTime = None
|
|
|
|
self.otherViews = []
|
|
|
|
def make_bar(elems):
|
|
box = gtk.HBox(homogeneous=False, spacing=2)
|
|
box.set_border_width(2)
|
|
for widget, signal, handler in elems:
|
|
if signal is not None:
|
|
widget.connect(signal, handler)
|
|
box.pack_start(widget, False, True, 0)
|
|
return box
|
|
|
|
self.timeEntry = gtk.Entry()
|
|
|
|
t = gtk.ToggleButton('T')
|
|
t.set_active(False)
|
|
s = gtk.ToggleButton('S')
|
|
s.set_active(True)
|
|
p = gtk.ToggleButton('P')
|
|
p.set_active(True)
|
|
l = gtk.ToggleButton('L')
|
|
l.set_active(True)
|
|
f = gtk.ToggleButton('F')
|
|
f.set_active(True)
|
|
e = gtk.ToggleButton('E')
|
|
e.set_active(True)
|
|
|
|
# Should really generate this from above
|
|
self.view.dataSelect.ids = set("SPLFE")
|
|
|
|
self.bar = gtk.VBox()
|
|
self.bar.set_homogeneous(False)
|
|
|
|
row1 = make_bar([
|
|
(gtk.Button('Start'), 'clicked', self.time_start),
|
|
(gtk.Button('End'), 'clicked', self.time_end),
|
|
(gtk.Button('Back'), 'clicked', self.time_back),
|
|
(gtk.Button('Forward'), 'clicked', self.time_forward),
|
|
(gtk.Button('Play'), 'clicked', self.time_play),
|
|
(gtk.Button('Stop'), 'clicked', self.time_stop),
|
|
(self.timeEntry, 'activate', self.time_set),
|
|
(gtk.Label('Visible ids:'), None, None),
|
|
(t, 'clicked', self.toggle_id('T')),
|
|
(gtk.Label('/'), None, None),
|
|
(s, 'clicked', self.toggle_id('S')),
|
|
(gtk.Label('.'), None, None),
|
|
(p, 'clicked', self.toggle_id('P')),
|
|
(gtk.Label('/'), None, None),
|
|
(l, 'clicked', self.toggle_id('L')),
|
|
(gtk.Label('/'), None, None),
|
|
(f, 'clicked', self.toggle_id('F')),
|
|
(gtk.Label('.'), None, None),
|
|
(e, 'clicked', self.toggle_id('E')),
|
|
(self.filenameEntry, 'activate', self.load_events),
|
|
(gtk.Button('Reload'), 'clicked', self.load_events)
|
|
])
|
|
|
|
self.bar.pack_start(row1, False, True, 0)
|
|
self.set_time_index(0)
|
|
|
|
def toggle_id(self, id):
|
|
"""One of the sequence number selector buttons has been toggled"""
|
|
def toggle(button):
|
|
if button.get_active():
|
|
self.view.dataSelect.ids.add(id)
|
|
else:
|
|
self.view.dataSelect.ids.discard(id)
|
|
|
|
# Always leave one thing visible
|
|
if len(self.view.dataSelect.ids) == 0:
|
|
self.view.dataSelect.ids.add(id)
|
|
button.set_active(True)
|
|
self.view.redraw()
|
|
return toggle
|
|
|
|
def set_time_index(self, time):
|
|
"""Set the time index in the view"""
|
|
self.view.set_time_index(time)
|
|
|
|
for view in self.otherViews:
|
|
view.set_time_index(time)
|
|
view.redraw()
|
|
|
|
self.timeEntry.set_text(str(self.view.time))
|
|
|
|
def time_start(self, button):
|
|
"""Start pressed"""
|
|
self.set_time_index(0)
|
|
self.view.redraw()
|
|
|
|
def time_end(self, button):
|
|
"""End pressed"""
|
|
self.set_time_index(len(self.model.times) - 1)
|
|
self.view.redraw()
|
|
|
|
def time_forward(self, button):
|
|
"""Step forward pressed"""
|
|
self.set_time_index(min(self.view.timeIndex + 1,
|
|
len(self.model.times) - 1))
|
|
self.view.redraw()
|
|
gtk.gdk.flush()
|
|
|
|
def time_back(self, button):
|
|
"""Step back pressed"""
|
|
self.set_time_index(max(self.view.timeIndex - 1, 0))
|
|
self.view.redraw()
|
|
|
|
def time_set(self, entry):
|
|
"""Time dialogue changed. Need to find a suitable time
|
|
<= the entry's time"""
|
|
newTime = self.model.find_time_index(int(entry.get_text()))
|
|
self.set_time_index(newTime)
|
|
self.view.redraw()
|
|
|
|
def time_step(self):
|
|
"""Time step while playing"""
|
|
if not self.playTimer \
|
|
or self.view.timeIndex == len(self.model.times) - 1:
|
|
self.time_stop(None)
|
|
return False
|
|
else:
|
|
self.time_forward(None)
|
|
return True
|
|
|
|
def time_play(self, play):
|
|
"""Automatically advance time every 100 ms"""
|
|
if not self.playTimer:
|
|
self.playTimer = gobject.timeout_add(100, self.time_step)
|
|
|
|
def time_stop(self, play):
|
|
"""Stop play pressed"""
|
|
if self.playTimer:
|
|
gobject.source_remove(self.playTimer)
|
|
self.playTimer = None
|
|
|
|
def load_events(self, button):
|
|
"""Reload events file"""
|
|
self.model.load_events(self.filenameEntry.get_text(),
|
|
startTime=self.startTime, endTime=self.endTime)
|
|
self.set_time_index(min(len(self.model.times) - 1,
|
|
self.view.timeIndex))
|
|
self.view.redraw()
|
|
|
|
class Overlay(object):
|
|
"""An Overlay is a speech bubble explaining the data in a blob"""
|
|
def __init__(self, model, view, point, blob):
|
|
self.model = model
|
|
self.view = view
|
|
self.point = point
|
|
self.blob = blob
|
|
|
|
def find_event(self):
|
|
"""Find the event for a changing time and a fixed blob"""
|
|
return self.model.find_unit_event_by_time(self.blob.unit,
|
|
self.view.time)
|
|
|
|
def show(self, cr):
|
|
"""Draw the overlay"""
|
|
event = self.find_event()
|
|
|
|
if event is None:
|
|
return
|
|
|
|
insts = event.find_ided_objects(self.model, self.blob.picChar,
|
|
False)
|
|
|
|
cr.set_line_width(self.view.thinLineWidth)
|
|
cr.translate(*(Point(0.0,0.0) - self.view.origin).to_pair())
|
|
cr.scale(*(Point(1.0,1.0) / self.view.masterScale).to_pair())
|
|
|
|
# Get formatted data from the insts to format into a table
|
|
lines = list(inst.table_line() for inst in insts)
|
|
|
|
text_size = 10.0
|
|
cr.set_font_size(text_size)
|
|
|
|
def text_width(str):
|
|
xb, yb, width, height, dx, dy = cr.text_extents(str)
|
|
return width
|
|
|
|
# Find the maximum number of columns and the widths of each column
|
|
num_columns = 0
|
|
for line in lines:
|
|
num_columns = max(num_columns, len(line))
|
|
|
|
widths = [0] * num_columns
|
|
for line in lines:
|
|
for i in xrange(0, len(line)):
|
|
widths[i] = max(widths[i], text_width(line[i]))
|
|
|
|
# Calculate the size of the speech bubble
|
|
column_gap = 1 * text_size
|
|
id_width = 6 * text_size
|
|
total_width = sum(widths) + id_width + column_gap * (num_columns + 1)
|
|
gap_step = Point(1.0, 0.0).scale(column_gap)
|
|
|
|
text_point = self.point
|
|
text_step = Point(0.0, text_size)
|
|
|
|
size = Point(total_width, text_size * len(insts))
|
|
|
|
# Draw the speech bubble
|
|
blobs.speech_bubble(cr, self.point, size, text_size)
|
|
cr.set_source_color(colours.backgroundColour)
|
|
cr.fill_preserve()
|
|
cr.set_source_color(colours.black)
|
|
cr.stroke()
|
|
|
|
text_point += Point(1.0,1.0).scale(2.0 * text_size)
|
|
|
|
id_size = Point(id_width, text_size)
|
|
|
|
# Draw the rows in the table
|
|
for i in xrange(0, len(insts)):
|
|
row_point = text_point
|
|
inst = insts[i]
|
|
line = lines[i]
|
|
blobs.striped_box(cr, row_point + id_size.scale(0.5),
|
|
id_size, inst.id.to_striped_block(self.view.dataSelect))
|
|
cr.set_source_color(colours.black)
|
|
|
|
row_point += Point(1.0, 0.0).scale(id_width)
|
|
row_point += text_step
|
|
# Draw the columns of each row
|
|
for j in xrange(0, len(line)):
|
|
row_point += gap_step
|
|
cr.move_to(*row_point.to_pair())
|
|
cr.show_text(line[j])
|
|
row_point += Point(1.0, 0.0).scale(widths[j])
|
|
|
|
text_point += text_step
|
|
|
|
class BlobWindow(object):
|
|
"""The top-level window and its mouse control"""
|
|
def __init__(self, model, view, controller):
|
|
self.model = model
|
|
self.view = view
|
|
self.controller = controller
|
|
self.controlbar = None
|
|
self.window = None
|
|
self.miniViewCount = 0
|
|
|
|
def add_control_bar(self, controlbar):
|
|
self.controlbar = controlbar
|
|
|
|
def show_window(self):
|
|
self.window = gtk.Window()
|
|
|
|
self.vbox = gtk.VBox()
|
|
self.vbox.set_homogeneous(False)
|
|
if self.controlbar:
|
|
self.vbox.pack_start(self.controlbar, False, True, 0)
|
|
self.vbox.add(self.view.da)
|
|
|
|
if self.miniViewCount > 0:
|
|
self.miniViews = []
|
|
self.miniViewHBox = gtk.HBox(homogeneous=True, spacing=2)
|
|
|
|
# Draw mini views
|
|
for i in xrange(1, self.miniViewCount + 1):
|
|
miniView = BlobView(self.model)
|
|
miniView.set_time_index(0)
|
|
miniView.masterScale = Point(0.1, 0.1)
|
|
miniView.set_da_size()
|
|
miniView.timeOffset = i + 1
|
|
self.miniViews.append(miniView)
|
|
self.miniViewHBox.pack_start(miniView.da, False, True, 0)
|
|
|
|
self.controller.otherViews = self.miniViews
|
|
self.vbox.add(self.miniViewHBox)
|
|
|
|
self.window.add(self.vbox)
|
|
|
|
def show_event(picChar, event):
|
|
print '**** Comments for', event.unit, \
|
|
'at time', self.view.time
|
|
for name, value in event.pairs.iteritems():
|
|
print name, '=', value
|
|
for comment in event.comments:
|
|
print comment
|
|
if picChar in event.visuals:
|
|
# blocks = event.visuals[picChar].elems()
|
|
print '**** Colour data'
|
|
objs = event.find_ided_objects(self.model, picChar, True)
|
|
for obj in objs:
|
|
print ' '.join(obj.table_line())
|
|
|
|
def clicked_da(da, b):
|
|
point = Point(b.x, b.y)
|
|
|
|
overlay = None
|
|
for blob, centre, size in self.view.positions:
|
|
if point.is_within_box((centre, size)):
|
|
event = self.model.find_unit_event_by_time(blob.unit,
|
|
self.view.time)
|
|
if event is not None:
|
|
if overlay is None:
|
|
overlay = Overlay(self.model, self.view, point,
|
|
blob)
|
|
show_event(blob.picChar, event)
|
|
if overlay is not None:
|
|
self.view.overlays = [overlay]
|
|
else:
|
|
self.view.overlays = []
|
|
|
|
self.view.redraw()
|
|
|
|
# Set initial size and event callbacks
|
|
self.view.set_da_size()
|
|
self.view.da.add_events(gtk.gdk.BUTTON_PRESS_MASK)
|
|
self.view.da.connect('button-press-event', clicked_da)
|
|
self.window.connect('destroy', lambda(widget): gtk.main_quit())
|
|
|
|
def resize(window, event):
|
|
"""Resize DrawingArea to match new window size"""
|
|
size = Point(float(event.width), float(event.height))
|
|
proportion = size / self.view.get_pic_size()
|
|
# Preserve aspect ratio
|
|
daScale = min(proportion.x, proportion.y)
|
|
self.view.masterScale = Point(daScale, daScale)
|
|
self.view.overlays = []
|
|
|
|
self.view.da.connect('configure-event', resize)
|
|
|
|
self.window.show_all()
|