util/plot_dram/PlotPowerStates.py - public/gem5 - Git at Google


            
            # Copyright (c) 2017 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: Radhika Jagtap


            import matplotlib

            
            matplotlib.use('Agg')

            
            import matplotlib.pyplot as plt

            
            from matplotlib.font_manager import FontProperties

            
            import numpy as np

            
            import os


            # global results dict

            
            results = {}

            
            idleResults = {}


            # global vars for bank utilisation and seq_bytes values swept in the experiment

            
            bankUtilValues = []

            
            seqBytesValues = []

            
            delayValues = []


            # settings for 3 values of bank util and 3 values of seq_bytes

            
            stackHeight = 6.0

            
            stackWidth = 18.0

            
            barWidth = 0.5

            
            plotFontSize = 18


            States = ['IDLE', 'ACT', 'REF', 'ACT_PDN', 'PRE_PDN', 'SREF']


            EnergyStates = ['ACT_E',

            
            'PRE_E',

            
            'READ_E',

            
            'REF_E',

            
            'ACT_BACK_E',

            
            'PRE_BACK_E',

            
            'ACT_PDN_E',

            
            'PRE_PDN_E',

            
            'SREF_E']


            StackColors = {

            
            'IDLE' : 'black',       # time spent in states

            
            'ACT' : 'lightskyblue',

            
            'REF' : 'limegreen',

            
            'ACT_PDN' : 'crimson',

            
            'PRE_PDN' : 'orange',

            
            'SREF' : 'gold',

            
            'ACT_E' : 'lightskyblue',  # energy of states

            
            'PRE_E' : 'black',

            
            'READ_E' : 'white',

            
            'REF_E' : 'limegreen',

            
            'ACT_BACK_E' : 'lightgray',

            
            'PRE_BACK_E' : 'gray',

            
            'ACT_PDN_E' : 'crimson',

            
            'PRE_PDN_E' : 'orange',

            
            'SREF_E' : 'gold'

            
            }


            StatToKey = {

            
            'system.mem_ctrls_0.actEnergy'          : 'ACT_E',

            
            'system.mem_ctrls_0.preEnergy'          : 'PRE_E',

            
            'system.mem_ctrls_0.readEnergy'         : 'READ_E',

            
            'system.mem_ctrls_0.refreshEnergy'      : 'REF_E',

            
            'system.mem_ctrls_0.actBackEnergy'      : 'ACT_BACK_E',

            
            'system.mem_ctrls_0.preBackEnergy'      : 'PRE_BACK_E',

            
            'system.mem_ctrls_0.actPowerDownEnergy' : 'ACT_PDN_E',

            
            'system.mem_ctrls_0.prePowerDownEnergy' : 'PRE_PDN_E',

            
            'system.mem_ctrls_0.selfRefreshEnergy'  : 'SREF_E'

            
            }

            
            # Skipping write energy, the example script issues 100% reads by default

            
            # 'system.mem_ctrls_0.writeEnergy' : "WRITE"


            def plotLowPStates(plot_dir, stats_fname, bank_util_list, seqbytes_list,

            
                               delay_list):

            
                """

            
                plotLowPStates generates plots by parsing statistics output by the DRAM

            
                sweep simulation described in the the configs/dram/low_power_sweep.py

            
                script.


                The function outputs eps format images for the following plots

            
                (1) time spent in the DRAM Power states as a stacked bar chart

            
                (2) energy consumed by the DRAM Power states as a stacked bar chart

            
                (3) idle plot for the last stats dump corresponding to an idle period


                For all plots, the time and energy values of the first rank (i.e. rank0)

            
                are plotted because the way the script is written means stats across ranks

            
                are similar.


                @param plot_dir: the dir to output the plots

            
                @param stats_fname: the stats file name of the low power sweep sim

            
                @param bank_util_list: list of bank utilisation values (e.g. [1, 4, 8])

            
                @param seqbytes_list: list of seq_bytes values (e.g. [64, 456, 512])

            
                @param delay_list: list of itt max multipliers (e.g. [1, 20, 200])


                """

            
                stats_file = open(stats_fname, 'r')


                global bankUtilValues

            
                bankUtilValues = bank_util_list


                global seqBytesValues

            
                seqBytesValues = seqbytes_list


                global delayValues

            
                delayValues = delay_list

            
                initResults()


                # throw away the first two lines of the stats file

            
                stats_file.readline()

            
                stats_file.readline() # the 'Begin' line


                #######################################

            
                # Parse stats file and gather results

            
                ########################################


                for delay in delayValues:

            
                    for bank_util in bankUtilValues:

            
                        for seq_bytes in seqBytesValues:


                            for line in stats_file:

            
                                if 'Begin' in line:

            
                                    break


                                if len(line.strip()) == 0:

            
                                    continue


                                #### state time values ####

            
                                if 'system.mem_ctrls_0.memoryStateTime' in line:

            
                                    # remove leading and trailing white spaces

            
                                    line = line.strip()

            
                                    # Example format:

            
                                    # 'system.mem_ctrls_0.memoryStateTime::ACT    1000000'

            
                                    statistic, stime = line.split()[0:2]

            
                                    # Now grab the state, i.e. 'ACT'

            
                                    state = statistic.split('::')[1]

            
                                    # store the value of the stat in the results dict

            
                                    results[delay][bank_util][seq_bytes][state] = \

            
                                        int(stime)

            
                                #### state energy values ####

            
                                elif line.strip().split()[0] in StatToKey.keys():

            
                                    # Example format:

            
                                    # system.mem_ctrls_0.actEnergy                 35392980

            
                                    statistic, e_val = line.strip().split()[0:2]

            
                                    senergy = int(float(e_val))

            
                                    state = StatToKey[statistic]

            
                                    # store the value of the stat in the results dict

            
                                    results[delay][bank_util][seq_bytes][state] = senergy


                # To add last traffic gen idle period stats to the results dict

            
                for line in stats_file:

            
                    if 'system.mem_ctrls_0.memoryStateTime' in line:

            
                        line = line.strip() # remove leading and trailing white spaces

            
                        # Example format:

            
                        # 'system.mem_ctrls_0.memoryStateTime::ACT    1000000'

            
                        statistic, stime = line.split()[0:2]

            
                        # Now grab the state energy, .e.g 'ACT'

            
                        state = statistic.split('::')[1]

            
                        idleResults[state] = int(stime)

            
                        if state == 'ACT_PDN':

            
                            break


                ########################################

            
                # Call plot functions

            
                ########################################

            
                # one plot per delay value

            
                for delay in delayValues:

            
                    plot_path = plot_dir + delay + '-'


                    plotStackedStates(delay, States, 'IDLE', stateTimePlotName(plot_path),

            
                                      'Time (ps) spent in a power state')

            
                    plotStackedStates(delay, EnergyStates, 'ACT_E',

            
                                      stateEnergyPlotName(plot_path),

            
                                      'Energy (pJ) of a power state')

            
                plotIdle(plot_dir)


            def plotIdle(plot_dir):

            
                """

            
                Create a bar chart for the time spent in power states during the idle phase


                @param plot_dir: the dir to output the plots

            
                """

            
                fig, ax = plt.subplots()

            
                width = 0.35

            
                ind = np.arange(len(States))

            
                l1 = ax.bar(ind, map(lambda x : idleResults[x], States), width)


                ax.xaxis.set_ticks(ind + width/2)

            
                ax.xaxis.set_ticklabels(States)

            
                ax.set_ylabel('Time (ps) spent in a power state')

            
                fig.suptitle("Idle 50 us")


                print "saving plot:", idlePlotName(plot_dir)

            
                plt.savefig(idlePlotName(plot_dir), format='eps')

            
                plt.close(fig)


            def plotStackedStates(delay, states_list, bottom_state, plot_name, ylabel_str):

            
                """

            
                Create a stacked bar chart for the list that is passed in as arg, which

            
                is either time spent or energy consumed in power states.


                @param delay: one plot is output per delay value

            
                @param states_list: list of either time or energy state names

            
                @param bottom_state: the bottom-most component of the stacked bar

            
                @param plot_name: the file name of the image to write the plot to

            
                @param ylabel_str: Y-axis label depending on plotting time or energy

            
                """

            
                fig, ax = plt.subplots(1, len(bankUtilValues), sharey=True)

            
                fig.set_figheight(stackHeight)

            
                fig.set_figwidth(stackWidth)

            
                width = barWidth

            
                plt.rcParams.update({'font.size': plotFontSize})


                # Get the number of seq_bytes values

            
                N = len(seqBytesValues)

            
                ind = np.arange(N)


                for sub_idx, bank_util in enumerate(bankUtilValues):


                    l_states = {}

            
                    p_states = {}


                    # Must have a bottom of the stack first

            
                    state = bottom_state


                    l_states[state] = map(lambda x: results[delay][bank_util][x][state],

            
                                          seqBytesValues)

            
                    p_states[state] = ax[sub_idx].bar(ind, l_states[state], width,

            
                                                      color=StackColors[state])


                    time_sum = l_states[state]

            
                    for state in states_list[1:]:

            
                        l_states[state] = map(lambda x:

            
                                              results[delay][bank_util][x][state],

            
                                              seqBytesValues)

            
                        # Now add on top of the bottom = sum of values up until now

            
                        p_states[state] = ax[sub_idx].bar(ind, l_states[state], width,

            
                                                          color=StackColors[state],

            
                                                          bottom=time_sum)

            
                        # Now add the bit of the stack that we just ploted to the bottom

            
                        # resulting in a new bottom for the next iteration

            
                        time_sum = [prev_sum + new_s for prev_sum, new_s in \

            
                            zip(time_sum, l_states[state])]


                    ax[sub_idx].set_title('Bank util %s' % bank_util)

            
                    ax[sub_idx].xaxis.set_ticks(ind + width/2.)

            
                    ax[sub_idx].xaxis.set_ticklabels(seqBytesValues, rotation=45)

            
                    ax[sub_idx].set_xlabel('Seq. bytes')

            
                    if bank_util == bankUtilValues[0]:

            
                        ax[sub_idx].set_ylabel(ylabel_str)


                myFontSize='small'

            
                fontP = FontProperties()

            
                fontP.set_size(myFontSize)

            
                fig.legend(map(lambda x: p_states[x], states_list), states_list,

            
                           prop=fontP)


                plt.savefig(plot_name,  format='eps', bbox_inches='tight')

            
                print "saving plot:", plot_name

            
                plt.close(fig)


            # These plat name functions are also called in the main script

            
            def idlePlotName(plot_dir):

            
                return (plot_dir + 'idle.eps')


            def stateTimePlotName(plot_dir):

            
                return (plot_dir + 'state-time.eps')


            def stateEnergyPlotName(plot_dir):

            
                return (plot_dir + 'state-energy.eps')


            def initResults():

            
                for delay in delayValues:

            
                    results[delay] = {}

            
                    for bank_util in bankUtilValues:

            
                        results[delay][bank_util] = {}

            
                        for seq_bytes in seqBytesValues:

            
                            results[delay][bank_util][seq_bytes] = {}
	# Copyright (c) 2017 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: Radhika Jagtap

	import matplotlib
	matplotlib.use('Agg')
	import matplotlib.pyplot as plt
	from matplotlib.font_manager import FontProperties
	import numpy as np
	import os

	# global results dict
	results = {}
	idleResults = {}

	# global vars for bank utilisation and seq_bytes values swept in the experiment
	bankUtilValues = []
	seqBytesValues = []
	delayValues = []

	# settings for 3 values of bank util and 3 values of seq_bytes
	stackHeight = 6.0
	stackWidth = 18.0
	barWidth = 0.5
	plotFontSize = 18

	States = ['IDLE', 'ACT', 'REF', 'ACT_PDN', 'PRE_PDN', 'SREF']

	EnergyStates = ['ACT_E',
	'PRE_E',
	'READ_E',
	'REF_E',
	'ACT_BACK_E',
	'PRE_BACK_E',
	'ACT_PDN_E',
	'PRE_PDN_E',
	'SREF_E']

	StackColors = {
	'IDLE' : 'black', # time spent in states
	'ACT' : 'lightskyblue',
	'REF' : 'limegreen',
	'ACT_PDN' : 'crimson',
	'PRE_PDN' : 'orange',
	'SREF' : 'gold',
	'ACT_E' : 'lightskyblue', # energy of states
	'PRE_E' : 'black',
	'READ_E' : 'white',
	'REF_E' : 'limegreen',
	'ACT_BACK_E' : 'lightgray',
	'PRE_BACK_E' : 'gray',
	'ACT_PDN_E' : 'crimson',
	'PRE_PDN_E' : 'orange',
	'SREF_E' : 'gold'
	}

	StatToKey = {
	'system.mem_ctrls_0.actEnergy' : 'ACT_E',
	'system.mem_ctrls_0.preEnergy' : 'PRE_E',
	'system.mem_ctrls_0.readEnergy' : 'READ_E',
	'system.mem_ctrls_0.refreshEnergy' : 'REF_E',
	'system.mem_ctrls_0.actBackEnergy' : 'ACT_BACK_E',
	'system.mem_ctrls_0.preBackEnergy' : 'PRE_BACK_E',
	'system.mem_ctrls_0.actPowerDownEnergy' : 'ACT_PDN_E',
	'system.mem_ctrls_0.prePowerDownEnergy' : 'PRE_PDN_E',
	'system.mem_ctrls_0.selfRefreshEnergy' : 'SREF_E'
	}
	# Skipping write energy, the example script issues 100% reads by default
	# 'system.mem_ctrls_0.writeEnergy' : "WRITE"

	def plotLowPStates(plot_dir, stats_fname, bank_util_list, seqbytes_list,
	delay_list):
	"""
	plotLowPStates generates plots by parsing statistics output by the DRAM
	sweep simulation described in the the configs/dram/low_power_sweep.py
	script.

	The function outputs eps format images for the following plots
	(1) time spent in the DRAM Power states as a stacked bar chart
	(2) energy consumed by the DRAM Power states as a stacked bar chart
	(3) idle plot for the last stats dump corresponding to an idle period

	For all plots, the time and energy values of the first rank (i.e. rank0)
	are plotted because the way the script is written means stats across ranks
	are similar.

	@param plot_dir: the dir to output the plots
	@param stats_fname: the stats file name of the low power sweep sim
	@param bank_util_list: list of bank utilisation values (e.g. [1, 4, 8])
	@param seqbytes_list: list of seq_bytes values (e.g. [64, 456, 512])
	@param delay_list: list of itt max multipliers (e.g. [1, 20, 200])

	"""
	stats_file = open(stats_fname, 'r')

	global bankUtilValues
	bankUtilValues = bank_util_list

	global seqBytesValues
	seqBytesValues = seqbytes_list

	global delayValues
	delayValues = delay_list
	initResults()

	# throw away the first two lines of the stats file
	stats_file.readline()
	stats_file.readline() # the 'Begin' line

	#######################################
	# Parse stats file and gather results
	########################################

	for delay in delayValues:
	for bank_util in bankUtilValues:
	for seq_bytes in seqBytesValues:

	for line in stats_file:
	if 'Begin' in line:
	break

	if len(line.strip()) == 0:
	continue

	#### state time values ####
	if 'system.mem_ctrls_0.memoryStateTime' in line:
	# remove leading and trailing white spaces
	line = line.strip()
	# Example format:
	# 'system.mem_ctrls_0.memoryStateTime::ACT 1000000'
	statistic, stime = line.split()[0:2]
	# Now grab the state, i.e. 'ACT'
	state = statistic.split('::')[1]
	# store the value of the stat in the results dict
	results[delay][bank_util][seq_bytes][state] = \
	int(stime)
	#### state energy values ####
	elif line.strip().split()[0] in StatToKey.keys():
	# Example format:
	# system.mem_ctrls_0.actEnergy 35392980
	statistic, e_val = line.strip().split()[0:2]
	senergy = int(float(e_val))
	state = StatToKey[statistic]
	# store the value of the stat in the results dict
	results[delay][bank_util][seq_bytes][state] = senergy

	# To add last traffic gen idle period stats to the results dict
	for line in stats_file:
	if 'system.mem_ctrls_0.memoryStateTime' in line:
	line = line.strip() # remove leading and trailing white spaces
	# Example format:
	# 'system.mem_ctrls_0.memoryStateTime::ACT 1000000'
	statistic, stime = line.split()[0:2]
	# Now grab the state energy, .e.g 'ACT'
	state = statistic.split('::')[1]
	idleResults[state] = int(stime)
	if state == 'ACT_PDN':
	break

	########################################
	# Call plot functions
	########################################
	# one plot per delay value
	for delay in delayValues:
	plot_path = plot_dir + delay + '-'

	plotStackedStates(delay, States, 'IDLE', stateTimePlotName(plot_path),
	'Time (ps) spent in a power state')
	plotStackedStates(delay, EnergyStates, 'ACT_E',
	stateEnergyPlotName(plot_path),
	'Energy (pJ) of a power state')
	plotIdle(plot_dir)

	def plotIdle(plot_dir):
	"""
	Create a bar chart for the time spent in power states during the idle phase

	@param plot_dir: the dir to output the plots
	"""
	fig, ax = plt.subplots()
	width = 0.35
	ind = np.arange(len(States))
	l1 = ax.bar(ind, map(lambda x : idleResults[x], States), width)

	ax.xaxis.set_ticks(ind + width/2)
	ax.xaxis.set_ticklabels(States)
	ax.set_ylabel('Time (ps) spent in a power state')
	fig.suptitle("Idle 50 us")

	print "saving plot:", idlePlotName(plot_dir)
	plt.savefig(idlePlotName(plot_dir), format='eps')
	plt.close(fig)

	def plotStackedStates(delay, states_list, bottom_state, plot_name, ylabel_str):
	"""
	Create a stacked bar chart for the list that is passed in as arg, which
	is either time spent or energy consumed in power states.

	@param delay: one plot is output per delay value
	@param states_list: list of either time or energy state names
	@param bottom_state: the bottom-most component of the stacked bar
	@param plot_name: the file name of the image to write the plot to
	@param ylabel_str: Y-axis label depending on plotting time or energy
	"""
	fig, ax = plt.subplots(1, len(bankUtilValues), sharey=True)
	fig.set_figheight(stackHeight)
	fig.set_figwidth(stackWidth)
	width = barWidth
	plt.rcParams.update({'font.size': plotFontSize})

	# Get the number of seq_bytes values
	N = len(seqBytesValues)
	ind = np.arange(N)

	for sub_idx, bank_util in enumerate(bankUtilValues):

	l_states = {}
	p_states = {}

	# Must have a bottom of the stack first
	state = bottom_state

	l_states[state] = map(lambda x: results[delay][bank_util][x][state],
	seqBytesValues)
	p_states[state] = ax[sub_idx].bar(ind, l_states[state], width,
	color=StackColors[state])

	time_sum = l_states[state]
	for state in states_list[1:]:
	l_states[state] = map(lambda x:
	results[delay][bank_util][x][state],
	seqBytesValues)
	# Now add on top of the bottom = sum of values up until now
	p_states[state] = ax[sub_idx].bar(ind, l_states[state], width,
	color=StackColors[state],
	bottom=time_sum)
	# Now add the bit of the stack that we just ploted to the bottom
	# resulting in a new bottom for the next iteration
	time_sum = [prev_sum + new_s for prev_sum, new_s in \
	zip(time_sum, l_states[state])]

	ax[sub_idx].set_title('Bank util %s' % bank_util)
	ax[sub_idx].xaxis.set_ticks(ind + width/2.)
	ax[sub_idx].xaxis.set_ticklabels(seqBytesValues, rotation=45)
	ax[sub_idx].set_xlabel('Seq. bytes')
	if bank_util == bankUtilValues[0]:
	ax[sub_idx].set_ylabel(ylabel_str)

	myFontSize='small'
	fontP = FontProperties()
	fontP.set_size(myFontSize)
	fig.legend(map(lambda x: p_states[x], states_list), states_list,
	prop=fontP)

	plt.savefig(plot_name, format='eps', bbox_inches='tight')
	print "saving plot:", plot_name
	plt.close(fig)

	# These plat name functions are also called in the main script
	def idlePlotName(plot_dir):
	return (plot_dir + 'idle.eps')

	def stateTimePlotName(plot_dir):
	return (plot_dir + 'state-time.eps')

	def stateEnergyPlotName(plot_dir):
	return (plot_dir + 'state-energy.eps')

	def initResults():
	for delay in delayValues:
	results[delay] = {}
	for bank_util in bankUtilValues:
	results[delay][bank_util] = {}
	for seq_bytes in seqBytesValues:
	results[delay][bank_util][seq_bytes] = {}