d11c40dcac
This ensures `isort` is applied to all files in the repo. Change-Id: Ib7ced1c924ef1639542bf0d1a01c5737f6ba43e9
334 lines
12 KiB
Python
Executable File
334 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 os
|
|
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
from matplotlib.font_manager import FontProperties
|
|
|
|
# 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)
|
|
|
|
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 list(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, [idleResults[x] for x in 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] = [
|
|
results[delay][bank_util][x][state] for x in 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] = [
|
|
results[delay][bank_util][x][state] for x in 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(f"Bank util {bank_util}")
|
|
ax[sub_idx].xaxis.set_ticks(ind + width / 2.0)
|
|
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([p_states[x] for x in 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] = {}
|