path: root/util/plot_dram/PlotPowerStates.py

# 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] = {}