| /* | |
| * 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. | |
| * | |
| */ | |
| #include "CommandAnalysis.h" | |
| using std::cerr; | |
| using std::endl; | |
| using std::max; | |
| using namespace Data; | |
| int64_t zero_guard(int64_t cycles_in, const char* warning) | |
| { | |
| // Calculate max(0, cycles_in) | |
| int64_t zero = 0; | |
| if (warning != nullptr && cycles_in < 0) { | |
| // This line is commented out for now, we will attempt to remove the situations where | |
| // these warnings trigger later. | |
| // cerr << "WARNING: " << warning << endl; | |
| } | |
| return max(zero, cycles_in); | |
| } | |
| void CommandAnalysis::handleAct(unsigned bank, int64_t timestamp) | |
| { | |
| printWarningIfPoweredDown("Command issued while in power-down mode.", MemCommand::ACT, timestamp, bank); | |
| // 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. | |
| // If the bank is already active ignore the command and generate a | |
| // warning. | |
| if (isPrecharged(bank)) { | |
| numberofactsBanks[bank]++; | |
| if (nActiveBanks() == 0) { | |
| // Here a memory state transition to ACT is happening. Save the | |
| // number of cycles in precharge state (increment the counter). | |
| first_act_cycle = timestamp; | |
| precycles += zero_guard(timestamp - last_pre_cycle, "1 last_pre_cycle is in the future."); | |
| idle_pre_update(timestamp, latest_pre_cycle); | |
| } | |
| bank_state[bank] = BANK_ACTIVE; | |
| latest_act_cycle = timestamp; | |
| } else { | |
| printWarning("Bank is already active!", MemCommand::ACT, timestamp, bank); | |
| } | |
| } | |
| void CommandAnalysis::handleRd(unsigned bank, int64_t timestamp) | |
| { | |
| printWarningIfPoweredDown("Command issued while in power-down mode.", MemCommand::RD, timestamp, bank); | |
| // If command is RD - update number of reads and read cycle. Check | |
| // for active idle cycles (if any). | |
| if (isPrecharged(bank)) { | |
| printWarning("Bank is not active!", MemCommand::RD, timestamp, bank); | |
| } | |
| numberofreadsBanks[bank]++; | |
| idle_act_update(latest_read_cycle, latest_write_cycle, latest_act_cycle, timestamp); | |
| latest_read_cycle = timestamp; | |
| } | |
| void CommandAnalysis::handleWr(unsigned bank, int64_t timestamp) | |
| { | |
| printWarningIfPoweredDown("Command issued while in power-down mode.", MemCommand::WR, timestamp, bank); | |
| // If command is WR - update number of writes and write cycle. Check | |
| // for active idle cycles (if any). | |
| if (isPrecharged(bank)) { | |
| printWarning("Bank is not active!", MemCommand::WR, timestamp, bank); | |
| } | |
| numberofwritesBanks[bank]++; | |
| idle_act_update(latest_read_cycle, latest_write_cycle, latest_act_cycle, timestamp); | |
| latest_write_cycle = timestamp; | |
| } | |
| void CommandAnalysis::handleRef(unsigned bank, int64_t timestamp) | |
| { | |
| printWarningIfPoweredDown("Command issued while in power-down mode.", MemCommand::REF, timestamp, bank); | |
| // 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.", MemCommand::REF, timestamp, bank); | |
| numberofrefs++; | |
| idle_pre_update(timestamp, latest_pre_cycle); | |
| first_act_cycle = timestamp; | |
| std::fill(first_act_cycle_banks.begin(), first_act_cycle_banks.end(), timestamp); | |
| precycles += zero_guard(timestamp - last_pre_cycle, "2 last_pre_cycle is in the future."); | |
| last_pre_cycle = timestamp + memSpec.memTimingSpec.RFC - memSpec.memTimingSpec.RP; | |
| latest_pre_cycle = last_pre_cycle; | |
| actcycles += memSpec.memTimingSpec.RFC - memSpec.memTimingSpec.RP; | |
| for (auto &e : actcyclesBanks) { | |
| e += memSpec.memTimingSpec.RFC - memSpec.memTimingSpec.RP; | |
| } | |
| for (auto& bs : bank_state) { | |
| bs = BANK_PRECHARGED; | |
| } | |
| } | |
| void CommandAnalysis::handleRefB(unsigned bank, int64_t timestamp) | |
| { | |
| // A REFB command requires a previous PRE command. | |
| if (isPrecharged(bank)) { | |
| // This previous PRE command handler is also responsible for keeping the | |
| // memory state updated. | |
| // Here we consider that the memory state is not changed in order to keep | |
| // things simple, since the transition from PRE to ACT state takes time. | |
| numberofrefbBanks[bank]++; | |
| // Length of the refresh: here we have an approximation, we consider tRP | |
| // also as act cycles because the bank will be precharged (stable) after | |
| // tRP. | |
| actcyclesBanks[bank] += memSpec.memTimingSpec.RAS + memSpec.memTimingSpec.RP; | |
| } else { | |
| printWarning("Bank must be precharged for REFB!", MemCommand::REFB, timestamp, bank); | |
| } | |
| } | |
| void CommandAnalysis::handlePre(unsigned bank, int64_t timestamp) | |
| { | |
| printWarningIfPoweredDown("Command issued while in power-down mode.", MemCommand::PRE, timestamp, bank); | |
| // 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 | |
| // (i.e., this is the last active bank). | |
| // If the bank is already precharged ignore the command and generate a | |
| // warning. | |
| // Precharge only if the target bank is active | |
| if (bank_state[bank] == BANK_ACTIVE) { | |
| numberofpresBanks[bank]++; | |
| actcyclesBanks[bank] += zero_guard(timestamp - first_act_cycle_banks[bank], "first_act_cycle is in the future (bank)."); | |
| // Since we got here, at least one bank is active | |
| assert(nActiveBanks() != 0); | |
| if (nActiveBanks() == 1) { | |
| // This is the last active bank. Therefore, here a memory state | |
| // transition to PRE is happening. Let's increment the active cycle | |
| // counter. | |
| actcycles += zero_guard(timestamp - first_act_cycle, "first_act_cycle is in the future."); | |
| last_pre_cycle = timestamp; | |
| idle_act_update(latest_read_cycle, latest_write_cycle, latest_act_cycle, timestamp); | |
| } | |
| bank_state[bank] = BANK_PRECHARGED; | |
| latest_pre_cycle = timestamp; | |
| } else { | |
| printWarning("Bank is already precharged!", MemCommand::PRE, timestamp, bank); | |
| } | |
| } | |
| void CommandAnalysis::handlePreA(unsigned bank, int64_t timestamp) | |
| { | |
| printWarningIfPoweredDown("Command issued while in power-down mode.", MemCommand::PREA, timestamp, bank); | |
| // If command is explicit PREA (precharge all banks) - update | |
| // number of precharges by the number of active banks, update the bank | |
| // state of all banks to PRE and set the precharge cycle (the cycle in | |
| // which the memory state changes from ACT to PRE, aka last_pre_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 (nActiveBanks() > 0) { | |
| // Active banks are being precharged | |
| // At least one bank was active, therefore the current memory state is | |
| // ACT. Since all banks are being precharged a memory state transition | |
| // to PRE is happening. Add to the counter the amount of cycles the | |
| // memory remained in the ACT state. | |
| actcycles += zero_guard(timestamp - first_act_cycle, "first_act_cycle is in the future."); | |
| last_pre_cycle = timestamp; | |
| for (unsigned b = 0; b < num_banks; b++) { | |
| if (bank_state[b] == BANK_ACTIVE) { | |
| // Active banks are being precharged | |
| numberofpresBanks[b] += 1; | |
| actcyclesBanks[b] += zero_guard(timestamp - first_act_cycle_banks[b], "first_act_cycle is in the future (bank)."); | |
| } | |
| } | |
| idle_act_update(latest_read_cycle, latest_write_cycle, latest_act_cycle, timestamp); | |
| latest_pre_cycle = timestamp; | |
| // Reset the state for all banks to precharged. | |
| for (auto& bs : bank_state) { | |
| bs = BANK_PRECHARGED; | |
| } | |
| } else { | |
| printWarning("All banks are already precharged!", MemCommand::PREA, timestamp, bank); | |
| } | |
| } | |
| void CommandAnalysis::handlePdnFAct(unsigned bank, int64_t timestamp) | |
| { | |
| // 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.", MemCommand::PDN_F_ACT, timestamp, bank); | |
| f_act_pdns++; | |
| last_bank_state = bank_state; | |
| pdn_cycle = timestamp; | |
| actcycles += zero_guard(timestamp - first_act_cycle, "first_act_cycle is in the future."); | |
| for (unsigned b = 0; b < num_banks; b++) { | |
| if (bank_state[b] == BANK_ACTIVE) { | |
| actcyclesBanks[b] += zero_guard(timestamp - first_act_cycle_banks[b], "first_act_cycle is in the future (bank)."); | |
| } | |
| } | |
| idle_act_update(latest_read_cycle, latest_write_cycle, latest_act_cycle, timestamp); | |
| mem_state = CommandAnalysis::MS_PDN_F_ACT; | |
| } | |
| void CommandAnalysis::handlePdnSAct(unsigned bank, int64_t timestamp) | |
| { | |
| // 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.", MemCommand::PDN_S_ACT, timestamp, bank); | |
| s_act_pdns++; | |
| last_bank_state = bank_state; | |
| pdn_cycle = timestamp; | |
| actcycles += zero_guard(timestamp - first_act_cycle, "first_act_cycle is in the future."); | |
| for (unsigned b = 0; b < num_banks; b++) { | |
| if (bank_state[b] == BANK_ACTIVE) { | |
| actcyclesBanks[b] += zero_guard(timestamp - first_act_cycle_banks[b], "first_act_cycle is in the future (bank)."); | |
| } | |
| } | |
| idle_act_update(latest_read_cycle, latest_write_cycle, latest_act_cycle, timestamp); | |
| mem_state = CommandAnalysis::MS_PDN_S_ACT; | |
| } | |
| void CommandAnalysis::handlePdnFPre(unsigned bank, int64_t timestamp) | |
| { | |
| // 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.", MemCommand::PDN_F_PRE, timestamp, bank); | |
| f_pre_pdns++; | |
| pdn_cycle = timestamp; | |
| precycles += zero_guard(timestamp - last_pre_cycle, "3 last_pre_cycle is in the future."); | |
| idle_pre_update(timestamp, latest_pre_cycle); | |
| mem_state = CommandAnalysis::MS_PDN_F_PRE; | |
| } | |
| void CommandAnalysis::handlePdnSPre(unsigned bank, int64_t timestamp) | |
| { | |
| // 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.", MemCommand::PDN_S_PRE, timestamp, bank); | |
| s_pre_pdns++; | |
| pdn_cycle = timestamp; | |
| precycles += zero_guard(timestamp - last_pre_cycle, "4 last_pre_cycle is in the future."); | |
| idle_pre_update(timestamp, latest_pre_cycle); | |
| mem_state = CommandAnalysis::MS_PDN_S_PRE; | |
| } | |
| void CommandAnalysis::handlePupAct(int64_t timestamp) | |
| { | |
| // 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. | |
| const MemTimingSpec& t = memSpec.memTimingSpec; | |
| if (mem_state == CommandAnalysis::MS_PDN_F_ACT) { | |
| f_act_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future."); | |
| pup_act_cycles += t.XP; | |
| latest_act_cycle = timestamp; | |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_ACT) { | |
| s_act_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future."); | |
| if (memSpec.memArchSpec.dll == false) { | |
| pup_act_cycles += t.XP; | |
| latest_act_cycle = timestamp; | |
| } else { | |
| pup_act_cycles += t.XPDLL - t.RCD; | |
| latest_act_cycle = timestamp + zero_guard(t.XPDLL - (2 * t.RCD), "t.XPDLL - (2 * t.RCD) < 0"); | |
| } | |
| } else { | |
| cerr << "Incorrect use of Active Power-Up!" << endl; | |
| } | |
| mem_state = MS_NOT_IN_PD; | |
| bank_state = last_bank_state; | |
| first_act_cycle = timestamp; | |
| std::fill(first_act_cycle_banks.begin(), first_act_cycle_banks.end(), timestamp); | |
| } | |
| void CommandAnalysis::handlePupPre(int64_t timestamp) | |
| { | |
| // 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. | |
| const MemTimingSpec& t = memSpec.memTimingSpec; | |
| if (mem_state == CommandAnalysis::MS_PDN_F_PRE) { | |
| f_pre_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future."); | |
| pup_pre_cycles += t.XP; | |
| latest_pre_cycle = timestamp; | |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_PRE) { | |
| s_pre_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future."); | |
| if (memSpec.memArchSpec.dll == false) { | |
| pup_pre_cycles += t.XP; | |
| latest_pre_cycle = timestamp; | |
| } else { | |
| pup_pre_cycles += t.XPDLL - t.RCD; | |
| latest_pre_cycle = timestamp + zero_guard(t.XPDLL - t.RCD - t.RP, "t.XPDLL - t.RCD - t.RP"); | |
| } | |
| } else { | |
| cerr << "Incorrect use of Precharged Power-Up!" << endl; | |
| } | |
| mem_state = MS_NOT_IN_PD; | |
| last_pre_cycle = timestamp; | |
| } | |
| void CommandAnalysis::handleSREn(unsigned bank, int64_t timestamp) | |
| { | |
| // 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.", MemCommand::SREN, timestamp, bank); | |
| numberofsrefs++; | |
| sref_cycle = timestamp; | |
| sref_cycle_window = timestamp; | |
| sref_ref_pre_cycles_window = 0; | |
| sref_ref_act_cycles_window = 0; | |
| precycles += zero_guard(timestamp - last_pre_cycle, "5 last_pre_cycle is in the future."); | |
| idle_pre_update(timestamp, latest_pre_cycle); | |
| mem_state = CommandAnalysis::MS_SREF; | |
| } | |
| void CommandAnalysis::handleSREx(unsigned bank, int64_t timestamp) | |
| { | |
| // 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. | |
| const MemTimingSpec& t = memSpec.memTimingSpec; | |
| if (mem_state != CommandAnalysis::MS_SREF) { | |
| cerr << "Incorrect use of Self-Refresh Power-Up!" << endl; | |
| } | |
| // The total duration of self-refresh is given by the difference between | |
| // the current clock cycle and the clock cycle of entering self-refresh. | |
| int64_t sref_duration = timestamp - sref_cycle; | |
| // Negative or zero duration should never happen. | |
| if (sref_duration <= 0) { | |
| printWarning("Invalid Self-Refresh duration!", MemCommand::SREX, timestamp, bank); | |
| sref_duration = 0; | |
| } | |
| // The minimum time that the DRAM must remain in Self-Refresh is CKESR. | |
| if (sref_duration < t.CKESR) { | |
| printWarning("Self-Refresh duration < CKESR!", MemCommand::SREX, timestamp, bank); | |
| } | |
| if (sref_duration >= t.RFC) { | |
| /* | |
| * Self-refresh Exit Context 1 (tSREF >= tRFC): | |
| * The memory remained in self-refresh for a certain number of clock | |
| * cycles greater than a refresh cycle time (RFC). Consequently, the | |
| * initial auto-refresh accomplished. | |
| * | |
| * | |
| * SREN # SREX | |
| * | # ^ | |
| * | # | | |
| * |<------------------------- tSREF ----------...----->| | |
| * | # | | |
| * | Initial Auto-Refresh # | | |
| * v # | | |
| * ------------------------------------#-------...-----------------> t | |
| * # | |
| * <------------- tRFC --------------># | |
| * <---- (tRFC - tRP) ----><-- tRP --># | |
| * | | | |
| * v v | |
| * sref_ref_act_cycles sref_ref_pre_cycles | |
| * | |
| * | |
| * Summary: | |
| * sref_cycles += tSREF – tRFC | |
| * sref_ref_act_cycles += tRFC - tRP | |
| * sref_ref_pre_cycles += tRP | |
| * spup_ref_act_cycles += 0 | |
| * spup_ref_pre_cycles += 0 | |
| * | |
| */ | |
| // The initial auto-refresh consumes (IDD5 − IDD3N) over one refresh | |
| // period (RFC) from the start of the self-refresh. | |
| sref_ref_act_cycles += t.RFC - | |
| t.RP - sref_ref_act_cycles_window; | |
| sref_ref_pre_cycles += t.RP - sref_ref_pre_cycles_window; | |
| last_pre_cycle = timestamp; | |
| // The IDD6 current is consumed for the time period spent in the | |
| // self-refresh mode, which excludes the time spent in finishing the | |
| // initial auto-refresh. | |
| if (sref_cycle_window > sref_cycle + t.RFC) { | |
| sref_cycles += zero_guard(timestamp - sref_cycle_window, "sref_cycle_window is in the future."); | |
| } else { | |
| sref_cycles += zero_guard(timestamp - sref_cycle - t.RFC, "sref_cycle - t.RFC < 0"); | |
| } | |
| // IDD2N current is consumed when exiting the self-refresh state. | |
| if (memSpec.memArchSpec.dll == false) { | |
| spup_cycles += t.XS; | |
| latest_pre_cycle = timestamp + zero_guard(t.XS - t.RP, "t.XS - t.RP < 0"); | |
| } else { | |
| spup_cycles += t.XSDLL - t.RCD; | |
| latest_pre_cycle = timestamp + zero_guard(t.XSDLL - t.RCD - t.RP, "t.XSDLL - t.RCD - t.RP < 0"); | |
| } | |
| } else { | |
| // Self-refresh Exit Context 2 (tSREF < tRFC): | |
| // Exit self-refresh before the completion of the initial | |
| // auto-refresh. | |
| // Number of active cycles needed by an auto-refresh. | |
| int64_t ref_act_cycles = t.RFC - t.RP; | |
| if (sref_duration >= ref_act_cycles) { | |
| /* | |
| * Self-refresh Exit Context 2A (tSREF < tRFC && tSREF >= tRFC - tRP): | |
| * The duration of self-refresh is equal or greater than the number | |
| * of active cycles needed by the initial auto-refresh. | |
| * | |
| * | |
| * SREN SREX | |
| * | ^ # | |
| * | | # | |
| * |<------------------ tSREF --------------------->| # | |
| * | | # | |
| * | Initial Auto-Refresh # | |
| * v | # | |
| * -----------------------------------------------------------#--> t | |
| * # | |
| * <------------------------ tRFC --------------------------># | |
| * <------------- (tRFC - tRP)--------------><----- tRP ----># | |
| * | <-----><-------> | |
| * v | | | |
| * sref_ref_act_cycles v v | |
| * sref_ref_pre_cycles spup_ref_pre_cycles | |
| * | |
| * | |
| * Summary: | |
| * sref_cycles += 0 | |
| * sref_ref_act_cycles += tRFC - tRP | |
| * sref_ref_pre_cycles += tSREF – (tRFC – tRP) | |
| * spup_ref_act_cycles += 0 | |
| * spup_ref_pre_cycles += tRP – sref_ref_pre_cycles | |
| * | |
| */ | |
| // Number of precharged cycles (zero <= pre_cycles < RP) | |
| int64_t pre_cycles = sref_duration - ref_act_cycles - sref_ref_pre_cycles_window; | |
| sref_ref_act_cycles += ref_act_cycles - sref_ref_act_cycles_window; | |
| sref_ref_pre_cycles += pre_cycles; | |
| // Number of precharged cycles during the self-refresh power-up. It | |
| // is at maximum tRP (if pre_cycles is zero). | |
| int64_t spup_pre = t.RP - pre_cycles; | |
| spup_ref_pre_cycles += spup_pre; | |
| last_pre_cycle = timestamp + spup_pre; | |
| if (memSpec.memArchSpec.dll == false) { | |
| spup_cycles += t.XS - spup_pre; | |
| latest_pre_cycle = timestamp + zero_guard(t.XS - spup_pre - t.RP, "t.XS - spup_pre - t.RP < 0"); | |
| } else { | |
| spup_cycles += t.XSDLL - t.RCD - spup_pre; | |
| latest_pre_cycle = timestamp + zero_guard(t.XSDLL - t.RCD - spup_pre - t.RP, "t.XSDLL - t.RCD - spup_pre - t.RP"); | |
| } | |
| } else { | |
| /* | |
| * Self-refresh Exit Context 2B (tSREF < tRFC - tRP): | |
| * self-refresh duration is shorter than the number of active cycles | |
| * needed by the initial auto-refresh. | |
| * | |
| * | |
| * SREN SREX | |
| * | ^ # | |
| * | | # | |
| * |<-------------- tSREF ----------->| # | |
| * | | # | |
| * | Initial Auto-Refresh # | |
| * v | # | |
| * ------------------------------------------------------------#--> t | |
| * # | |
| * <------------------------ tRFC ---------------------------># | |
| * <-------------- (tRFC - tRP)-------------><------ tRP ----># | |
| * <--------------------------------><------><---------------> | |
| * | | | | |
| * v v v | |
| * sref_ref_act_cycles spup_ref_act_cycles spup_ref_pre_cycles | |
| * | |
| * | |
| * Summary: | |
| * sref_cycles += 0 | |
| * sref_ref_act_cycles += tSREF | |
| * sref_ref_pre_cycles += 0 | |
| * spup_ref_act_cycles += (tRFC – tRP) - tSREF | |
| * spup_ref_pre_cycles += tRP | |
| * | |
| */ | |
| sref_ref_act_cycles += sref_duration - sref_ref_act_cycles_window; | |
| int64_t spup_act = (t.RFC - t.RP) - sref_duration; | |
| spup_ref_act_cycles += spup_act; | |
| spup_ref_pre_cycles += t.RP; | |
| last_pre_cycle = timestamp + spup_act + t.RP; | |
| if (memSpec.memArchSpec.dll == false) { | |
| spup_cycles += t.XS - spup_act - t.RP; | |
| latest_pre_cycle = timestamp + zero_guard(t.XS - spup_act - (2 * t.RP), "t.XS - spup_act - (2 * t.RP) < 0"); | |
| } else { | |
| spup_cycles += t.XSDLL - t.RCD - spup_act - t.RP; | |
| latest_pre_cycle = timestamp + zero_guard(t.XSDLL - t.RCD - spup_act - (2 * t.RP), "t.XSDLL - t.RCD - spup_act - (2 * t.RP) < 0"); | |
| } | |
| } | |
| } | |
| mem_state = MS_NOT_IN_PD; | |
| } | |
| void CommandAnalysis::handleNopEnd(int64_t timestamp) | |
| { | |
| // May be optionally used at the end of memory trace for better accuracy | |
| // Update all counters based on completion of operations. | |
| const MemTimingSpec& t = memSpec.memTimingSpec; | |
| for (unsigned b = 0; b < num_banks; b++) { | |
| if (bank_state[b] == BANK_ACTIVE) { | |
| actcyclesBanks[b] += zero_guard(timestamp - first_act_cycle_banks[b], "first_act_cycle is in the future (bank)"); | |
| } | |
| } | |
| if (nActiveBanks() > 0 && mem_state == MS_NOT_IN_PD) { | |
| actcycles += zero_guard(timestamp - first_act_cycle, "first_act_cycle is in the future"); | |
| idle_act_update(latest_read_cycle, latest_write_cycle, | |
| latest_act_cycle, timestamp); | |
| } else if (nActiveBanks() == 0 && mem_state == MS_NOT_IN_PD) { | |
| precycles += zero_guard(timestamp - last_pre_cycle, "6 last_pre_cycle is in the future"); | |
| idle_pre_update(timestamp, latest_pre_cycle); | |
| } else if (mem_state == CommandAnalysis::MS_PDN_F_ACT) { | |
| f_act_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future"); | |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_ACT) { | |
| s_act_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future"); | |
| } else if (mem_state == CommandAnalysis::MS_PDN_F_PRE) { | |
| f_pre_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future"); | |
| } else if (mem_state == CommandAnalysis::MS_PDN_S_PRE) { | |
| s_pre_pdcycles += zero_guard(timestamp - pdn_cycle, "pdn_cycle is in the future"); | |
| } else if (mem_state == CommandAnalysis::MS_SREF) { | |
| auto rfc_minus_rp = (t.RFC - t.RP); | |
| if (timestamp > sref_cycle + t.RFC) { | |
| if (sref_cycle_window <= sref_cycle + rfc_minus_rp) { | |
| sref_ref_act_cycles += rfc_minus_rp - sref_ref_act_cycles_window; | |
| sref_ref_act_cycles_window = rfc_minus_rp; | |
| sref_cycle_window = sref_cycle + rfc_minus_rp; | |
| } | |
| if (sref_cycle_window <= sref_cycle + t.RFC) { | |
| sref_ref_pre_cycles += t.RP - sref_ref_pre_cycles_window; | |
| sref_ref_pre_cycles_window = t.RP; | |
| sref_cycle_window = sref_cycle + t.RFC; | |
| } | |
| sref_cycles += zero_guard(timestamp - sref_cycle_window, "sref_cycle_window is in the future"); | |
| } else if (timestamp > sref_cycle + rfc_minus_rp) { | |
| if (sref_cycle_window <= sref_cycle + rfc_minus_rp) { | |
| sref_ref_act_cycles += rfc_minus_rp - sref_ref_act_cycles_window; | |
| sref_ref_act_cycles_window = rfc_minus_rp; | |
| sref_cycle_window = sref_cycle + rfc_minus_rp; | |
| } | |
| sref_ref_pre_cycles_window += timestamp - sref_cycle_window; | |
| sref_ref_pre_cycles += timestamp - sref_cycle_window; | |
| } else { | |
| sref_ref_act_cycles_window += timestamp - sref_cycle_window; | |
| sref_ref_act_cycles += timestamp - sref_cycle_window; | |
| } | |
| } | |
| } |