gem5  v22.0.0.2
SimpleATInitiator1.h
Go to the documentation of this file.
1 /*****************************************************************************
2 
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements. See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License. You may obtain a copy of the License at
9 
10  http://www.apache.org/licenses/LICENSE-2.0
11 
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied. See the License for the specific language governing
16  permissions and limitations under the License.
17 
18  *****************************************************************************/
19 
20 //====================================================================
21 // Nov 06, 2008
22 //
23 // Updated by:
24 // Xiaopeng Qiu, JEDA Technologies, Inc
25 // Email: qiuxp@jedatechnologies.net
26 //
27 // To fix violations of TLM2.0 rules, which are detected by JEDA
28 // TLM2.0 checker.
29 //
30 //====================================================================
31 
32 #ifndef __SIMPLE_AT_INITIATOR1_H__
33 #define __SIMPLE_AT_INITIATOR1_H__
34 
35 #include "tlm.h"
36 #include "tlm_utils/simple_initiator_socket.h"
37 //#include <systemc>
38 #include <cassert>
39 #include <queue>
40 //#include <iostream>
41 
43 {
44 public:
46  typedef tlm::tlm_phase phase_type;
49 
50 public:
51  // extended transaction, holds tlm_generic_payload + data storage
52  template <typename DT>
53  class MyTransaction : public transaction_type
54  {
55  public:
57  {
58  this->set_data_ptr(reinterpret_cast<unsigned char*>(&mData));
59  }
61  {
62  this->set_data_ptr(reinterpret_cast<unsigned char*>(&mData));
63  }
64 
65  void setData(DT& data) { mData = data; }
66  DT getData() const { return mData; }
67 
68  private:
69  DT mData;
70  };
72 
73  // Dummy Transaction Pool
74  class SimplePool : public tlm::tlm_mm_interface
75  {
76  public:
79  {
81  t->acquire();
82  return t;
83  }
85  {
86  t->release();
87  }
89  {
90  t->reset();
91  delete t;
92  }
93  };
94 
95 public:
97 
98 public:
101  unsigned int nrOfTransactions = 0x5,
102  unsigned int baseAddress = 0x0) :
104  socket("socket"),
106  mNrOfTransactions(nrOfTransactions),
107  mBaseAddress(baseAddress),
110  {
111  // register nb_transport method
113 
114  // Initiator thread
115  SC_THREAD(run);
116 
119  dont_initialize();
120  }
121 
122  bool initTransaction(mytransaction_type*& trans)
123  {
125  trans = transPool.claim();
127  trans->setData(mTransactionCount);
128  trans->set_command(tlm::TLM_WRITE_COMMAND);
129 
130  } else if (mTransactionCount < 2 * mNrOfTransactions) {
131  trans = transPool.claim();
133  trans->set_command(tlm::TLM_READ_COMMAND);
134 
135  } else {
136  return false;
137  }
138 
139  trans->set_data_length(4);
140  trans->set_streaming_width(4);
141 
143  return true;
144  }
145 
147  {
148  if (trans.get_command() == tlm::TLM_WRITE_COMMAND) {
149  std::cout << name() << ": Send write request: A = 0x"
150  << std::hex << (unsigned int)trans.get_address()
151  << ", D = 0x" << trans.getData() << std::dec
152  << " @ " << sc_core::sc_time_stamp() << std::endl;
153 
154  } else {
155  std::cout << name() << ": Send read request: A = 0x"
156  << std::hex << (int)trans.get_address() << std::dec
157  << " @ " << sc_core::sc_time_stamp() << std::endl;
158  }
159  }
160 
162  {
163  if (trans.get_response_status() != tlm::TLM_OK_RESPONSE) {
164  std::cout << name() << ": Received error response @ "
165  << sc_core::sc_time_stamp() << std::endl;
166 
167  } else {
168  std::cout << name() << ": Received ok response";
169  if (trans.get_command() == tlm::TLM_READ_COMMAND) {
170  std::cout << ": D = 0x" << trans.getData() << std::dec;
171  }
172  std::cout << " @ " << sc_core::sc_time_stamp() << std::endl;
173  }
174  }
175 
176  //
177  // Simple AT Initiator
178  // - Request must be accepted by the target before the next request can be
179  // send
180  // - Responses can come out of order
181  // - Responses will be accepted after fixed delay
182  //
183  void run()
184  {
185  phase_type phase;
187 
188  mytransaction_type* ptrans;
189  while (initTransaction(ptrans)) {
190  // Create transaction and initialise phase and t
191  mytransaction_type& trans = *ptrans;
192  phase = tlm::BEGIN_REQ;
194 
195  logStartTransation(trans);
196 
197  switch (socket->nb_transport_fw(trans, phase, t)) {
198  case tlm::TLM_COMPLETED:
199  // Transaction Finished, wait for the returned delay
200  wait(t);
201  logEndTransaction(trans);
202  transPool.release(&trans);
203  break;
204 
205  case tlm::TLM_ACCEPTED:
206  case tlm::TLM_UPDATED:
207  switch (phase) {
208  case tlm::BEGIN_REQ:
209  // Request phase not yet finished
210  // Wait until end of request phase before sending new request
211 
212  // FIXME
213  mCurrentTransaction = &trans;
216  break;
217 
218  case tlm::END_REQ:
219  // Request phase ended
220  if (t != sc_core::SC_ZERO_TIME) {
221  // Wait until end of request time before sending new request
222  wait(t);
223  }
224  break;
225 
226  case tlm::BEGIN_RESP:
227  // Request phase ended and response phase already started
228  if (t != sc_core::SC_ZERO_TIME) {
229  // Wait until end of request time before sending new request
230  wait(t);
231  }
232  if (mEndResponseQueue.empty()) {
233  // Notify end of response phase after ACCEPT delay
235  }
236  mEndResponseQueue.push(&trans);
237  break;
238 
239  case tlm::END_RESP: // fall-through
240  default:
241  // A target should never return with these phases
242  // If phase == END_RESP, nb_transport should have returned true
243  assert(0); exit(1);
244  break;
245  }
246  break;
247 
248  default:
249  assert(0); exit(1);
250  };
251  }
252  wait();
253  }
254 
256  {
257  switch (phase) {
258  case tlm::END_REQ:
259  assert(t == sc_core::SC_ZERO_TIME); // FIXME: can t != 0?
260  // Request phase ended
262  return tlm::TLM_ACCEPTED;
263 
264  case tlm::BEGIN_RESP:
265  {
266  assert(t == sc_core::SC_ZERO_TIME); // FIXME: can t != 0?
267 
268  // Notify end of request phase if run thread is waiting for it
269  // FIXME
270  if (&trans == mCurrentTransaction) {
272  }
273 
274  assert(dynamic_cast<mytransaction_type*>(&trans));
275  mytransaction_type* myTrans = static_cast<mytransaction_type*>(&trans);
276  assert(myTrans);
277 
278  if (mEndResponseQueue.empty()) {
279  // Notify end of response phase after ACCEPT delay
281  }
282  mEndResponseQueue.push(myTrans);
283  return tlm::TLM_ACCEPTED;
284  }
285 
286  case tlm::BEGIN_REQ: // fall-through
287  case tlm::END_RESP: // fall-through
288  default:
289  // A target should never call nb_transport with these phases
290  assert(0); exit(1);
291 // return tlm::TLM_COMPLETED; //unreachable code
292  };
293  }
294 
295  void endResponse()
296  {
297  assert(!mEndResponseQueue.empty());
298  // end response phase
299  phase_type phase = tlm::END_RESP;
301  mytransaction_type* trans = mEndResponseQueue.front();
302  assert(trans);
303  mEndResponseQueue.pop();
304  #if ( ! NDEBUG )
305  sync_enum_type r = socket->nb_transport_fw(*trans, phase, t);
306  #endif /* ! NDEBUG */
307  assert(r == tlm::TLM_COMPLETED); // FIXME: target should return TLM_COMPLETED?
308  assert(t == sc_core::SC_ZERO_TIME); // t must be SC_ZERO_TIME
309 
310  logEndTransaction(*trans);
311  transPool.release(trans);
312 
313  if (!mEndResponseQueue.empty()) {
314  // Notify end of response phase after ACCEPT delay
316  }
317  }
318 
319 private:
321 
322 private:
323  unsigned int mNrOfTransactions;
324  unsigned int mBaseAddress;
325  SimplePool transPool;
326  unsigned int mTransactionCount;
328  std::queue<mytransaction_type*> mEndResponseQueue;
331 };
332 
333 #endif
SimpleATInitiator1::mBaseAddress
unsigned int mBaseAddress
Definition: SimpleATInitiator1.h:341
SC_THREAD
#define SC_THREAD(name)
Definition: sc_module.hh:313
data
const char data[]
Definition: circlebuf.test.cc:48
tlm_utils::simple_initiator_socket_b::register_nb_transport_bw
void register_nb_transport_bw(MODULE *mod, sync_enum_type(MODULE::*cb)(transaction_type &, phase_type &, sc_core::sc_time &))
Definition: simple_initiator_socket.h:97
sc_core::sc_module
Definition: sc_module.hh:101
tlm::tlm_phase
Definition: phase.hh:47
SimpleATInitiator1::ACCEPT_DELAY
const sc_core::sc_time ACCEPT_DELAY
Definition: SimpleATInitiator1.h:337
tlm::TLM_COMPLETED
@ TLM_COMPLETED
Definition: fw_bw_ifs.hh:65
SimpleATInitiator1::mEndResponseQueue
std::queue< mytransaction_type * > mEndResponseQueue
Definition: SimpleATInitiator1.h:345
SimpleATInitiator1::mytransaction_type
MyTransaction< unsigned int > mytransaction_type
Definition: SimpleATInitiator1.h:88
sc_core
Definition: messages.cc:31
SimpleATInitiator1::run
void run()
Definition: SimpleATInitiator1.h:200
tlm::TLM_WRITE_COMMAND
@ TLM_WRITE_COMMAND
Definition: gp.hh:102
SimpleATInitiator1::SimpleATInitiator1
SimpleATInitiator1(sc_core::sc_module_name name, unsigned int nrOfTransactions=0x5, unsigned int baseAddress=0x0)
Definition: SimpleATInitiator1.h:117
tlm::TLM_UPDATED
@ TLM_UPDATED
Definition: fw_bw_ifs.hh:65
SimpleATInitiator1::MyTransaction::MyTransaction
MyTransaction()
Definition: SimpleATInitiator1.h:73
tlm::TLM_OK_RESPONSE
@ TLM_OK_RESPONSE
Definition: gp.hh:108
tlm::END_REQ
@ END_REQ
Definition: phase.hh:42
sc_core::sc_module::sc_module
sc_module()
Definition: sc_module.cc:256
sc_core::SC_ZERO_TIME
const sc_time SC_ZERO_TIME
Definition: sc_time.cc:290
SimpleATInitiator1::endResponse
void endResponse()
Definition: SimpleATInitiator1.h:312
SimpleATInitiator1::initTransaction
bool initTransaction(mytransaction_type *&trans)
Definition: SimpleATInitiator1.h:139
gem5::VegaISA::r
Bitfield< 5 > r
Definition: pagetable.hh:60
SimpleATInitiator1::transaction_type
tlm::tlm_generic_payload transaction_type
Definition: SimpleATInitiator1.h:62
SimpleATInitiator1::mTransactionCount
unsigned int mTransactionCount
Definition: SimpleATInitiator1.h:343
SimpleATInitiator1::SimplePool::free
void free(tlm::tlm_generic_payload *t)
Definition: SimpleATInitiator1.h:105
sc_core::SC_NS
@ SC_NS
Definition: sc_time.hh:43
SimpleATInitiator1::SC_HAS_PROCESS
SC_HAS_PROCESS(SimpleATInitiator1)
SimpleATInitiator1::mEndRequestPhase
sc_core::sc_event mEndRequestPhase
Definition: SimpleATInitiator1.h:344
gem5::VegaISA::t
Bitfield< 51 > t
Definition: pagetable.hh:56
sc_core::sc_module::dont_initialize
void dont_initialize()
Definition: sc_module.cc:336
SimpleATInitiator1::MyTransaction
Definition: SimpleATInitiator1.h:70
SC_METHOD
#define SC_METHOD(name)
Definition: sc_module.hh:303
sc_core::sc_event
Definition: sc_event.hh:169
SimpleATInitiator1::SimplePool::SimplePool
SimplePool()
Definition: SimpleATInitiator1.h:94
sc_core::sc_time
Definition: sc_time.hh:49
tlm::TLM_READ_COMMAND
@ TLM_READ_COMMAND
Definition: gp.hh:101
tlm_utils::simple_initiator_socket< SimpleATInitiator1 >
sc_core::sc_module_name
Definition: sc_module_name.hh:41
mm
Definition: mm.h:8
SimpleATInitiator1::logStartTransation
void logStartTransation(mytransaction_type &trans)
Definition: SimpleATInitiator1.h:163
SimpleATInitiator1::MyTransaction::setData
void setData(DT &data)
Definition: SimpleATInitiator1.h:82
SimpleATInitiator1::MyTransaction::getData
DT getData() const
Definition: SimpleATInitiator1.h:83
tlm::END_RESP
@ END_RESP
Definition: phase.hh:44
SimpleATInitiator1
Definition: SimpleATInitiator1.h:42
gem5::X86ISA::exit
Bitfield< 3 > exit
Definition: misc.hh:848
sc_core::sc_event::notify
void notify()
Definition: sc_event.cc:337
tlm::BEGIN_REQ
@ BEGIN_REQ
Definition: phase.hh:41
SimpleATInitiator1::mCurrentTransaction
transaction_type * mCurrentTransaction
Definition: SimpleATInitiator1.h:347
SimpleATInitiator1::MyTransaction::mData
DT mData
Definition: SimpleATInitiator1.h:86
tlm::tlm_generic_payload
Definition: gp.hh:133
SimpleATInitiator1::SimplePool
Definition: SimpleATInitiator1.h:91
SimpleATInitiator1::sync_enum_type
tlm::tlm_sync_enum sync_enum_type
Definition: SimpleATInitiator1.h:64
sc_core::sc_object::name
const char * name() const
Definition: sc_object.cc:44
tlm::tlm_generic_payload::set_address
void set_address(const sc_dt::uint64 address)
Definition: gp.hh:202
SimpleATInitiator1::initiator_socket_type
tlm_utils::simple_initiator_socket< SimpleATInitiator1 > initiator_socket_type
Definition: SimpleATInitiator1.h:65
SimpleATInitiator1::phase_type
tlm::tlm_phase phase_type
Definition: SimpleATInitiator1.h:63
SimpleATInitiator1::transPool
SimplePool transPool
Definition: SimpleATInitiator1.h:342
tlm::tlm_sync_enum
tlm_sync_enum
Definition: fw_bw_ifs.hh:48
sc_core::sc_module::wait
void wait()
Definition: sc_module.cc:428
SimpleATInitiator1::SimplePool::claim
mytransaction_type * claim()
Definition: SimpleATInitiator1.h:95
SimpleATInitiator1::mNrOfTransactions
unsigned int mNrOfTransactions
Definition: SimpleATInitiator1.h:340
SimpleATInitiator1::SimplePool::release
void release(mytransaction_type *t)
Definition: SimpleATInitiator1.h:101
sc_core::sc_module::sensitive
sc_sensitive sensitive
Definition: sc_module.hh:210
tlm::tlm_mm_interface
Definition: gp.hh:50
SimpleATInitiator1::logEndTransaction
void logEndTransaction(mytransaction_type &trans)
Definition: SimpleATInitiator1.h:178
sc_core::sc_time_stamp
const sc_time & sc_time_stamp()
Definition: sc_main.cc:127
tlm::BEGIN_RESP
@ BEGIN_RESP
Definition: phase.hh:43
SimpleATInitiator1::myNBTransport
sync_enum_type myNBTransport(transaction_type &trans, phase_type &phase, sc_core::sc_time &t)
Definition: SimpleATInitiator1.h:272
SimpleATInitiator1::socket
initiator_socket_type socket
Definition: SimpleATInitiator1.h:113
SimpleATInitiator1::mEndResponseEvent
sc_core::sc_event mEndResponseEvent
Definition: SimpleATInitiator1.h:346
tlm::tlm_generic_payload::set_data_ptr
void set_data_ptr(unsigned char *data)
Definition: gp.hh:206
tlm::TLM_ACCEPTED
@ TLM_ACCEPTED
Definition: fw_bw_ifs.hh:65

Generated on Thu Jul 28 2022 13:32:39 for gem5 by doxygen 1.8.17