MemCommand.cc revision 10428:0caf62b57dfd
1/* 2 * Copyright (c) 2012-2014, TU Delft 3 * Copyright (c) 2012-2014, TU Eindhoven 4 * Copyright (c) 2012-2014, TU Kaiserslautern 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions are 9 * met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * 3. Neither the name of the copyright holder nor the names of its 19 * contributors may be used to endorse or promote products derived from 20 * this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 23 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 25 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 28 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 29 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 * 34 * Authors: Karthik Chandrasekar 35 * 36 */ 37 38#include "MemCommand.h" 39 40#include <algorithm> // for max 41 42#include "MemorySpecification.h" 43 44using namespace Data; 45using namespace std; 46 47MemCommand::MemCommand() : 48 type(MemCommand::PRE), 49 bank(0), 50 timestamp(0) 51{ 52} 53 54MemCommand::MemCommand(MemCommand::cmds type, 55 unsigned bank, double timestamp) : 56 type(type), 57 bank(bank), 58 timestamp(timestamp) 59{ 60} 61 62void MemCommand::setType(MemCommand::cmds _type) 63{ 64 type = _type; 65} 66 67MemCommand::cmds MemCommand::getType() const 68{ 69 return type; 70} 71 72void MemCommand::setBank(unsigned _bank) 73{ 74 bank = _bank; 75} 76 77unsigned MemCommand::getBank() const 78{ 79 return bank; 80} 81 82// For auto-precharge with read or write - to calculate cycle of precharge 83int MemCommand::getPrechargeOffset(const MemorySpecification& memSpec, 84 MemCommand::cmds type) const 85{ 86 int precharge_offset = 0; 87 88 int BL(static_cast<int>(memSpec.memArchSpec.burstLength)); 89 int RTP(static_cast<int>(memSpec.memTimingSpec.RTP)); 90 int dataRate(static_cast<int>(memSpec.memArchSpec.dataRate)); 91 int AL(static_cast<int>(memSpec.memTimingSpec.AL)); 92 int WL(static_cast<int>(memSpec.memTimingSpec.WL)); 93 int WR(static_cast<int>(memSpec.memTimingSpec.WR)); 94 int B = BL/dataRate; 95 96 const MemoryType::MemoryType_t& memType = memSpec.memoryType; 97 98 // Read with auto-precharge 99 if (type == MemCommand::RDA) { 100 if (memType == MemoryType::DDR2) { 101 precharge_offset = B + AL - 2 + max(RTP, 2); 102 } else if (memType == MemoryType::DDR3) { 103 precharge_offset = AL + max(RTP, 4); 104 } else if (memType == MemoryType::DDR4) { 105 precharge_offset = AL + RTP; 106 } else if (memType == MemoryType::LPDDR) { 107 precharge_offset = B; 108 } else if (memType == MemoryType::LPDDR2) { 109 precharge_offset = B + max(0, RTP - 2); 110 } else if (memType == MemoryType::LPDDR3) { 111 precharge_offset = B + max(0, RTP - 4); 112 } else if (memType == MemoryType::WIDEIO_SDR) { 113 precharge_offset = B; 114 } 115 } else if (type == MemCommand::WRA) { // Write with auto-precharge 116 if (memType == MemoryType::DDR2) { 117 precharge_offset = B + WL + WR; 118 } else if (memType == MemoryType::DDR3) { 119 precharge_offset = B + WL + WR; 120 } else if (memType == MemoryType::DDR4) { 121 precharge_offset = B + WL + WR; 122 } else if (memType == MemoryType::LPDDR) { 123 precharge_offset = B + WR; // + DQSS actually, but we don't have that parameter. 124 } else if (memType == MemoryType::LPDDR2) { 125 precharge_offset = B + WL + WR + 1; 126 } else if (memType == MemoryType::LPDDR3) { 127 precharge_offset = B + WL + WR + 1; 128 } else if (memType == MemoryType::WIDEIO_SDR) { 129 precharge_offset = B + WL + WR - 1; 130 } 131 } 132 133 return precharge_offset; 134} // MemCommand::getPrechargeOffset 135 136void MemCommand::setTime(double _timestamp) 137{ 138 timestamp = _timestamp; 139} 140 141double MemCommand::getTime() const 142{ 143 return timestamp; 144} 145 146int64_t MemCommand::getTimeInt64() const 147{ 148 return static_cast<int64_t>(timestamp); 149} 150 151MemCommand::cmds MemCommand::typeWithoutAutoPrechargeFlag() const 152{ 153 if (type == MemCommand::RDA) { 154 return MemCommand::RD; 155 } else if (type == MemCommand::WRA) { 156 return MemCommand::WR; 157 } 158 return type; 159} 160