src/mem/dram_ctrl.cc

107     fatal_if(!isPowerOf2(burstSize), "DRAM burst size %d is not allowed, "
125     uint64_t capacity = ULL(1) << ceilLog2(AbstractMemory::size());
131     // if actual DRAM size does not match memory capacity in system warn!
138             AbstractMemory::size());
140     DPRINTF(DRAM, "Row buffer size %d bytes with %d columns per row buffer\n",
215             // is larger than the DRAM burst size, then map the
219             // of the address (above the ones denoting the burst size)
226                       "as the cache line size\n", name());
229             // ...and equal or smaller than the row-buffer size
232                       "as the row-buffer size\n", name());
287     DPRINTF(DRAM, "Read queue limit %d, current size %d, entries needed %d\n",
288             readBufferSize, totalReadQueueSize + respQueue.size(),
291     auto rdsize_new = totalReadQueueSize + respQueue.size() + neededEntries;
298     DPRINTF(DRAM, "Write queue limit %d, current size %d, entries needed %d\n",
306 DRAMCtrl::decodeAddr(const PacketPtr pkt, Addr dramPktAddr, unsigned size,
408                           size, ranks[rank]->banks[bank], *ranks[rank]);
420     // if the request size is larger than burst size, the pkt is split into
422     // Note if the pkt starting address is not aligened to burst size, the
424     // are aligned to burst size boundaries. This is to ensure we accurately
430         unsigned size = std::min((addr | (burstSize - 1)) + 1,
432         readPktSize[ceilLog2(size)]++;
448                        ((addr + size) <= (p->addr + p->size))) {
454                                 "Read to addr %lld with size %d serviced by "
456                                 addr, size);
475             DRAMPacket* dram_pkt = decodeAddr(pkt, addr, size, true);
479             rdQLenPdf[totalReadQueueSize + respQueue.size()]++;
492             avgRdQLen = totalReadQueueSize + respQueue.size();
524     // if the request size is larger than burst size, the pkt is split into
528         unsigned size = std::min((addr | (burstSize - 1)) + 1,
530         writePktSize[ceilLog2(size)]++;
542             DRAMPacket* dram_pkt = decodeAddr(pkt, addr, size, false);
556             assert(totalWriteQueueSize == isInWriteQueue.size());
578     // @todo, if a pkt size is larger than burst size, we might need a
619     DPRINTF(DRAM, "recvTimingReq: request %s addr %lld size %d\n",
636     // If the burst size is equal or larger than the pkt size, then a pkt
639     unsigned size = pkt->getSize();
641     unsigned int dram_pkt_count = divCeil(offset + size, burstSize);
648         assert(size != 0);
658             bytesWrittenSys += size;
662         assert(size != 0);
672             bytesReadSys += size;
779         if (queue.size() == 1) {
957     assert(rank_ref.actTicks.size() == activationLimit);
1318         masterReadBytes[dram_pkt->masterId()] += dram_pkt->size;
1325         masterWriteBytes[dram_pkt->masterId()] += dram_pkt->size;
1455                         prio, queue->size());
1488             assert(dram_pkt->size <= burstSize);
1538                     prio, queue->size());
1565         assert(dram_pkt->size <= burstSize);
2870                 respQueue.size());