|
#! /usr/bin/env python3 |
|
|
|
# Copyright (c) 2011 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. |
|
|
|
# Pipeline activity viewer for the O3 CPU model. |
|
|
|
import argparse |
|
import os |
|
import sys |
|
import copy |
|
|
|
# Temporary storage for instructions. The queue is filled in out-of-order |
|
# until it reaches 'max_threshold' number of instructions. It is then |
|
# sorted out and instructions are printed out until their number drops to |
|
# 'min_threshold'. |
|
# It is assumed that the instructions are not out of order for more then |
|
# 'min_threshold' places - otherwise they will appear out of order. |
|
insts = { |
|
"queue": [], # Instructions to print. |
|
"max_threshold": 2000, # Instructions are sorted out and printed when |
|
# their number reaches this threshold. |
|
"min_threshold": 1000, # Printing stops when this number is reached. |
|
"sn_start": 0, # The first instruction seq. number to be printed. |
|
"sn_stop": 0, # The last instruction seq. number to be printed. |
|
"tick_start": 0, # The first tick to be printed |
|
"tick_stop": 0, # The last tick to be printed |
|
"tick_drift": 2000, # Used to calculate the start and the end of main |
|
# loop. We assume here that the instructions are not |
|
# out of order for more then 2000 CPU ticks, |
|
# otherwise the print may not start/stop |
|
# at the time specified by tick_start/stop. |
|
"only_committed": 0, # Set if only committed instructions are printed. |
|
} |
|
|
|
|
|
def process_trace( |
|
trace, |
|
outfile, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
committed_only, |
|
store_completions, |
|
start_tick, |
|
stop_tick, |
|
start_sn, |
|
stop_sn, |
|
): |
|
global insts |
|
|
|
insts["sn_start"] = start_sn |
|
insts["sn_stop"] = stop_sn |
|
insts["tick_start"] = start_tick |
|
insts["tick_stop"] = stop_tick |
|
insts["tick_drift"] = insts["tick_drift"] * cycle_time |
|
insts["only_committed"] = committed_only |
|
line = None |
|
fields = None |
|
|
|
# Skip lines up to the starting tick |
|
if start_tick != 0: |
|
while True: |
|
line = trace.readline() |
|
if not line: |
|
return |
|
fields = line.split(":") |
|
if fields[0] != "O3PipeView": |
|
continue |
|
if int(fields[2]) >= start_tick: |
|
break |
|
elif start_sn != 0: |
|
while True: |
|
line = trace.readline() |
|
if not line: |
|
return |
|
fields = line.split(":") |
|
if fields[0] != "O3PipeView": |
|
continue |
|
if fields[1] == "fetch" and int(fields[5]) >= start_sn: |
|
break |
|
else: |
|
line = trace.readline() |
|
if not line: |
|
return |
|
fields = line.split(":") |
|
|
|
# Skip lines up to next instruction fetch |
|
while fields[0] != "O3PipeView" or fields[1] != "fetch": |
|
line = trace.readline() |
|
if not line: |
|
return |
|
fields = line.split(":") |
|
|
|
# Print header |
|
outfile.write( |
|
"// f = fetch, d = decode, n = rename, p = dispatch, " |
|
"i = issue, c = complete, r = retire" |
|
) |
|
|
|
if store_completions: |
|
outfile.write(", s = store-complete") |
|
outfile.write("\n\n") |
|
|
|
outfile.write( |
|
" " |
|
+ "timeline".center(width) |
|
+ " " |
|
+ "tick".center(15) |
|
+ " " |
|
+ "pc.upc".center(12) |
|
+ " " |
|
+ "disasm".ljust(25) |
|
+ " " |
|
+ "seq_num".center(10) |
|
) |
|
if timestamps: |
|
outfile.write("timestamps".center(25)) |
|
outfile.write("\n") |
|
|
|
# Region of interest |
|
curr_inst = {} |
|
while True: |
|
if fields[0] == "O3PipeView": |
|
curr_inst[fields[1]] = int(fields[2]) |
|
if fields[1] == "fetch": |
|
if ( |
|
stop_tick > 0 |
|
and int(fields[2]) > stop_tick + insts["tick_drift"] |
|
) or ( |
|
stop_sn > 0 |
|
and int(fields[5]) > (stop_sn + insts["max_threshold"]) |
|
): |
|
print_insts( |
|
outfile, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
store_completions, |
|
0, |
|
) |
|
return |
|
(curr_inst["pc"], curr_inst["upc"]) = fields[3:5] |
|
curr_inst["sn"] = int(fields[5]) |
|
curr_inst["disasm"] = " ".join(fields[6][:-1].split()) |
|
elif fields[1] == "retire": |
|
if curr_inst["retire"] == 0: |
|
curr_inst["disasm"] = "-----" + curr_inst["disasm"] |
|
if store_completions: |
|
curr_inst[fields[3]] = int(fields[4]) |
|
queue_inst( |
|
outfile, |
|
curr_inst, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
store_completions, |
|
) |
|
|
|
line = trace.readline() |
|
if not line: |
|
print_insts( |
|
outfile, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
store_completions, |
|
0, |
|
) |
|
return |
|
fields = line.split(":") |
|
|
|
|
|
# Puts new instruction into the print queue. |
|
# Sorts out and prints instructions when their number reaches threshold value |
|
def queue_inst( |
|
outfile, inst, cycle_time, width, color, timestamps, store_completions |
|
): |
|
global insts |
|
l_copy = copy.deepcopy(inst) |
|
insts["queue"].append(l_copy) |
|
if len(insts["queue"]) > insts["max_threshold"]: |
|
print_insts( |
|
outfile, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
store_completions, |
|
insts["min_threshold"], |
|
) |
|
|
|
|
|
# Sorts out and prints instructions in print queue |
|
def print_insts( |
|
outfile, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
store_completions, |
|
lower_threshold, |
|
): |
|
global insts |
|
# sort the list of insts by sequence numbers |
|
insts["queue"].sort(key=lambda inst: inst["sn"]) |
|
while len(insts["queue"]) > lower_threshold: |
|
print_item = insts["queue"].pop(0) |
|
# As the instructions are processed out of order the main loop starts |
|
# earlier then specified by start_sn/tick and finishes later then what |
|
# is defined in stop_sn/tick. |
|
# Therefore, here we have to filter out instructions that reside out of |
|
# the specified boundaries. |
|
if insts["sn_start"] > 0 and print_item["sn"] < insts["sn_start"]: |
|
continue |
|
# earlier then the starting sequence number |
|
if insts["sn_stop"] > 0 and print_item["sn"] > insts["sn_stop"]: |
|
continue |
|
# later then the ending sequence number |
|
if ( |
|
insts["tick_start"] > 0 |
|
and print_item["fetch"] < insts["tick_start"] |
|
): |
|
continue |
|
# earlier then the starting tick number |
|
if insts["tick_stop"] > 0 and print_item["fetch"] > insts["tick_stop"]: |
|
continue |
|
# later then the ending tick number |
|
|
|
if insts["only_committed"] != 0 and print_item["retire"] == 0: |
|
continue |
|
# retire is set to zero if it hasn't been completed |
|
print_inst( |
|
outfile, |
|
print_item, |
|
cycle_time, |
|
width, |
|
color, |
|
timestamps, |
|
store_completions, |
|
) |
|
|
|
|
|
# Prints a single instruction |
|
def print_inst( |
|
outfile, inst, cycle_time, width, color, timestamps, store_completions |
|
): |
|
if color: |
|
from m5.util.terminal import termcap |
|
else: |
|
from m5.util.terminal import no_termcap as termcap |
|
# Pipeline stages |
|
stages = [ |
|
{ |
|
"name": "fetch", |
|
"color": termcap.Blue + termcap.Reverse, |
|
"shorthand": "f", |
|
}, |
|
{ |
|
"name": "decode", |
|
"color": termcap.Yellow + termcap.Reverse, |
|
"shorthand": "d", |
|
}, |
|
{ |
|
"name": "rename", |
|
"color": termcap.Magenta + termcap.Reverse, |
|
"shorthand": "n", |
|
}, |
|
{ |
|
"name": "dispatch", |
|
"color": termcap.Green + termcap.Reverse, |
|
"shorthand": "p", |
|
}, |
|
{ |
|
"name": "issue", |
|
"color": termcap.Red + termcap.Reverse, |
|
"shorthand": "i", |
|
}, |
|
{ |
|
"name": "complete", |
|
"color": termcap.Cyan + termcap.Reverse, |
|
"shorthand": "c", |
|
}, |
|
{ |
|
"name": "retire", |
|
"color": termcap.Blue + termcap.Reverse, |
|
"shorthand": "r", |
|
}, |
|
] |
|
if store_completions: |
|
stages.append( |
|
{ |
|
"name": "store", |
|
"color": termcap.Yellow + termcap.Reverse, |
|
"shorthand": "s", |
|
} |
|
) |
|
|
|
# Print |
|
|
|
time_width = width * cycle_time |
|
base_tick = (inst["fetch"] // time_width) * time_width |
|
|
|
# Find out the time of the last event - it may not |
|
# be 'retire' if the instruction is not comlpeted. |
|
last_event_time = max( |
|
inst["fetch"], |
|
inst["decode"], |
|
inst["rename"], |
|
inst["dispatch"], |
|
inst["issue"], |
|
inst["complete"], |
|
inst["retire"], |
|
) |
|
if store_completions: |
|
last_event_time = max(last_event_time, inst["store"]) |
|
|
|
# Timeline shorter then time_width is printed in compact form where |
|
# the print continues at the start of the same line. |
|
if (last_event_time - inst["fetch"]) < time_width: |
|
num_lines = 1 # compact form |
|
else: |
|
num_lines = ((last_event_time - base_tick) // time_width) + 1 |
|
|
|
curr_color = termcap.Normal |
|
|
|
# This will visually distinguish completed and abandoned intructions. |
|
if inst["retire"] == 0: |
|
dot = "=" # abandoned instruction |
|
else: |
|
dot = "." # completed instruction |
|
|
|
for i in range(num_lines): |
|
start_tick = base_tick + i * time_width |
|
end_tick = start_tick + time_width |
|
if num_lines == 1: # compact form |
|
end_tick += inst["fetch"] - base_tick |
|
events = [] |
|
for stage_idx in range(len(stages)): |
|
tick = inst[stages[stage_idx]["name"]] |
|
if tick != 0: |
|
if tick >= start_tick and tick < end_tick: |
|
events.append( |
|
( |
|
tick % time_width, |
|
stages[stage_idx]["name"], |
|
stage_idx, |
|
tick, |
|
) |
|
) |
|
events.sort() |
|
outfile.write("[") |
|
pos = 0 |
|
if num_lines == 1 and events[0][2] != 0: # event is not fetch |
|
curr_color = stages[events[0][2] - 1]["color"] |
|
for event in events: |
|
if ( |
|
stages[event[2]]["name"] == "dispatch" |
|
and inst["dispatch"] == inst["issue"] |
|
): |
|
continue |
|
outfile.write(curr_color + dot * ((event[0] // cycle_time) - pos)) |
|
outfile.write( |
|
stages[event[2]]["color"] + stages[event[2]]["shorthand"] |
|
) |
|
|
|
if event[3] != last_event_time: # event is not the last one |
|
curr_color = stages[event[2]]["color"] |
|
else: |
|
curr_color = termcap.Normal |
|
|
|
pos = (event[0] // cycle_time) + 1 |
|
outfile.write( |
|
curr_color |
|
+ dot * (width - pos) |
|
+ termcap.Normal |
|
+ "]-(" |
|
+ str(base_tick + i * time_width).rjust(15) |
|
+ ") " |
|
) |
|
if i == 0: |
|
outfile.write( |
|
"%s.%s %s [%s]" |
|
% ( |
|
inst["pc"].rjust(10), |
|
inst["upc"], |
|
inst["disasm"].ljust(25), |
|
str(inst["sn"]).rjust(10), |
|
) |
|
) |
|
if timestamps: |
|
outfile.write(" f=%s, r=%s" % (inst["fetch"], inst["retire"])) |
|
outfile.write("\n") |
|
else: |
|
outfile.write("...".center(12) + "\n") |
|
|
|
|
|
def validate_range(my_range): |
|
my_range = [int(i) for i in my_range.split(":")] |
|
if ( |
|
len(my_range) != 2 |
|
or my_range[0] < 0 |
|
or my_range[1] > 0 |
|
and my_range[0] >= my_range[1] |
|
): |
|
return None |
|
return my_range |
|
|
|
|
|
def main(): |
|
# Parse args |
|
usage = "%(prog)s [OPTION]... TRACE_FILE" |
|
parser = argparse.ArgumentParser( |
|
usage=usage, formatter_class=argparse.ArgumentDefaultsHelpFormatter |
|
) |
|
parser.add_argument( |
|
"-o", |
|
dest="outfile", |
|
default=os.path.join(os.getcwd(), "o3-pipeview.out"), |
|
help="output file", |
|
) |
|
parser.add_argument( |
|
"-t", dest="tick_range", default="0:-1", help="tick range (-1 == inf.)" |
|
) |
|
parser.add_argument( |
|
"-i", |
|
dest="inst_range", |
|
default="0:-1", |
|
help="instruction range (-1 == inf.)", |
|
) |
|
parser.add_argument( |
|
"-w", dest="width", type=int, default=80, help="timeline width" |
|
) |
|
parser.add_argument( |
|
"--color", |
|
action="store_true", |
|
default=False, |
|
help="enable colored output", |
|
) |
|
parser.add_argument( |
|
"-c", |
|
"--cycle-time", |
|
type=int, |
|
default=1000, |
|
help="CPU cycle time in ticks", |
|
) |
|
parser.add_argument( |
|
"--timestamps", |
|
action="store_true", |
|
default=False, |
|
help="print fetch and retire timestamps", |
|
) |
|
parser.add_argument( |
|
"--only_committed", |
|
action="store_true", |
|
default=False, |
|
help="display only committed (completed) instructions", |
|
) |
|
parser.add_argument( |
|
"--store_completions", |
|
action="store_true", |
|
default=False, |
|
help="additionally display store completion ticks", |
|
) |
|
parser.add_argument("tracefile") |
|
|
|
args = parser.parse_args() |
|
tick_range = validate_range(args.tick_range) |
|
if not tick_range: |
|
parser.error("invalid range") |
|
sys.exit(1) |
|
inst_range = validate_range(args.inst_range) |
|
if not inst_range: |
|
parser.error("invalid range") |
|
sys.exit(1) |
|
# Process trace |
|
print("Processing trace... ", end=" ") |
|
with open(args.tracefile, "r") as trace: |
|
with open(args.outfile, "w") as out: |
|
process_trace( |
|
trace, |
|
out, |
|
args.cycle_time, |
|
args.width, |
|
args.color, |
|
args.timestamps, |
|
args.only_committed, |
|
args.store_completions, |
|
*(tick_range + inst_range) |
|
) |
|
print("done!") |
|
|
|
|
|
if __name__ == "__main__": |
|
sys.path.append( |
|
os.path.join( |
|
os.path.dirname(os.path.abspath(__file__)), "..", "src", "python" |
|
) |
|
) |
|
main() |