52b3f58a8c
Change-Id: I2a165d3130c1464a73823046e4c7b03ba0355459 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/25457 Reviewed-by: Daniel Carvalho <odanrc@yahoo.com.br> Reviewed-by: Bobby R. Bruce <bbruce@ucdavis.edu> Tested-by: kokoro <noreply+kokoro@google.com> Maintainer: Bobby R. Bruce <bbruce@ucdavis.edu>
307 lines
12 KiB
Python
Executable File
307 lines
12 KiB
Python
Executable File
# 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.
|
|
|
|
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] = {}
|