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;

--- 14 unchanged lines hidden (view full) ---

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
29/**
30 * @file
31 * Declaration of the Packet Class, a packet is a transaction occuring
32 * between a single level of the memory heirarchy (ie L1->L2).
33 */
34
35#ifndef __MEM_PACKET_HH__
36#define __MEM_PACKET_HH__
37
38#include "mem/request.hh"
39#include "arch/isa_traits.hh"
40#include "sim/root.hh"
41
42struct Packet;
43typedef Packet* PacketPtr;
44typedef uint8_t* PacketDataPtr;
45
46/**
47 * A Packet is the structure to handle requests between two levels
48 * of the memory system. The Request is a global object that trancends
49 * all of the memory heirarchy, but at each levels interface a packet
50 * is created to transfer data/requests. For example, a request would
51 * be used to initiate a request to go to memory/IOdevices, as the request
52 * passes through the memory system several packets will be created. One
53 * will be created to go between the L1 and L2 caches and another to go to
54 * the next level and so forth.
55 *
56 * Packets are assumed to be returned in the case of a single response. If
57 * the transaction has no response, then the consumer will delete the packet.
58 */
59class Packet
60{
61 private:
62 /** A pointer to the data being transfered. It can be differnt sizes
63 at each level of the heirarchy so it belongs in the packet,
64 not request. This may or may not be populated when a responder recieves
65 the packet. If not populated it memory should be allocated.
66 */
67 PacketDataPtr data;
68
69 /** Is the data pointer set to a value that shouldn't be freed when the
70 * packet is destroyed? */
71 bool staticData;
72 /** The data pointer points to a value that should be freed when the packet
73 * is destroyed. */
74 bool dynamicData;
75 /** the data pointer points to an array (thus delete [] ) needs to be called
76 * on it rather than simply delete.*/
77 bool arrayData;
78
79
80 /** The address of the request, could be virtual or physical (depending on
81 cache configurations). */
82 Addr addr;
83
84 /** Indicates the size of the request. */
85 int size;
86
87 /** A index of the source of the transaction. */
88 short src;
89
90 /** A index to the destination of the transaction. */
91 short dest;
92
93 bool addrValid;
94 bool sizeValid;
95 bool srcValid;
96
97 public:
98
99 static const short Broadcast = -1;
100
101 /** A pointer to the overall request. */
102 RequestPtr req;
103
104 class CoherenceState {
105 public:
106 virtual ~CoherenceState() {}
107 };
108
109 /** A virtual base opaque structure used to hold
110 coherence status messages. */
111 CoherenceState *coherence; // virtual base opaque,
112 // assert(dynamic_cast<Foo>) etc.
113
114 class SenderState {
115 public:
116 virtual ~SenderState() {}
117 };
118
119 /** A virtual base opaque structure used to hold the senders state. */
120 SenderState *senderState; // virtual base opaque,
121 // assert(dynamic_cast<Foo>) etc.
122
123 private:
124 /** List of command attributes. */
125 enum CommandAttribute
126 {
127 IsRead = 1 << 0,
128 IsWrite = 1 << 1,
129 IsPrefetch = 1 << 2,

--- 9 unchanged lines hidden (view full) ---

139 {
140 ReadReq = IsRead | IsRequest | NeedsResponse,
141 WriteReq = IsWrite | IsRequest | NeedsResponse,
142 WriteReqNoAck = IsWrite | IsRequest,
143 ReadResp = IsRead | IsResponse,
144 WriteResp = IsWrite | IsResponse
145 };
146
147 const std::string &cmdString() const;
148
149 /** The command of the transaction. */
150 Command cmd;
151
152 bool isRead() { return (cmd & IsRead) != 0; }
153 bool isRequest() { return (cmd & IsRequest) != 0; }
154 bool isResponse() { return (cmd & IsResponse) != 0; }
155 bool needsResponse() { return (cmd & NeedsResponse) != 0; }
156
157 void makeTimingResponse() {
158 assert(needsResponse());
159 int icmd = (int)cmd;
160 icmd &= ~(IsRequest | NeedsResponse);
161 icmd |= IsResponse;
162 cmd = (Command)icmd;
163 dest = src;
164 srcValid = false;
165 }
166
167 /** The time this request was responded to. Used to calculate latencies. */
168 Tick time;
169
170 /** The result of a particular packets request. */
171 enum Result
172 {
173 Success,
174 BadAddress,
175 Unknown
176 };
177
178 /** The result of the packet transaction. */
179 Result result;
180
181 /** Accessor function that returns the source index of the packet. */
182 short getSrc() const { assert(srcValid); return src; }
183 void setSrc(short _src) { src = _src; srcValid = true; }
184
185 /** Accessor function that returns the destination index of
186 the packet. */
187 short getDest() const { return dest; }
188 void setDest(short _dest) { dest = _dest; }
189
190 Addr getAddr() const { assert(addrValid); return addr; }
191 void setAddr(Addr _addr) { addr = _addr; addrValid = true; }
192
193 int getSize() const { assert(sizeValid); return size; }
194 void setSize(int _size) { size = _size; sizeValid = true; }
195
196
197 Packet(Request *_req, Command _cmd, short _dest)
198 : data(NULL), staticData(false), dynamicData(false), arrayData(false),
199 addr(_req->paddr), size(_req->size), dest(_dest),
200 addrValid(_req->validPaddr), sizeValid(_req->validSize),
201 srcValid(false),
202 req(_req), coherence(NULL), senderState(NULL), cmd(_cmd),
203 time(curTick), result(Unknown)
204 {
205 }
206
207 ~Packet()
208 { deleteData(); }
209
210
211 /** Minimally reset a packet so something like simple cpu can reuse it. */
212 void reset();
213
214 void reinitFromRequest() {
215 if (req->validPaddr) setAddr(req->paddr);
216 if (req->validSize) setSize(req->size);
217 }
218
219 /** Set the data pointer to the following value that should not be freed. */
220 template <typename T>
221 void dataStatic(T *p);
222
223 /** Set the data pointer to a value that should have delete [] called on it.
224 */
225 template <typename T>
226 void dataDynamicArray(T *p);

--- 30 unchanged lines hidden ---