| /* |
| * 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, Sven Goossens |
| * |
| */ |
| |
| #include <fstream> |
| #include <algorithm> |
| #include <sstream> |
| |
| #include "CommandAnalysis.h" |
| #include "CmdScheduler.h" |
| |
| using namespace Data; |
| using namespace std; |
| |
| CommandAnalysis::CommandAnalysis() |
| { |
| } |
| |
| CommandAnalysis::CommandAnalysis(const int nbrofBanks) |
| { |
| // Initializing all counters and variables |
| |
| numberofacts = 0; |
| numberofpres = 0; |
| numberofreads = 0; |
| numberofwrites = 0; |
| numberofrefs = 0; |
| f_act_pdns = 0; |
| s_act_pdns = 0; |
| f_pre_pdns = 0; |
| s_pre_pdns = 0; |
| numberofsrefs = 0; |
| |
| pop = 0; |
| init = 0; |
| zero = 0; |
| |
| actcycles = 0; |
| precycles = 0; |
| f_act_pdcycles = 0; |
| s_act_pdcycles = 0; |
| f_pre_pdcycles = 0; |
| s_pre_pdcycles = 0; |
| pup_act_cycles = 0; |
| pup_pre_cycles = 0; |
| sref_cycles = 0; |
| spup_cycles = 0; |
| sref_ref_act_cycles = 0; |
| sref_ref_pre_cycles = 0; |
| spup_ref_act_cycles = 0; |
| spup_ref_pre_cycles = 0; |
| idlecycles_act = 0; |
| idlecycles_pre = 0; |
| |
| latest_act_cycle = -1; |
| latest_pre_cycle = -1; |
| latest_read_cycle = -1; |
| latest_write_cycle = -1; |
| end_read_op = 0; |
| end_write_op = 0; |
| end_act_op = 0; |
| |
| first_act_cycle = 0; |
| last_pre_cycle = 0; |
| |
| bankstate.resize(nbrofBanks, 0); |
| last_states.resize(nbrofBanks); |
| mem_state = 0; |
| |
| sref_cycle = 0; |
| pdn_cycle = 0; |
| |
| cmd_list.clear(); |
| full_cmd_list.resize(1, MemCommand::PRE); |
| cached_cmd.clear(); |
| activation_cycle.resize(nbrofBanks, 0); |
| } |
| |
| // function to clear all arrays |
| void CommandAnalysis::clear() |
| { |
| cached_cmd.clear(); |
| cmd_list.clear(); |
| full_cmd_list.clear(); |
| last_states.clear(); |
| bankstate.clear(); |
| } |
| |
| // Reads through the trace file, identifies the timestamp, command and bank |
| // If the issued command includes an auto-precharge, adds an explicit |
| // precharge to a cached command list and computes the precharge offset from the |
| // issued command timestamp, when the auto-precharge would kick in |
| |
| void CommandAnalysis::getCommands(const Data::MemorySpecification& memSpec, |
| const int nbrofBanks, std::vector<MemCommand>& list, bool lastupdate) |
| { |
| for (vector<MemCommand>::const_iterator i = list.begin(); i != list.end(); ++i) { |
| const MemCommand& cmd = *i; |
| cmd_list.push_back(cmd); |
| |
| MemCommand::cmds cmdType = cmd.getType(); |
| if (cmdType == MemCommand::ACT) { |
| activation_cycle[cmd.getBank()] = cmd.getTimeInt64(); |
| } else if (cmdType == MemCommand::RDA || cmdType == MemCommand::WRA) { |
| // Remove auto-precharge flag from command |
| cmd_list.back().setType(cmd.typeWithoutAutoPrechargeFlag()); |
| |
| // Add the auto precharge to the list of cached_cmds |
| int64_t preTime = max(cmd.getTimeInt64() + cmd.getPrechargeOffset(memSpec, cmdType), |
| activation_cycle[cmd.getBank()] + memSpec.memTimingSpec.RAS); |
| cached_cmd.push_back(MemCommand(MemCommand::PRE, cmd.getBank(), static_cast<double>(preTime))); |
| } |
| } |
| pop = 0; |
| // Note: the extra pre-cmds at the end of the lists, and the cast to double |
| // of the size vector is probably not desirable. |
| cmd_list.push_back(MemCommand::PRE); |
| cached_cmd.push_back(MemCommand::PRE); |
| analyse_commands(nbrofBanks, memSpec, cmd_list.size()-1, |
| cached_cmd.size()-1, lastupdate); |
| cmd_list.clear(); |
| cached_cmd.clear(); |
| } // CommandAnalysis::getCommands |
| |
| // Checks the auto-precharge cached command list and inserts the explicit |
| // precharges with the appropriate timestamp in the original command list |
| // (by merging) based on their offset from the issuing command. Calls the |
| // evaluate function to analyse this expanded list of commands. |
| |
| void CommandAnalysis::analyse_commands(const int nbrofBanks, |
| Data::MemorySpecification memSpec, int64_t nCommands, int64_t nCached, bool lastupdate) |
| { |
| full_cmd_list.resize(1, MemCommand::PRE); |
| unsigned mCommands = 0; |
| unsigned mCached = 0; |
| for (unsigned i = 0; i < nCommands + nCached + 1; i++) { |
| if (cached_cmd.size() > 1) { |
| if ((cmd_list[mCommands].getTime() > 1) && (init == 0)) { |
| full_cmd_list[i].setType(MemCommand::PREA); |
| init = 1; |
| pop = 1; |
| } else { |
| init = 1; |
| if ((cached_cmd[mCached].getTime() > 0) && (cmd_list. |
| at(mCommands).getTime() < cached_cmd[mCached]. |
| getTime()) && ((cmd_list[mCommands].getTime() > 0) || |
| ((cmd_list[mCommands].getTime() == 0) && (cmd_list[mCommands]. |
| getType() != MemCommand::PRE)))) { |
| full_cmd_list[i] = cmd_list[mCommands]; |
| mCommands++; |
| } else if ((cached_cmd[mCached].getTime() > 0) && (cmd_list[mCommands]. |
| getTime() >= cached_cmd[mCached].getTime())) { |
| full_cmd_list[i] = cached_cmd[mCached]; |
| mCached++; |
| } else if (cached_cmd[mCached].getTime() == 0) { |
| if ((cmd_list[mCommands].getTime() > 0) || ((cmd_list[mCommands]. |
| getTime() == 0) && (cmd_list[mCommands]. |
| getType() != MemCommand::PRE))) { |
| full_cmd_list[i] = cmd_list[mCommands]; |
| mCommands++; |
| } |
| } else if (cmd_list[mCommands].getTime() == 0) { |
| full_cmd_list[i] = cached_cmd[mCached]; |
| mCached++; |
| } |
| } |
| } else { |
| if ((cmd_list[mCommands].getTime() > 1) && (init == 0)) { |
| full_cmd_list[i].setType(MemCommand::PREA); |
| init = 1; |
| pop = 1; |
| } else { |
| init = 1; |
| if ((cmd_list[mCommands].getTime() > 0) || ((cmd_list. |
| at(mCommands).getTime() == 0) && (cmd_list[mCommands]. |
| getType() != MemCommand::PRE))) { |
| full_cmd_list[i] = cmd_list[mCommands]; |
| mCommands++; |
| } |
| } |
| } |
| full_cmd_list.resize(full_cmd_list.size() + 1, MemCommand::PRE); |
| } |
| |
| full_cmd_list.pop_back(); |
| if (pop == 0) { |
| full_cmd_list.pop_back(); |
| } |
| if (lastupdate) { |
| full_cmd_list.resize(full_cmd_list.size() + 1, MemCommand::NOP); |
| full_cmd_list[full_cmd_list.size() - 1].setTime(full_cmd_list |
| [full_cmd_list.size() - 2].getTime() + timeToCompletion(memSpec, |
| full_cmd_list[full_cmd_list.size() - 2].getType()) - 1); |
| } |
| |
| evaluate(memSpec, full_cmd_list, nbrofBanks); |
| } // CommandAnalysis::analyse_commands |
| |
| // To get the time of completion of the issued command |
| // Derived based on JEDEC specifications |
| |
| int CommandAnalysis::timeToCompletion(const MemorySpecification& |
| memSpec, MemCommand::cmds type) |
| { |
| int offset = 0; |
| const MemTimingSpec& memTimingSpec = memSpec.memTimingSpec; |
| const MemArchitectureSpec& memArchSpec = memSpec.memArchSpec; |
| |
| if (type == MemCommand::RD) { |
| offset = static_cast<int>(memTimingSpec.RL + |
| memTimingSpec.DQSCK + 1 + (memArchSpec.burstLength / |
| memArchSpec.dataRate)); |
| } else if (type == MemCommand::WR) { |
| offset = static_cast<int>(memTimingSpec.WL + |
| (memArchSpec.burstLength / memArchSpec.dataRate) + |
| memTimingSpec.WR); |
| } else if (type == MemCommand::ACT) { |
| offset = static_cast<int>(memTimingSpec.RCD); |
| } else if ((type == MemCommand::PRE) || (type == MemCommand::PREA)) { |
| offset = static_cast<int>(memTimingSpec.RP); |
| } |
| return offset; |
| } // CommandAnalysis::timeToCompletion |
| |
| // Used to analyse a given list of commands and identify command timings |
| // and memory state transitions |
| void CommandAnalysis::evaluate(const MemorySpecification& memSpec, |
| vector<MemCommand>& cmd_list, int nbrofBanks) |
| { |
| // for each command identify timestamp, type and bank |
| for (unsigned cmd_list_counter = 0; cmd_list_counter < cmd_list.size(); |
| cmd_list_counter++) { |
| // For command type |
| int type = cmd_list[cmd_list_counter].getType(); |
| // For command bank |
| int bank = cmd_list[cmd_list_counter].getBank(); |
| // Command Issue timestamp in clock cycles (cc) |
| int64_t timestamp = cmd_list[cmd_list_counter].getTimeInt64(); |
| |
| if (type == MemCommand::ACT) { |
| // If command is ACT - update number of acts, bank state of the |
| // target bank, first and latest activation cycle and the memory |
| // state. Update the number of precharged/idle-precharged cycles. |
| numberofacts++; |
| if (bankstate[bank] == 1) { |
| printWarning("Bank is already active!", type, timestamp, bank); |
| } |
| bankstate[bank] = 1; |
| if (mem_state == 0) { |
| first_act_cycle = timestamp; |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| } |
| latest_act_cycle = timestamp; |
| mem_state++; |
| } else if (type == MemCommand::RD) { |
| // If command is RD - update number of reads and read cycle. Check |
| // for active idle cycles (if any). |
| if (bankstate[bank] == 0) { |
| printWarning("Bank is not active!", type, timestamp, bank); |
| } |
| numberofreads++; |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| latest_read_cycle = timestamp; |
| } else if (type == MemCommand::WR) { |
| // If command is WR - update number of writes and write cycle. Check |
| // for active idle cycles (if any). |
| if (bankstate[bank] == 0) { |
| printWarning("Bank is not active!", type, timestamp, bank); |
| } |
| numberofwrites++; |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| latest_write_cycle = timestamp; |
| } else if (type == MemCommand::REF) { |
| // If command is REF - update number of refreshes, set bank state of |
| // all banks to ACT, set the last PRE cycles at RFC-RP cycles from |
| // timestamp, set the number of active cycles to RFC-RP and check |
| // for active and precharged cycles and idle active and idle |
| // precharged cycles before refresh. Change memory state to 0. |
| printWarningIfActive("One or more banks are active! REF requires all banks to be precharged.", type, timestamp, bank); |
| numberofrefs++; |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| first_act_cycle = timestamp; |
| precycles += max(zero, timestamp - last_pre_cycle); |
| last_pre_cycle = timestamp + memSpec.memTimingSpec.RFC - |
| memSpec.memTimingSpec.RP; |
| latest_pre_cycle = last_pre_cycle; |
| actcycles += memSpec.memTimingSpec.RFC - memSpec.memTimingSpec.RP; |
| mem_state = 0; |
| for (int j = 0; j < nbrofBanks; j++) { |
| bankstate[j] = 0; |
| } |
| } else if (type == MemCommand::PRE) { |
| // If command is explicit PRE - update number of precharges, bank |
| // state of the target bank and last and latest precharge cycle. |
| // Calculate the number of active cycles if the memory was in the |
| // active state before, but there is a state transition to PRE now. |
| // If not, update the number of precharged cycles and idle cycles. |
| // Update memory state if needed. |
| if (bankstate[bank] == 1) { |
| numberofpres++; |
| } |
| bankstate[bank] = 0; |
| |
| if (mem_state == 1) { |
| actcycles += max(zero, timestamp - first_act_cycle); |
| last_pre_cycle = timestamp; |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| } else if (mem_state == 0) { |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| last_pre_cycle = timestamp; |
| } |
| latest_pre_cycle = timestamp; |
| if (mem_state > 0) { |
| mem_state--; |
| } else { |
| mem_state = 0; |
| } |
| } else if (type == MemCommand::PREA) { |
| // If command is explicit PREA (precharge all banks) - update |
| // number of precharges by the number of banks, update the bank |
| // state of all banks to PRE and set the precharge cycle. |
| // Calculate the number of active cycles if the memory was in the |
| // active state before, but there is a state transition to PRE now. |
| // If not, update the number of precharged cycles and idle cycles. |
| if (timestamp == 0) { |
| numberofpres += 0; |
| } else { |
| numberofpres += mem_state; |
| } |
| |
| if (mem_state > 0) { |
| actcycles += max(zero, timestamp - first_act_cycle); |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| } else if (mem_state == 0) { |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| } |
| |
| latest_pre_cycle = timestamp; |
| last_pre_cycle = timestamp; |
| |
| mem_state = 0; |
| |
| for (int j = 0; j < nbrofBanks; j++) { |
| bankstate[j] = 0; |
| } |
| } else if (type == MemCommand::PDN_F_ACT) { |
| // If command is fast-exit active power-down - update number of |
| // power-downs, set the power-down cycle and the memory mode to |
| // fast-exit active power-down. Save states of all the banks from |
| // the cycle before entering active power-down, to be returned to |
| // after powering-up. Update active and active idle cycles. |
| printWarningIfNotActive("All banks are precharged! Incorrect use of Active Power-Down.", type, timestamp, bank); |
| f_act_pdns++; |
| for (int j = 0; j < nbrofBanks; j++) { |
| last_states[j] = bankstate[j]; |
| } |
| pdn_cycle = timestamp; |
| actcycles += max(zero, timestamp - first_act_cycle); |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| mem_state = CommandAnalysis::MS_PDN_F_ACT; |
| } else if (type == MemCommand::PDN_S_ACT) { |
| // If command is slow-exit active power-down - update number of |
| // power-downs, set the power-down cycle and the memory mode to |
| // slow-exit active power-down. Save states of all the banks from |
| // the cycle before entering active power-down, to be returned to |
| // after powering-up. Update active and active idle cycles. |
| printWarningIfNotActive("All banks are precharged! Incorrect use of Active Power-Down.", type, timestamp, bank); |
| s_act_pdns++; |
| for (int j = 0; j < nbrofBanks; j++) { |
| last_states[j] = bankstate[j]; |
| } |
| pdn_cycle = timestamp; |
| actcycles += max(zero, timestamp - first_act_cycle); |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| mem_state = CommandAnalysis::MS_PDN_S_ACT; |
| } else if (type == MemCommand::PDN_F_PRE) { |
| // If command is fast-exit precharged power-down - update number of |
| // power-downs, set the power-down cycle and the memory mode to |
| // fast-exit precahrged power-down. Update precharged and precharged |
| // idle cycles. |
| printWarningIfActive("One or more banks are active! Incorrect use of Precharged Power-Down.", type, timestamp, bank); |
| f_pre_pdns++; |
| pdn_cycle = timestamp; |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| mem_state = CommandAnalysis::MS_PDN_F_PRE; |
| } else if (type == MemCommand::PDN_S_PRE) { |
| // If command is slow-exit precharged power-down - update number of |
| // power-downs, set the power-down cycle and the memory mode to |
| // slow-exit precahrged power-down. Update precharged and precharged |
| // idle cycles. |
| printWarningIfActive("One or more banks are active! Incorrect use of Precharged Power-Down.", type, timestamp, bank); |
| s_pre_pdns++; |
| pdn_cycle = timestamp; |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| mem_state = CommandAnalysis::MS_PDN_S_PRE; |
| } else if (type == MemCommand::PUP_ACT) { |
| // If command is power-up in the active mode - check the power-down |
| // exit-mode employed (fast or slow), update the number of power-down |
| // and power-up cycles and the latest and first act cycle. Also, reset |
| // all the individual bank states to the respective saved states |
| // before entering power-down. |
| if (mem_state == CommandAnalysis::MS_PDN_F_ACT) { |
| f_act_pdcycles += max(zero, timestamp - pdn_cycle); |
| pup_act_cycles += memSpec.memTimingSpec.XP; |
| latest_act_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XP - memSpec.memTimingSpec.RCD); |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_ACT) { |
| s_act_pdcycles += max(zero, timestamp - pdn_cycle); |
| if (memSpec.memArchSpec.dll == false) { |
| pup_act_cycles += memSpec.memTimingSpec.XP; |
| latest_act_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XP - memSpec.memTimingSpec.RCD); |
| } else { |
| pup_act_cycles += memSpec.memTimingSpec.XPDLL - |
| memSpec.memTimingSpec.RCD; |
| latest_act_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XPDLL - |
| (2 * memSpec.memTimingSpec.RCD)); |
| } |
| } else if ((mem_state != CommandAnalysis::MS_PDN_S_ACT) || (mem_state != |
| CommandAnalysis::MS_PDN_F_ACT)) { |
| cerr << "Incorrect use of Active Power-Up!" << endl; |
| } |
| mem_state = 0; |
| for (int j = 0; j < nbrofBanks; j++) { |
| bankstate[j] = last_states[j]; |
| mem_state += last_states[j]; |
| } |
| first_act_cycle = timestamp; |
| } else if (type == MemCommand::PUP_PRE) { |
| // If command is power-up in the precharged mode - check the power-down |
| // exit-mode employed (fast or slow), update the number of power-down |
| // and power-up cycles and the latest and last pre cycle. |
| if (mem_state == CommandAnalysis::MS_PDN_F_PRE) { |
| f_pre_pdcycles += max(zero, timestamp - pdn_cycle); |
| pup_pre_cycles += memSpec.memTimingSpec.XP; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XP - memSpec.memTimingSpec.RP); |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_PRE) { |
| s_pre_pdcycles += max(zero, timestamp - pdn_cycle); |
| if (memSpec.memArchSpec.dll == false) { |
| pup_pre_cycles += memSpec.memTimingSpec.XP; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XP - memSpec.memTimingSpec.RP); |
| } else { |
| pup_pre_cycles += memSpec.memTimingSpec.XPDLL - |
| memSpec.memTimingSpec.RCD; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XPDLL - memSpec.memTimingSpec.RCD - |
| memSpec.memTimingSpec.RP); |
| } |
| } else if ((mem_state != CommandAnalysis::MS_PDN_S_PRE) || (mem_state != |
| CommandAnalysis::MS_PDN_F_PRE)) { |
| cerr << "Incorrect use of Precharged Power-Up!" << endl; |
| } |
| mem_state = 0; |
| last_pre_cycle = timestamp; |
| } else if (type == MemCommand::SREN) { |
| // If command is self-refresh - update number of self-refreshes, |
| // set memory state to SREF, update precharge and idle precharge |
| // cycles and set the self-refresh cycle. |
| printWarningIfActive("One or more banks are active! SREF requires all banks to be precharged.", type, timestamp, bank); |
| numberofsrefs++; |
| sref_cycle = timestamp; |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| mem_state = CommandAnalysis::MS_SREF; |
| } else if (type == MemCommand::SREX) { |
| // If command is self-refresh exit - update the number of self-refresh |
| // clock cycles, number of active and precharged auto-refresh clock |
| // cycles during self-refresh and self-refresh exit based on the number |
| // of cycles in the self-refresh mode and auto-refresh duration (RFC). |
| // Set the last and latest precharge cycle accordingly and set the |
| // memory state to 0. |
| if (mem_state != CommandAnalysis::MS_SREF) { |
| cerr << "Incorrect use of Self-Refresh Power-Up!" << endl; |
| } |
| if (max(zero, timestamp - sref_cycle) >= memSpec.memTimingSpec.RFC) { |
| sref_cycles += max(zero, timestamp - sref_cycle |
| - memSpec.memTimingSpec.RFC); |
| sref_ref_act_cycles += memSpec.memTimingSpec.RFC - |
| memSpec.memTimingSpec.RP; |
| sref_ref_pre_cycles += memSpec.memTimingSpec.RP; |
| last_pre_cycle = timestamp; |
| if (memSpec.memArchSpec.dll == false) { |
| spup_cycles += memSpec.memTimingSpec.XS; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XS - memSpec.memTimingSpec.RP); |
| } else { |
| spup_cycles += memSpec.memTimingSpec.XSDLL - |
| memSpec.memTimingSpec.RCD; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XSDLL - memSpec.memTimingSpec.RCD |
| - memSpec.memTimingSpec.RP); |
| } |
| } else { |
| int64_t sref_diff = memSpec.memTimingSpec.RFC - memSpec.memTimingSpec.RP; |
| int64_t sref_pre = max(zero, timestamp - sref_cycle - sref_diff); |
| int64_t spup_pre = memSpec.memTimingSpec.RP - sref_pre; |
| int64_t sref_act = max(zero, timestamp - sref_cycle); |
| int64_t spup_act = memSpec.memTimingSpec.RFC - sref_act; |
| |
| if (max(zero, timestamp - sref_cycle) >= sref_diff) { |
| sref_ref_act_cycles += sref_diff; |
| sref_ref_pre_cycles += sref_pre; |
| spup_ref_pre_cycles += spup_pre; |
| last_pre_cycle = timestamp + spup_pre; |
| if (memSpec.memArchSpec.dll == false) { |
| spup_cycles += memSpec.memTimingSpec.XS - spup_pre; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XS - spup_pre - |
| memSpec.memTimingSpec.RP); |
| } else { |
| spup_cycles += memSpec.memTimingSpec.XSDLL - |
| memSpec.memTimingSpec.RCD - spup_pre; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XSDLL - memSpec.memTimingSpec.RCD - |
| spup_pre - memSpec.memTimingSpec.RP); |
| } |
| } else { |
| sref_ref_act_cycles += sref_act; |
| spup_ref_act_cycles += spup_act; |
| spup_ref_pre_cycles += memSpec.memTimingSpec.RP; |
| last_pre_cycle = timestamp + spup_act + memSpec.memTimingSpec.RP; |
| if (memSpec.memArchSpec.dll == false) { |
| spup_cycles += memSpec.memTimingSpec.XS - spup_act - |
| memSpec.memTimingSpec.RP; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XS - spup_act - |
| (2 * memSpec.memTimingSpec.RP)); |
| } else { |
| spup_cycles += memSpec.memTimingSpec.XSDLL - |
| memSpec.memTimingSpec.RCD - spup_act - |
| memSpec.memTimingSpec.RP; |
| latest_pre_cycle = max(timestamp, timestamp + |
| memSpec.memTimingSpec.XSDLL - memSpec.memTimingSpec.RCD - |
| spup_act - (2 * memSpec.memTimingSpec.RP)); |
| } |
| } |
| } |
| mem_state = 0; |
| } else if ((type == MemCommand::END) || (type == MemCommand::NOP)) { |
| // May be optionally used at the end of memory trace for better accuracy |
| // Update all counters based on completion of operations. |
| if ((mem_state > 0) && (mem_state < 9)) { |
| actcycles += max(zero, timestamp - first_act_cycle); |
| idle_act_update(memSpec, latest_read_cycle, latest_write_cycle, |
| latest_act_cycle, timestamp); |
| } else if (mem_state == 0) { |
| precycles += max(zero, timestamp - last_pre_cycle); |
| idle_pre_update(memSpec, timestamp, latest_pre_cycle); |
| } else if (mem_state == CommandAnalysis::MS_PDN_F_ACT) { |
| f_act_pdcycles += max(zero, timestamp - pdn_cycle); |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_ACT) { |
| s_act_pdcycles += max(zero, timestamp - pdn_cycle); |
| } else if (mem_state == CommandAnalysis::MS_PDN_F_PRE) { |
| f_pre_pdcycles += max(zero, timestamp - pdn_cycle); |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_PRE) { |
| s_pre_pdcycles += max(zero, timestamp - pdn_cycle); |
| } else if (mem_state == CommandAnalysis::MS_SREF) { |
| sref_cycles += max(zero, timestamp - sref_cycle); |
| } |
| } |
| } |
| } // CommandAnalysis::evaluate |
| |
| // To update idle period information whenever active cycles may be idle |
| void CommandAnalysis::idle_act_update(const MemorySpecification& memSpec, |
| int64_t latest_read_cycle, int64_t latest_write_cycle, |
| int64_t latest_act_cycle, int64_t timestamp) |
| { |
| if (latest_read_cycle >= 0) { |
| end_read_op = latest_read_cycle + timeToCompletion(memSpec, |
| MemCommand::RD) - 1; |
| } |
| |
| if (latest_write_cycle >= 0) { |
| end_write_op = latest_write_cycle + timeToCompletion(memSpec, |
| MemCommand::WR) - 1; |
| } |
| |
| if (latest_act_cycle >= 0) { |
| end_act_op = latest_act_cycle + timeToCompletion(memSpec, |
| MemCommand::ACT) - 1; |
| } |
| |
| idlecycles_act += max(zero, timestamp - max(max(end_read_op, end_write_op), |
| end_act_op)); |
| } // CommandAnalysis::idle_act_update |
| |
| // To update idle period information whenever precharged cycles may be idle |
| void CommandAnalysis::idle_pre_update(const MemorySpecification& memSpec, |
| int64_t timestamp, int64_t latest_pre_cycle) |
| { |
| if (latest_pre_cycle > 0) { |
| idlecycles_pre += max(zero, timestamp - latest_pre_cycle - |
| memSpec.memTimingSpec.RP); |
| } else if (latest_pre_cycle == 0) { |
| idlecycles_pre += max(zero, timestamp - latest_pre_cycle); |
| } |
| } |
| |
| void CommandAnalysis::printWarningIfActive(const string& warning, int type, int64_t timestamp, int bank) |
| { |
| if (mem_state != 0) { |
| printWarning(warning, type, timestamp, bank); |
| } |
| } |
| |
| void CommandAnalysis::printWarningIfNotActive(const string& warning, int type, int64_t timestamp, int bank) |
| { |
| if (mem_state == 0) { |
| printWarning(warning, type, timestamp, bank); |
| } |
| } |
| |
| void CommandAnalysis::printWarning(const string& warning, int type, int64_t timestamp, int bank) |
| { |
| cerr << "WARNING: " << warning << endl; |
| cerr << "Command: " << type << ", Timestamp: " << timestamp << |
| ", Bank: " << bank << endl; |
| } |
