1/* 2 * Copyright (c) 2006 The Regents of The University of Michigan 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; 9 * redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution; 12 * neither the name of the copyright holders nor the names of its 13 * contributors may be used to endorse or promote products derived from 14 * this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * Authors: Ali Saidi 29 * Steve Reinhardt 30 */ 31 32/** 33 * @file 34 * Definition of the Packet Class, a packet is a transaction occuring 35 * between a single level of the memory heirarchy (ie L1->L2). 36 */
|
37
38#include <iostream>
|
37#include "base/misc.hh" 38#include "mem/packet.hh"
|
41#include "base/trace.hh"
|
39 40static const std::string ReadReqString("ReadReq"); 41static const std::string WriteReqString("WriteReq");
|
45static const std::string WriteReqNoAckString("WriteReqNoAck");
|
42static const std::string WriteReqNoAckString("WriteReqNoAck|Writeback"); |
43static const std::string ReadRespString("ReadResp"); 44static const std::string WriteRespString("WriteResp");
|
45static const std::string SoftPFReqString("SoftPFReq"); 46static const std::string SoftPFRespString("SoftPFResp"); 47static const std::string HardPFReqString("HardPFReq"); 48static const std::string HardPFRespString("HardPFResp"); 49static const std::string InvalidateReqString("InvalidateReq"); 50static const std::string WriteInvalidateReqString("WriteInvalidateReq"); 51static const std::string UpgradeReqString("UpgradeReq"); 52static const std::string ReadExReqString("ReadExReq"); 53static const std::string ReadExRespString("ReadExResp"); |
54static const std::string OtherCmdString("<other>"); 55 56const std::string & 57Packet::cmdString() const 58{ 59 switch (cmd) { 60 case ReadReq: return ReadReqString; 61 case WriteReq: return WriteReqString; 62 case WriteReqNoAck: return WriteReqNoAckString; 63 case ReadResp: return ReadRespString; 64 case WriteResp: return WriteRespString;
|
65 case SoftPFReq: return SoftPFReqString; 66 case SoftPFResp: return SoftPFRespString; 67 case HardPFReq: return HardPFReqString; 68 case HardPFResp: return HardPFRespString; 69 case InvalidateReq: return InvalidateReqString; 70 case WriteInvalidateReq:return WriteInvalidateReqString; 71 case UpgradeReq: return UpgradeReqString; 72 case ReadExReq: return ReadExReqString; 73 case ReadExResp: return ReadExRespString; |
74 default: return OtherCmdString; 75 } 76} 77 78const std::string & 79Packet::cmdIdxToString(Packet::Command idx) 80{ 81 switch (idx) { 82 case ReadReq: return ReadReqString; 83 case WriteReq: return WriteReqString; 84 case WriteReqNoAck: return WriteReqNoAckString; 85 case ReadResp: return ReadRespString; 86 case WriteResp: return WriteRespString;
|
87 case SoftPFReq: return SoftPFReqString; 88 case SoftPFResp: return SoftPFRespString; 89 case HardPFReq: return HardPFReqString; 90 case HardPFResp: return HardPFRespString; 91 case InvalidateReq: return InvalidateReqString; 92 case WriteInvalidateReq:return WriteInvalidateReqString; 93 case UpgradeReq: return UpgradeReqString; 94 case ReadExReq: return ReadExReqString; 95 case ReadExResp: return ReadExRespString; |
96 default: return OtherCmdString; 97 } 98} 99 100/** delete the data pointed to in the data pointer. Ok to call to matter how 101 * data was allocted. */ 102void 103Packet::deleteData() 104{ 105 assert(staticData || dynamicData); 106 if (staticData) 107 return; 108 109 if (arrayData) 110 delete [] data; 111 else 112 delete data; 113} 114 115/** If there isn't data in the packet, allocate some. */ 116void 117Packet::allocate() 118{ 119 if (data) 120 return; 121 assert(!staticData); 122 dynamicData = true; 123 arrayData = true; 124 data = new uint8_t[getSize()]; 125} 126 127/** Do the packet modify the same addresses. */ 128bool 129Packet::intersect(Packet *p) 130{ 131 Addr s1 = getAddr(); 132 Addr e1 = getAddr() + getSize() - 1; 133 Addr s2 = p->getAddr(); 134 Addr e2 = p->getAddr() + p->getSize() - 1; 135 136 return !(s1 > e2 || e1 < s2); 137} 138 139bool 140fixPacket(Packet *func, Packet *timing) 141{
|
118 Addr funcStart = func->getAddr();
119 Addr funcEnd = func->getAddr() + func->getSize() - 1;
120 Addr timingStart = timing->getAddr();
121 Addr timingEnd = timing->getAddr() + timing->getSize() - 1;
122
123 assert(!(funcStart > timingEnd || timingStart < funcEnd));
124
125 if (DTRACE(FunctionalAccess)) {
126 DebugOut() << func;
127 DebugOut() << timing;
128 }
129
130 // this packet can't solve our problem, continue on
131 if (!timing->hasData())
132 return true;
133
134 if (func->isRead()) {
135 if (funcStart >= timingStart && funcEnd <= timingEnd) {
136 func->allocate();
137 memcpy(func->getPtr<uint8_t>(), timing->getPtr<uint8_t>() +
138 funcStart - timingStart, func->getSize());
139 func->result = Packet::Success;
140 return false;
141 } else {
142 // In this case the timing packet only partially satisfies the
143 // requset, so we would need more information to make this work.
144 // Like bytes valid in the packet or something, so the request could
145 // continue and get this bit of possibly newer data along with the
146 // older data not written to yet.
147 panic("Timing packet only partially satisfies the functional"
148 "request. Now what?");
149 }
150 } else if (func->isWrite()) {
151 if (funcStart >= timingStart) {
152 memcpy(timing->getPtr<uint8_t>() + (funcStart - timingStart),
153 func->getPtr<uint8_t>(),
154 funcStart - std::min(funcEnd, timingEnd));
155 } else { // timingStart > funcStart
156 memcpy(timing->getPtr<uint8_t>(),
157 func->getPtr<uint8_t>() + (timingStart - funcStart),
158 timingStart - std::min(funcEnd, timingEnd));
159 }
160 // we always want to keep going with a write
161 return true;
162 } else
163 panic("Don't know how to handle command type %#x\n",
164 func->cmdToIndex());
165
|
142 panic("Need to implement!"); |
143}
|
167
168
169std::ostream &
170operator<<(std::ostream &o, const Packet &p)
171{
172
173 o << "[0x";
174 o.setf(std::ios_base::hex, std::ios_base::showbase);
175 o << p.getAddr();
176 o.unsetf(std::ios_base::hex| std::ios_base::showbase);
177 o << ":";
178 o.setf(std::ios_base::hex, std::ios_base::showbase);
179 o << p.getAddr() + p.getSize() - 1 << "] ";
180 o.unsetf(std::ios_base::hex| std::ios_base::showbase);
181
182 if (p.result == Packet::Success)
183 o << "Successful ";
184 if (p.result == Packet::BadAddress)
185 o << "BadAddress ";
186 if (p.result == Packet::Nacked)
187 o << "Nacked ";
188 if (p.result == Packet::Unknown)
189 o << "Inflight ";
190
191 if (p.isRead())
192 o << "Read ";
193 if (p.isWrite())
194 o << "Read ";
195 if (p.isInvalidate())
196 o << "Read ";
197 if (p.isRequest())
198 o << "Request ";
199 if (p.isResponse())
200 o << "Response ";
201 if (p.hasData())
202 o << "w/Data ";
203
204 o << std::endl;
205 return o;
206}
207
|
|