diff options
Diffstat (limited to 'util/plot_dram/PlotPowerStates.py')
| -rwxr-xr-x | util/plot_dram/PlotPowerStates.py | 308 |
1 files changed, 308 insertions, 0 deletions
diff --git a/util/plot_dram/PlotPowerStates.py b/util/plot_dram/PlotPowerStates.py new file mode 100755 index 000000000..8dca0e069 --- /dev/null +++ b/util/plot_dram/PlotPowerStates.py @@ -0,0 +1,308 @@ +# 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] = {} |