ext/drampower/src/MemoryPowerModel.h - arm/gem5 - Git at Google

 /*
  * 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
	/*
	* 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