xref: /gem5/ext/drampower/src/MemoryPowerModel.h

/*
 * Copyright (c) 2012-2014, TU Delft
 * Copyright (c) 2012-2014, TU Eindhoven
 * Copyright (c) 2012-2014, TU Kaiserslautern
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of the copyright holder 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
 * HOLDER 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: Karthik Chandrasekar
 *          Matthias Jung
 *          Omar Naji
 *          Subash Kannoth
 *          Éder F. Zulian
 *          Felipe S. Prado
 *
 */

#ifndef MEMORY_POWER_MODEL_H
#define MEMORY_POWER_MODEL_H

#include <numeric>
#include "MemorySpecification.h"
#include "MemBankWiseParams.h"
#include "CommandAnalysis.h"

namespace Data {
class MemoryPowerModel {
 public:

  MemoryPowerModel();

  // Calculate energy and average power consumption for the given memory
  // command trace
  void power_calc(const MemorySpecification& memSpec,
                  const CommandAnalysis& c,
                  int term,
                  const MemBankWiseParams& bwPowerParams);

  // Used to calculate self-refresh active energy
  static double engy_sref(double idd6,
                          double idd3n,
                          double idd5,
                          double vdd,
                          double sref_cycles_idd6,
                          double sref_ref_act_cycles,
                          double sref_ref_pre_cycles,
                          double spup_ref_act_cycles,
                          double spup_ref_pre_cycles,
                          double clk);
  static double engy_sref_banks(double idd6,
                                double idd3n,
                                double idd5,
                                double vdd,
                                double sref_cycles,
                                double sref_ref_act_cycles,
                                double sref_ref_pre_cycles,
                                double spup_ref_act_cycles,
                                double spup_ref_pre_cycles,
                                double clk,
                                double esharedPASR,
                                const MemBankWiseParams& bwPowerParams,
                                unsigned bnkIdx,
                                int64_t nbrofBanks);

  int64_t total_cycles;

  int64_t window_cycles;

  struct Energy {
    // Total energy of all activates
    double act_energy;
    std::vector<double> act_energy_banks;

    // Total energy of all precharges
    double pre_energy;
    std::vector<double> pre_energy_banks;

    // Total energy of all reads
    double read_energy;
    std::vector<double> read_energy_banks;

    // Total energy of all writes
    double write_energy;
    std::vector<double> write_energy_banks;

    // Total energy of all refreshes
    double ref_energy;
    std::vector<double> ref_energy_banks;

    // Bankwise refresh energy
    std::vector<double> refb_energy_banks;

    // Total background energy of all active standby cycles
    double act_stdby_energy;
    std::vector<double> act_stdby_energy_banks;

    // Total background energy of all precharge standby cycles
    double pre_stdby_energy;
    std::vector<double> pre_stdby_energy_banks;

    // Total energy of idle cycles in the active mode
    double idle_energy_act;
    std::vector<double> idle_energy_act_banks;

    // Total energy of idle cycles in the precharge mode
    double idle_energy_pre;
    std::vector<double> idle_energy_pre_banks;

    // Total trace/pattern energy
    double total_energy;
    std::vector<double> total_energy_banks;

    // Window energy
    double window_energy;

    // Average Power
    double average_power;

    // Energy consumed in active/precharged fast/slow-exit modes
    double f_act_pd_energy;
    std::vector<double> f_act_pd_energy_banks;

    double f_pre_pd_energy;
    std::vector<double> f_pre_pd_energy_banks;

    double s_act_pd_energy;
    std::vector<double> s_act_pd_energy_banks;

    double s_pre_pd_energy;
    std::vector<double> s_pre_pd_energy_banks;

    // Energy consumed in self-refresh mode
    double sref_energy;
    std::vector<double> sref_energy_banks;

    // Energy consumed in auto-refresh during self-refresh mode
    double sref_ref_energy;
    std::vector<double> sref_ref_energy_banks;

    double sref_ref_act_energy;
    std::vector<double> sref_ref_act_energy_banks;

    double sref_ref_pre_energy;
    std::vector<double> sref_ref_pre_energy_banks;

    // Energy consumed in powering-up from self-refresh mode
    double spup_energy;
    std::vector<double> spup_energy_banks;

    // Energy consumed in auto-refresh during self-refresh power-up
    double spup_ref_energy;
    std::vector<double> spup_ref_energy_banks;

    double spup_ref_act_energy;
    std::vector<double> spup_ref_act_energy_banks;

    double spup_ref_pre_energy;
    std::vector<double> spup_ref_pre_energy_banks;

    // Energy consumed in powering-up from active/precharged power-down modes
    double pup_act_energy;
    std::vector<double> pup_act_energy_banks;

    double pup_pre_energy;
    std::vector<double> pup_pre_energy_banks;

    // Energy consumed by IO and Termination
    double read_io_energy;     // Read IO Energy
    double write_term_energy;  // Write Termination Energy
    double read_oterm_energy;  // Read Termination Energy from idle rank
    double write_oterm_energy; // Write Termination Energy from idle rank
    // Total IO and Termination Energy
    double io_term_energy;
  };

  struct Power {
    // Power measures corresponding to IO and Termination
    double IO_power;     // Read IO Power
    double WR_ODT_power; // Write ODT Power
    double TermRD_power; // Read Termination in idle rank (in dual-rank systems)
    double TermWR_power; // Write Termination in idle rank (in dual-rank systems)

    // Average Power
    double average_power;

    // Window Average Power
    double window_average_power;
  };

  // Print the power and energy
  void power_print(const MemorySpecification& memSpec,
                   int                 term,
                   const CommandAnalysis& c,
                   bool bankwiseMode) const;

  // To derive IO and Termination Power measures using DRAM specification
  void io_term_power(const MemorySpecification& memSpec);

  Energy energy;
  Power  power;

 private:
  double calcIoTermEnergy(int64_t cycles, double period, double power, int64_t numBits) const;
  // Sum quantities (e.g., operations, energy, cycles) that are stored in a per bank basis returning the total amount.
  template <typename T> T sum(const std::vector<T> vec) const { return std::accumulate(vec.begin(), vec.end(), static_cast<T>(0)); }
};

class EnergyDomain {
 public:
  EnergyDomain(double voltage, double clkPeriod) :
    voltage(voltage),
    clkPeriod(clkPeriod)
  {}

  double calcTivEnergy(int64_t cycles, double current) const;
  double getVoltage() const{ return voltage; };
 private:
  const double voltage;
  const double clkPeriod;
};

}
#endif // ifndef MEMORY_POWER_MODEL_H