util/o3-pipeview.py - public/gem5 - Git at Google

 #! /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 optparse
 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, 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(':')


 #Sorts out instructions according to sequence number
 def compare_by_sn(a, b):
     return cmp(a['sn'], b['sn'])

 # 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
     insts['queue'].sort(compare_by_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 options
     usage = ('%prog [OPTION]... TRACE_FILE')
     parser = optparse.OptionParser(usage=usage)
     parser.add_option(
         '-o',
         dest='outfile',
         default=os.path.join(os.getcwd(), 'o3-pipeview.out'),
         help="output file (default: '%default')")
     parser.add_option(
         '-t',
         dest='tick_range',
         default='0:-1',
         help="tick range (default: '%default'; -1 == inf.)")
     parser.add_option(
         '-i',
         dest='inst_range',
         default='0:-1',
         help="instruction range (default: '%default'; -1 == inf.)")
     parser.add_option(
         '-w',
         dest='width',
         type='int', default=80,
         help="timeline width (default: '%default')")
     parser.add_option(
         '--color',
         action='store_true', default=False,
         help="enable colored output (default: '%default')")
     parser.add_option(
         '-c', '--cycle-time',
         type='int', default=1000,
         help="CPU cycle time in ticks (default: '%default')")
     parser.add_option(
         '--timestamps',
         action='store_true', default=False,
         help="print fetch and retire timestamps (default: '%default')")
     parser.add_option(
         '--only_committed',
         action='store_true', default=False,
         help="display only committed (completed) instructions (default: '%default')")
     parser.add_option(
         '--store_completions',
         action='store_true', default=False,
         help="additionally display store completion ticks (default: '%default')")
     (options, args) = parser.parse_args()
     if len(args) != 1:
         parser.error('incorrect number of arguments')
         sys.exit(1)
     tick_range = validate_range(options.tick_range)
     if not tick_range:
         parser.error('invalid range')
         sys.exit(1)
     inst_range = validate_range(options.inst_range)
     if not inst_range:
         parser.error('invalid range')
         sys.exit(1)
     # Process trace
     print('Processing trace... ', end=' ')
     with open(args[0], 'r') as trace:
         with open(options.outfile, 'w') as out:
             process_trace(trace, out, options.cycle_time, options.width,
                           options.color, options.timestamps,
                           options.only_committed, options.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()
	#! /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 optparse
	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, 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(':')


	#Sorts out instructions according to sequence number
	def compare_by_sn(a, b):
	return cmp(a['sn'], b['sn'])

	# 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
	insts['queue'].sort(compare_by_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 options
	usage = ('%prog [OPTION]... TRACE_FILE')
	parser = optparse.OptionParser(usage=usage)
	parser.add_option(
	'-o',
	dest='outfile',
	default=os.path.join(os.getcwd(), 'o3-pipeview.out'),
	help="output file (default: '%default')")
	parser.add_option(
	'-t',
	dest='tick_range',
	default='0:-1',
	help="tick range (default: '%default'; -1 == inf.)")
	parser.add_option(
	'-i',
	dest='inst_range',
	default='0:-1',
	help="instruction range (default: '%default'; -1 == inf.)")
	parser.add_option(
	'-w',
	dest='width',
	type='int', default=80,
	help="timeline width (default: '%default')")
	parser.add_option(
	'--color',
	action='store_true', default=False,
	help="enable colored output (default: '%default')")
	parser.add_option(
	'-c', '--cycle-time',
	type='int', default=1000,
	help="CPU cycle time in ticks (default: '%default')")
	parser.add_option(
	'--timestamps',
	action='store_true', default=False,
	help="print fetch and retire timestamps (default: '%default')")
	parser.add_option(
	'--only_committed',
	action='store_true', default=False,
	help="display only committed (completed) instructions (default: '%default')")
	parser.add_option(
	'--store_completions',
	action='store_true', default=False,
	help="additionally display store completion ticks (default: '%default')")
	(options, args) = parser.parse_args()
	if len(args) != 1:
	parser.error('incorrect number of arguments')
	sys.exit(1)
	tick_range = validate_range(options.tick_range)
	if not tick_range:
	parser.error('invalid range')
	sys.exit(1)
	inst_range = validate_range(options.inst_range)
	if not inst_range:
	parser.error('invalid range')
	sys.exit(1)
	# Process trace
	print('Processing trace... ', end=' ')
	with open(args[0], 'r') as trace:
	with open(options.outfile, 'w') as out:
	process_trace(trace, out, options.cycle_time, options.width,
	options.color, options.timestamps,
	options.only_committed, options.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()