simple_initiator_socket.h (13513:bbf275465d3d) simple_initiator_socket.h (13586:008fe87c1ad4)
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#ifndef __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__
21#define __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__
22
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#ifndef __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__
21#define __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__
22
23#include <tlm>
23#include "../core/sc_module.hh"
24#include "../core/sc_port.hh"
25#include "../tlm_core/2/generic_payload/gp.hh"
26#include "../tlm_core/2/interfaces/fw_bw_ifs.hh"
27#include "../tlm_core/2/sockets/initiator_socket.hh"
28#include "../utils/sc_report_handler.hh"
29#include "convenience_socket_bases.h"
24
30
25#include "tlm_utils/convenience_socket_bases.h"
26
27namespace tlm_utils
28{
29
30template <typename MODULE, unsigned int BUSWIDTH, typename TYPES,
31 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND>
32class simple_initiator_socket_b :
33 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>,
34 protected simple_socket_base
35{
36 public:
37 typedef typename TYPES::tlm_payload_type transaction_type;
38 typedef typename TYPES::tlm_phase_type phase_type;
39 typedef tlm::tlm_sync_enum sync_enum_type;
40 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type;
41 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type;
42 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type;
43
44 public:
45 static const char *
46 default_name()
47 {
48 return sc_core::sc_gen_unique_name("simple_initiator_socket");
49 }
50
51 explicit simple_initiator_socket_b(const char *n=default_name()) :
52 base_type(n), m_process(this)
53 {
54 this->m_export.bind(m_process);
55 }
56
57 void
58 register_nb_transport_bw(MODULE *mod,
59 sync_enum_type (MODULE::*cb)(transaction_type &, phase_type &,
60 sc_core::sc_time &))
61 {
62 m_process.set_transport_ptr(mod, cb);
63 }
64
65 void
66 register_invalidate_direct_mem_ptr(MODULE *mod,
67 void (MODULE::*cb)(sc_dt::uint64, sc_dt::uint64))
68 {
69 m_process.set_invalidate_direct_mem_ptr(mod, cb);
70 }
71
72 private:
73 class process : public tlm::tlm_bw_transport_if<TYPES>,
74 protected convenience_socket_cb_holder
75 {
76 public:
77 typedef sync_enum_type (MODULE::*TransportPtr)(
78 transaction_type &, phase_type &, sc_core::sc_time &);
79 typedef void (MODULE::*InvalidateDirectMemPtr)(
80 sc_dt::uint64, sc_dt::uint64);
81
82 explicit process(simple_socket_base *owner) :
83 convenience_socket_cb_holder(owner), m_mod(0),
84 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0)
85 {}
86
87 void
88 set_transport_ptr(MODULE *mod, TransportPtr p)
89 {
90 if (m_transport_ptr) {
91 display_warning("non-blocking callback already registered");
92 return;
93 }
94 sc_assert(!m_mod || m_mod == mod);
95 m_mod = mod;
96 m_transport_ptr = p;
97 }
98
99 void
100 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p)
101 {
102 if (m_invalidate_direct_mem_ptr) {
103 display_warning("invalidate DMI callback already registered");
104 return;
105 }
106 sc_assert(!m_mod || m_mod == mod);
107 m_mod = mod;
108 m_invalidate_direct_mem_ptr = p;
109 }
110
111 sync_enum_type
112 nb_transport_bw(transaction_type &trans, phase_type &phase,
113 sc_core::sc_time &t)
114 {
115 if (m_transport_ptr) {
116 // Forward call.
117 sc_assert(m_mod);
118 return (m_mod->*m_transport_ptr)(trans, phase, t);
119 }
120 display_error("no transport callback registered");
121 return tlm::TLM_COMPLETED;
122 }
123
124 void
125 invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
126 sc_dt::uint64 end_range)
127 {
128 if (m_invalidate_direct_mem_ptr) {
129 // Forward call.
130 sc_assert(m_mod);
131 (m_mod->*m_invalidate_direct_mem_ptr)(
132 start_range, end_range);
133 }
134 }
135
136 private:
137 MODULE *m_mod;
138 TransportPtr m_transport_ptr;
139 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr;
140 };
141
142 private:
143 const sc_core::sc_object *get_socket() const { return this; }
144
145 private:
146 process m_process;
147};
148
149template <typename MODULE, unsigned int BUSWIDTH=32,
150 typename TYPES=tlm::tlm_base_protocol_types>
151class simple_initiator_socket :
152 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES>
153{
154 typedef simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES> socket_b;
155 public:
156 simple_initiator_socket() : socket_b() {}
157 explicit simple_initiator_socket(const char *name) : socket_b(name) {}
158};
159
160template <typename MODULE, unsigned int BUSWIDTH=32,
161 typename TYPES=tlm::tlm_base_protocol_types>
162class simple_initiator_socket_optional :
163 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES,
164 sc_core::SC_ZERO_OR_MORE_BOUND>
165{
166 typedef simple_initiator_socket_b<
167 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b;
168 public:
169 simple_initiator_socket_optional() : socket_b() {}
170 explicit simple_initiator_socket_optional(const char *name) :
171 socket_b(name)
172 {}
173};
174
175
176// Tagged version
177
178template <typename MODULE, unsigned int BUSWIDTH, typename TYPES,
179 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND>
180class simple_initiator_socket_tagged_b :
181 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>,
182 protected simple_socket_base
183{
184 public:
185 typedef typename TYPES::tlm_payload_type transaction_type;
186 typedef typename TYPES::tlm_phase_type phase_type;
187 typedef tlm::tlm_sync_enum sync_enum_type;
188 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type;
189 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type;
190 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type;
191
192 public:
193 static const char *
194 default_name()
195 {
196 return sc_core::sc_gen_unique_name("simple_initiator_socket_tagged");
197 }
198
199 explicit simple_initiator_socket_tagged_b(const char *n=default_name()) :
200 base_type(n), m_process(this)
201 {
202 this->m_export.bind(m_process);
203 }
204
205 void
206 register_nb_transport_bw(MODULE *mod,
207 sync_enum_type (MODULE::*cb)(
208 int, transaction_type &, phase_type &, sc_core::sc_time &),
209 int id)
210 {
211 m_process.set_transport_ptr(mod, cb);
212 m_process.set_transport_user_id(id);
213 }
214
215 void
216 register_invalidate_direct_mem_ptr(MODULE *mod,
217 void (MODULE::*cb)(int, sc_dt::uint64, sc_dt::uint64), int id)
218 {
219 m_process.set_invalidate_direct_mem_ptr(mod, cb);
220 m_process.set_invalidate_dmi_user_id(id);
221 }
222
223 private:
224 class process : public tlm::tlm_bw_transport_if<TYPES>,
225 protected convenience_socket_cb_holder
226 {
227 public:
228 typedef sync_enum_type (MODULE::*TransportPtr)(
229 int, transaction_type &, phase_type &, sc_core::sc_time &);
230 typedef void (MODULE::*InvalidateDirectMemPtr)(
231 int, sc_dt::uint64, sc_dt::uint64);
232
233 explicit process(simple_socket_base *owner) :
234 convenience_socket_cb_holder(owner), m_mod(0),
235 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0),
236 m_transport_user_id(0), m_invalidate_direct_mem_user_id(0)
237 {}
238
239 void set_transport_user_id(int id) { m_transport_user_id = id; }
240 void
241 set_invalidate_dmi_user_id(int id)
242 {
243 m_invalidate_direct_mem_user_id = id;
244 }
245
246 void
247 set_transport_ptr(MODULE *mod, TransportPtr p)
248 {
249 if (m_transport_ptr) {
250 display_warning("non-blocking callback already registered");
251 return;
252 }
253 sc_assert(!m_mod || m_mod == mod);
254 m_mod = mod;
255 m_transport_ptr = p;
256 }
257
258 void
259 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p)
260 {
261 if (m_invalidate_direct_mem_ptr) {
262 display_warning("invalidate DMI callback already registered");
263 return;
264 }
265 sc_assert(!m_mod || m_mod == mod);
266 m_mod = mod;
267 m_invalidate_direct_mem_ptr = p;
268 }
269
270 sync_enum_type
271 nb_transport_bw(transaction_type &trans, phase_type &phase,
272 sc_core::sc_time &t)
273 {
274 if (m_transport_ptr) {
275 // Forward call.
276 sc_assert(m_mod);
277 return (m_mod->*m_transport_ptr)(
278 m_transport_user_id, trans, phase, t);
279 }
280 display_error("no transport callback registered");
281 return tlm::TLM_COMPLETED;
282 }
283
284 void
285 invalidate_direct_mem_ptr(
286 sc_dt::uint64 start_range, sc_dt::uint64 end_range)
287 {
288 if (m_invalidate_direct_mem_ptr) {
289 // Forward call.
290 sc_assert(m_mod);
291 (m_mod->*m_invalidate_direct_mem_ptr)(
292 m_invalidate_direct_mem_user_id,
293 start_range, end_range);
294 }
295 }
296
297 private:
298 MODULE *m_mod;
299 TransportPtr m_transport_ptr;
300 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr;
301 int m_transport_user_id;
302 int m_invalidate_direct_mem_user_id;
303 };
304
305 private:
306 const sc_core::sc_object *get_socket() const { return this; }
307
308 private:
309 process m_process;
310};
311
312template <typename MODULE, unsigned int BUSWIDTH=32,
313 typename TYPES=tlm::tlm_base_protocol_types>
314class simple_initiator_socket_tagged :
315 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES>
316{
317 typedef simple_initiator_socket_tagged_b<
318 MODULE, BUSWIDTH, TYPES> socket_b;
319 public:
320 simple_initiator_socket_tagged() : socket_b() {}
321 explicit simple_initiator_socket_tagged(const char *name) :
322 socket_b(name)
323 {}
324};
325
326template <typename MODULE, unsigned int BUSWIDTH=32,
327 typename TYPES=tlm::tlm_base_protocol_types>
328class simple_initiator_socket_tagged_optional :
329 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES,
330 sc_core::SC_ZERO_OR_MORE_BOUND>
331{
332 typedef simple_initiator_socket_tagged_b<
333 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b;
334 public:
335 simple_initiator_socket_tagged_optional() : socket_b() {}
336 explicit simple_initiator_socket_tagged_optional(const char *name) :
337 socket_b(name)
338 {}
339};
340
341} // namespace tlm_utils
342
343#endif /* __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__ */
31namespace tlm_utils
32{
33
34template <typename MODULE, unsigned int BUSWIDTH, typename TYPES,
35 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND>
36class simple_initiator_socket_b :
37 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>,
38 protected simple_socket_base
39{
40 public:
41 typedef typename TYPES::tlm_payload_type transaction_type;
42 typedef typename TYPES::tlm_phase_type phase_type;
43 typedef tlm::tlm_sync_enum sync_enum_type;
44 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type;
45 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type;
46 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type;
47
48 public:
49 static const char *
50 default_name()
51 {
52 return sc_core::sc_gen_unique_name("simple_initiator_socket");
53 }
54
55 explicit simple_initiator_socket_b(const char *n=default_name()) :
56 base_type(n), m_process(this)
57 {
58 this->m_export.bind(m_process);
59 }
60
61 void
62 register_nb_transport_bw(MODULE *mod,
63 sync_enum_type (MODULE::*cb)(transaction_type &, phase_type &,
64 sc_core::sc_time &))
65 {
66 m_process.set_transport_ptr(mod, cb);
67 }
68
69 void
70 register_invalidate_direct_mem_ptr(MODULE *mod,
71 void (MODULE::*cb)(sc_dt::uint64, sc_dt::uint64))
72 {
73 m_process.set_invalidate_direct_mem_ptr(mod, cb);
74 }
75
76 private:
77 class process : public tlm::tlm_bw_transport_if<TYPES>,
78 protected convenience_socket_cb_holder
79 {
80 public:
81 typedef sync_enum_type (MODULE::*TransportPtr)(
82 transaction_type &, phase_type &, sc_core::sc_time &);
83 typedef void (MODULE::*InvalidateDirectMemPtr)(
84 sc_dt::uint64, sc_dt::uint64);
85
86 explicit process(simple_socket_base *owner) :
87 convenience_socket_cb_holder(owner), m_mod(0),
88 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0)
89 {}
90
91 void
92 set_transport_ptr(MODULE *mod, TransportPtr p)
93 {
94 if (m_transport_ptr) {
95 display_warning("non-blocking callback already registered");
96 return;
97 }
98 sc_assert(!m_mod || m_mod == mod);
99 m_mod = mod;
100 m_transport_ptr = p;
101 }
102
103 void
104 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p)
105 {
106 if (m_invalidate_direct_mem_ptr) {
107 display_warning("invalidate DMI callback already registered");
108 return;
109 }
110 sc_assert(!m_mod || m_mod == mod);
111 m_mod = mod;
112 m_invalidate_direct_mem_ptr = p;
113 }
114
115 sync_enum_type
116 nb_transport_bw(transaction_type &trans, phase_type &phase,
117 sc_core::sc_time &t)
118 {
119 if (m_transport_ptr) {
120 // Forward call.
121 sc_assert(m_mod);
122 return (m_mod->*m_transport_ptr)(trans, phase, t);
123 }
124 display_error("no transport callback registered");
125 return tlm::TLM_COMPLETED;
126 }
127
128 void
129 invalidate_direct_mem_ptr(sc_dt::uint64 start_range,
130 sc_dt::uint64 end_range)
131 {
132 if (m_invalidate_direct_mem_ptr) {
133 // Forward call.
134 sc_assert(m_mod);
135 (m_mod->*m_invalidate_direct_mem_ptr)(
136 start_range, end_range);
137 }
138 }
139
140 private:
141 MODULE *m_mod;
142 TransportPtr m_transport_ptr;
143 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr;
144 };
145
146 private:
147 const sc_core::sc_object *get_socket() const { return this; }
148
149 private:
150 process m_process;
151};
152
153template <typename MODULE, unsigned int BUSWIDTH=32,
154 typename TYPES=tlm::tlm_base_protocol_types>
155class simple_initiator_socket :
156 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES>
157{
158 typedef simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES> socket_b;
159 public:
160 simple_initiator_socket() : socket_b() {}
161 explicit simple_initiator_socket(const char *name) : socket_b(name) {}
162};
163
164template <typename MODULE, unsigned int BUSWIDTH=32,
165 typename TYPES=tlm::tlm_base_protocol_types>
166class simple_initiator_socket_optional :
167 public simple_initiator_socket_b<MODULE, BUSWIDTH, TYPES,
168 sc_core::SC_ZERO_OR_MORE_BOUND>
169{
170 typedef simple_initiator_socket_b<
171 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b;
172 public:
173 simple_initiator_socket_optional() : socket_b() {}
174 explicit simple_initiator_socket_optional(const char *name) :
175 socket_b(name)
176 {}
177};
178
179
180// Tagged version
181
182template <typename MODULE, unsigned int BUSWIDTH, typename TYPES,
183 sc_core::sc_port_policy POL=sc_core::SC_ONE_OR_MORE_BOUND>
184class simple_initiator_socket_tagged_b :
185 public tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL>,
186 protected simple_socket_base
187{
188 public:
189 typedef typename TYPES::tlm_payload_type transaction_type;
190 typedef typename TYPES::tlm_phase_type phase_type;
191 typedef tlm::tlm_sync_enum sync_enum_type;
192 typedef tlm::tlm_fw_transport_if<TYPES> fw_interface_type;
193 typedef tlm::tlm_bw_transport_if<TYPES> bw_interface_type;
194 typedef tlm::tlm_initiator_socket<BUSWIDTH, TYPES, 1, POL> base_type;
195
196 public:
197 static const char *
198 default_name()
199 {
200 return sc_core::sc_gen_unique_name("simple_initiator_socket_tagged");
201 }
202
203 explicit simple_initiator_socket_tagged_b(const char *n=default_name()) :
204 base_type(n), m_process(this)
205 {
206 this->m_export.bind(m_process);
207 }
208
209 void
210 register_nb_transport_bw(MODULE *mod,
211 sync_enum_type (MODULE::*cb)(
212 int, transaction_type &, phase_type &, sc_core::sc_time &),
213 int id)
214 {
215 m_process.set_transport_ptr(mod, cb);
216 m_process.set_transport_user_id(id);
217 }
218
219 void
220 register_invalidate_direct_mem_ptr(MODULE *mod,
221 void (MODULE::*cb)(int, sc_dt::uint64, sc_dt::uint64), int id)
222 {
223 m_process.set_invalidate_direct_mem_ptr(mod, cb);
224 m_process.set_invalidate_dmi_user_id(id);
225 }
226
227 private:
228 class process : public tlm::tlm_bw_transport_if<TYPES>,
229 protected convenience_socket_cb_holder
230 {
231 public:
232 typedef sync_enum_type (MODULE::*TransportPtr)(
233 int, transaction_type &, phase_type &, sc_core::sc_time &);
234 typedef void (MODULE::*InvalidateDirectMemPtr)(
235 int, sc_dt::uint64, sc_dt::uint64);
236
237 explicit process(simple_socket_base *owner) :
238 convenience_socket_cb_holder(owner), m_mod(0),
239 m_transport_ptr(0), m_invalidate_direct_mem_ptr(0),
240 m_transport_user_id(0), m_invalidate_direct_mem_user_id(0)
241 {}
242
243 void set_transport_user_id(int id) { m_transport_user_id = id; }
244 void
245 set_invalidate_dmi_user_id(int id)
246 {
247 m_invalidate_direct_mem_user_id = id;
248 }
249
250 void
251 set_transport_ptr(MODULE *mod, TransportPtr p)
252 {
253 if (m_transport_ptr) {
254 display_warning("non-blocking callback already registered");
255 return;
256 }
257 sc_assert(!m_mod || m_mod == mod);
258 m_mod = mod;
259 m_transport_ptr = p;
260 }
261
262 void
263 set_invalidate_direct_mem_ptr(MODULE *mod, InvalidateDirectMemPtr p)
264 {
265 if (m_invalidate_direct_mem_ptr) {
266 display_warning("invalidate DMI callback already registered");
267 return;
268 }
269 sc_assert(!m_mod || m_mod == mod);
270 m_mod = mod;
271 m_invalidate_direct_mem_ptr = p;
272 }
273
274 sync_enum_type
275 nb_transport_bw(transaction_type &trans, phase_type &phase,
276 sc_core::sc_time &t)
277 {
278 if (m_transport_ptr) {
279 // Forward call.
280 sc_assert(m_mod);
281 return (m_mod->*m_transport_ptr)(
282 m_transport_user_id, trans, phase, t);
283 }
284 display_error("no transport callback registered");
285 return tlm::TLM_COMPLETED;
286 }
287
288 void
289 invalidate_direct_mem_ptr(
290 sc_dt::uint64 start_range, sc_dt::uint64 end_range)
291 {
292 if (m_invalidate_direct_mem_ptr) {
293 // Forward call.
294 sc_assert(m_mod);
295 (m_mod->*m_invalidate_direct_mem_ptr)(
296 m_invalidate_direct_mem_user_id,
297 start_range, end_range);
298 }
299 }
300
301 private:
302 MODULE *m_mod;
303 TransportPtr m_transport_ptr;
304 InvalidateDirectMemPtr m_invalidate_direct_mem_ptr;
305 int m_transport_user_id;
306 int m_invalidate_direct_mem_user_id;
307 };
308
309 private:
310 const sc_core::sc_object *get_socket() const { return this; }
311
312 private:
313 process m_process;
314};
315
316template <typename MODULE, unsigned int BUSWIDTH=32,
317 typename TYPES=tlm::tlm_base_protocol_types>
318class simple_initiator_socket_tagged :
319 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES>
320{
321 typedef simple_initiator_socket_tagged_b<
322 MODULE, BUSWIDTH, TYPES> socket_b;
323 public:
324 simple_initiator_socket_tagged() : socket_b() {}
325 explicit simple_initiator_socket_tagged(const char *name) :
326 socket_b(name)
327 {}
328};
329
330template <typename MODULE, unsigned int BUSWIDTH=32,
331 typename TYPES=tlm::tlm_base_protocol_types>
332class simple_initiator_socket_tagged_optional :
333 public simple_initiator_socket_tagged_b<MODULE, BUSWIDTH, TYPES,
334 sc_core::SC_ZERO_OR_MORE_BOUND>
335{
336 typedef simple_initiator_socket_tagged_b<
337 MODULE, BUSWIDTH, TYPES, sc_core::SC_ZERO_OR_MORE_BOUND> socket_b;
338 public:
339 simple_initiator_socket_tagged_optional() : socket_b() {}
340 explicit simple_initiator_socket_tagged_optional(const char *name) :
341 socket_b(name)
342 {}
343};
344
345} // namespace tlm_utils
346
347#endif /* __SYSTEMC_EXT_TLM_UTILS_SIMPLE_INITIATOR_SOCKET_H__ */