/* * 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 #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 act_energy_banks; // Total energy of all precharges double pre_energy; std::vector pre_energy_banks; // Total energy of all reads double read_energy; std::vector read_energy_banks; // Total energy of all writes double write_energy; std::vector write_energy_banks; // Total energy of all refreshes double ref_energy; std::vector ref_energy_banks; // Bankwise refresh energy std::vector refb_energy_banks; // Total background energy of all active standby cycles double act_stdby_energy; std::vector act_stdby_energy_banks; // Total background energy of all precharge standby cycles double pre_stdby_energy; std::vector pre_stdby_energy_banks; // Total energy of idle cycles in the active mode double idle_energy_act; std::vector idle_energy_act_banks; // Total energy of idle cycles in the precharge mode double idle_energy_pre; std::vector idle_energy_pre_banks; // Total trace/pattern energy double total_energy; std::vector 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 f_act_pd_energy_banks; double f_pre_pd_energy; std::vector f_pre_pd_energy_banks; double s_act_pd_energy; std::vector s_act_pd_energy_banks; double s_pre_pd_energy; std::vector s_pre_pd_energy_banks; // Energy consumed in self-refresh mode double sref_energy; std::vector sref_energy_banks; // Energy consumed in auto-refresh during self-refresh mode double sref_ref_energy; std::vector sref_ref_energy_banks; double sref_ref_act_energy; std::vector sref_ref_act_energy_banks; double sref_ref_pre_energy; std::vector sref_ref_pre_energy_banks; // Energy consumed in powering-up from self-refresh mode double spup_energy; std::vector spup_energy_banks; // Energy consumed in auto-refresh during self-refresh power-up double spup_ref_energy; std::vector spup_ref_energy_banks; double spup_ref_act_energy; std::vector spup_ref_act_energy_banks; double spup_ref_pre_energy; std::vector spup_ref_pre_energy_banks; // Energy consumed in powering-up from active/precharged power-down modes double pup_act_energy; std::vector pup_act_energy_banks; double pup_pre_energy; std::vector 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 T sum(const std::vector vec) const { return std::accumulate(vec.begin(), vec.end(), static_cast(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