src/mem/dram_ctrl.cc

155             fatal("banks per rank (%d) must be equal to or larger than "
156                   "banks groups per rank (%d)\n",
159         // must have same number of banks in each bank group
162                   "per rank (%d) for equal banks per bank group\n",
333         // over the banks
355         // over the banks
408                           size, ranks[rank]->banks[bank], *ranks[rank]);
887                 // bank is amongst first available banks
995         if (bankGroupArch && (bank_ref.bankgr == rank_ref.banks[i].bankgr)) {
999             rank_ref.banks[i].actAllowedAt = std::max(act_tick + tRRD_L,
1000                                              rank_ref.banks[i].actAllowedAt);
1005             rank_ref.banks[i].actAllowedAt = std::max(act_tick + tRRD,
1006                                              rank_ref.banks[i].actAllowedAt);
1039                 rank_ref.banks[j].actAllowedAt =
1041                              rank_ref.banks[j].actAllowedAt);
1087     // if we look at the current number of active banks we might be
1167                    (bank.bankgr == ranks[j]->banks[i].bankgr)) {
1190             ranks[j]->banks[i].rdAllowedAt = std::max(cmd_at + dly_to_rd_cmd,
1191                                              ranks[j]->banks[i].rdAllowedAt);
1192             ranks[j]->banks[i].wrAllowedAt = std::max(cmd_at + dly_to_wr_cmd,
1193                                              ranks[j]->banks[i].wrAllowedAt);
1429                 // ensuring all banks are closed and
1677                 Tick act_at = ranks[i]->banks[j].openRow == Bank::NO_ROW ?
1678                     std::max(ranks[i]->banks[j].actAllowedAt, curTick()) :
1679                     std::max(ranks[i]->banks[j].preAllowedAt, curTick()) + tRP;
1683                                               ranks[i]->banks[j].rdAllowedAt :
1684                                               ranks[i]->banks[j].wrAllowedAt;
1692                 // seamless banks, and got a bank with an earlier
1728       wakeUpAllowedAt(0), power(_p, false), banks(_p->banks_per_rank),
1738         banks[b].bank = b;
1739         // GDDR addressing of banks to BG is linear.
1744             // rotate across bank groups as banks are incremented
1745             // e.g. with 4 banks per bank group and 16 banks total:
1746             //    banks 0,4,8,12  are in bank group 0
1747             //    banks 1,5,9,13  are in bank group 1
1748             //    banks 2,6,10,14 are in bank group 2
1749             //    banks 3,7,11,15 are in bank group 3
1750             banks[b].bankgr = b % _p->bank_groups_per_rank;
1753             banks[b].bankgr = b;
1855     // if all banks are precharged for the power models
1864             // All banks closed - switch to precharge power down state.
1937     // at this point, ensure that all banks are precharged
1948             for (auto &b : banks) {
1950                 // constraints, some banks could already have a
1955             // make sure all banks per rank are precharged, and for those that
1959             for (auto &b : banks) {
1968             // precharge all banks in rank
1977             DPRINTF(DRAM, "All banks already precharged, starting refresh\n");
1983             // banks state is closed but haven't transitioned pwrState to IDLE
1992         // wait for all banks to be precharged, at which point the
2001         // should never get here with any banks active
2007         for (auto &b : banks) {
2037         // should never get here with any banks active
2133         // transition to PRE_PDN now that all banks are closed
2182     for (auto &b : banks) {
2184         // constraints, some banks could already have a
2222         // banks still open, transition to PWR_ACT
2226         // banks are closed - transition to PWR_IDLE
2280         // go back to REF event and close banks
2284         DPRINTF(DRAMState, "All banks precharged\n");
2298                 // state, after PRE_PDN exit, when banks are IDLE but an
2900         // then verify that the power state is IDLE ensuring all banks are