58class gs_memory :
public sc_core::sc_module
62 bool m_address_valid =
false;
63 bool m_relative_addresses;
68 template <
unsigned int N = 2>
75 gs_memory<BUSWIDTH>& m_mem;
77 uint8_t* m_ptr =
nullptr;
78 std::array<std::unique_ptr<SubBlock>, (1 << N)> m_sub_blocks;
79 bool m_use_sub_blocks =
false;
81 bool m_mapped =
false;
83 bool m_aligned =
false;
86 SubBlock(uint64_t address, uint64_t len, gs_memory& mem): m_len(len), m_address(address), m_mem(mem)
88 SCP_TRACE(())(
"Init");
93 SCP_WARN((), m_mem.name())(
"Reset (block at offset {:x})", m_address);
94 for (
unsigned int i = 0; i < N; i++) {
95 if (m_sub_blocks[i]) m_sub_blocks[i]->doreset();
97 if (m_mem.p_init_mem && m_ptr) {
98 memset(m_ptr, m_mem.p_init_mem_val, m_len);
102 SubBlock& access(uint64_t address)
107 if (m_ptr && !m_use_sub_blocks) {
108 assert(address >= m_address);
111 if (m_len > m_mem.p_max_block_size) {
112 m_use_sub_blocks =
true;
115 if (!m_use_sub_blocks) {
116 if (!((std::string)m_mem.p_mapfile).empty()) {
117 if ((m_ptr = MemoryServices::get().map_file(((std::string)(m_mem.p_mapfile)), m_len, m_address)) !=
124 std::stringstream shmname_stream;
126 DWORD pid = GetCurrentProcessId();
128 pid_t pid = getpid();
130 if (m_mem.p_shmem_prefix.get_value() !=
"")
131 shmname_stream <<
"/" << m_mem.p_shmem_prefix.get_value() << std::hex << pid;
133 shmname_stream <<
"/" << std::hex << pid <<
"-" << std::hex
134 << MemoryServices::get().get_shmem_seg_num();
135 if (shmname_stream.str().size() > 31) {
136 size_t hash = std::hash<std::string>{}(
137 shmname_stream.str());
138 shmname_stream.str(
"");
139 shmname_stream <<
"/" << std::hex << hash;
141 std::string shmname = shmname_stream.str();
143 if ((m_ptr = MemoryServices::get().map_mem_create(shmname, m_len, &shm_fd)) !=
nullptr) {
151 if (alloc_mem.ptr !=
nullptr) {
152 m_ptr = alloc_mem.ptr;
153 m_aligned = alloc_mem.is_aligned;
154 if (m_mem.p_init_mem) memset(m_ptr, m_mem.p_init_mem_val, m_len);
159 m_use_sub_blocks =
true;
162 if (m_len < m_mem.p_min_block_size) {
163 SCP_FATAL(m_mem.name()) <<
"Unable to allocate memory!";
167 assert((m_len & ~(-1llu << N)) == 0);
168 uint64_t m_sub_size = m_len >> N;
169 int i = (address - m_address) / (m_sub_size);
171 if (!m_sub_blocks[i]) {
172 m_sub_blocks[i] = std::make_unique<SubBlock<N>>((i * m_sub_size) + m_address, m_sub_size, m_mem);
174 return m_sub_blocks[i]->access(address);
177 uint64_t read_sub_blocks(uint8_t* data, uint64_t offset, uint64_t len)
179 uint64_t block_offset = offset - m_address;
180 uint64_t block_len = m_len - block_offset;
181 uint64_t remain_len = (len < block_len) ? len : block_len;
183 memcpy(data, &m_ptr[block_offset], remain_len);
188 uint64_t write_sub_blocks(
const uint8_t* data, uint64_t offset, uint64_t len)
190 uint64_t block_offset = offset - m_address;
191 uint64_t block_len = m_len - block_offset;
192 uint64_t remain_len = (len < block_len) ? len : block_len;
194 memcpy(&m_ptr[block_offset], data, remain_len);
199 uint8_t* get_ptr() {
return m_ptr; }
201 uint64_t get_len() {
return m_len; }
203 uint64_t get_address() {
return m_address; }
207 if (m_shmemID.empty())
return nullptr;
211 void free_raw_alloc()
219 _aligned_free(m_ptr);
231 MemoryServices::get().unmap_file(m_ptr, m_len);
239 std::unique_ptr<gs_memory<BUSWIDTH>::SubBlock<>> m_sub_block;
240 cci::cci_broker_handle m_broker;
243 virtual bool get_direct_mem_ptr(
int id, tlm::tlm_generic_payload& txn, tlm::tlm_dmi& dmi_data)
245 if (!p_dmi)
return false;
246 sc_dt::uint64 addr = txn.get_address();
248 if (!m_relative_addresses) {
249 if (addr < m_address) {
250 txn.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
255 if (addr >= m_size) {
256 txn.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
260 SCP_TRACE(()) <<
" : DMI access to address "
261 <<
"0x" << std::hex << addr;
264 dmi_data.allow_read();
266 dmi_data.allow_read_write();
268 SubBlock<>& blk = m_sub_block->access(addr);
270 uint8_t* ptr = blk.get_ptr();
271 uint64_t
size = blk.get_len();
272 uint64_t block_address = blk.get_address();
274 dmi_data.set_dmi_ptr(
reinterpret_cast<unsigned char*
>(ptr));
275 if (!m_relative_addresses) {
276 dmi_data.set_start_address(block_address + m_address);
277 dmi_data.set_end_address((block_address + m_address +
size) - 1);
279 dmi_data.set_start_address(block_address);
280 dmi_data.set_end_address((block_address +
size) - 1);
282 dmi_data.set_read_latency(p_latency);
283 dmi_data.set_write_latency(p_latency);
287 txn.set_extension(ext);
293 virtual void b_transport(
int id, tlm::tlm_generic_payload& txn, sc_core::sc_time& delay)
295 unsigned int len = txn.get_data_length();
296 unsigned char* ptr = txn.get_data_ptr();
297 sc_dt::uint64 addr = txn.get_address();
298 unsigned char* byt = txn.get_byte_enable_ptr();
299 unsigned int bel = txn.get_byte_enable_length();
301 if (txn.get_streaming_width() < len) {
302 SCP_FATAL(()) <<
"using streaming width: 0x" << std::hex << txn.get_streaming_width()
303 <<
" less than data length: 0x" << std::hex << len <<
" is not supported.";
305 SCP_INFO(()) <<
"Start b_transport :" << get_txn_command_str(txn) <<
" to address: 0x" << std::hex << addr
306 <<
" len: 0x" << std::hex << len;
308 if (!m_relative_addresses) {
309 if (addr < m_address) {
310 txn.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
315 if ((addr + len) > m_size) {
316 txn.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
320 switch (txn.get_command()) {
321 case tlm::TLM_READ_COMMAND:
323 for (
unsigned int i = 0; i < len; i++)
324 if (byt[i % bel] == TLM_BYTE_ENABLED) {
325 if (!read(&(ptr[i]), (addr + i), 1)) {
326 SCP_FATAL(()) <<
"Address + length is out of range of the memory size";
330 if (!read(ptr, addr, len)) {
331 SCP_FATAL(()) <<
"Address + length is out of range of the memory size";
335 case tlm::TLM_WRITE_COMMAND:
337 txn.set_response_status(tlm::TLM_COMMAND_ERROR_RESPONSE);
341 for (
unsigned int i = 0; i < len; i++)
342 if (byt[i % bel] == TLM_BYTE_ENABLED) {
343 if (!write(&(ptr[i]), (addr + i), 1)) {
344 SCP_FATAL(()) <<
"Address + length is out of range of the memory size";
348 if (!write(ptr, addr, len)) {
349 SCP_FATAL(()) <<
"Address + length is out of range of the memory size";
354 SCP_FATAL(()) <<
"TLM command not supported";
358 txn.set_response_status(tlm::TLM_OK_RESPONSE);
359 SCP_INFO(()) <<
"Completed b_transport :" << scp::scp_txn_tostring(txn);
361 if (p_dmi) txn.set_dmi_allowed(
true);
364 const char* get_txn_command_str(
const tlm::tlm_generic_payload& trans)
366 switch (trans.get_command()) {
367 case tlm::TLM_READ_COMMAND:
369 case tlm::TLM_WRITE_COMMAND:
371 case tlm::TLM_IGNORE_COMMAND:
379 virtual unsigned int transport_dbg(
int id, tlm::tlm_generic_payload& txn)
381 unsigned int len = txn.get_data_length();
382 sc_dt::uint64 addr = txn.get_address();
383 sc_core::sc_time delay = sc_core::SC_ZERO_TIME;
384 SCP_INFO(()) <<
"Start b_transport dbg :" << get_txn_command_str(txn) <<
" to address: 0x" << std::hex << addr
385 <<
" len: 0x" << std::hex << len;
386 b_transport(
id, txn, delay);
387 SCP_INFO(()) <<
"Completed b_transport dbg :" << get_txn_command_str(txn) <<
" to address: 0x" << std::hex
388 << addr <<
" len: 0x" << std::hex << len <<
" status: " << txn.get_response_string();
389 if (txn.get_response_status() == tlm::TLM_OK_RESPONSE)
395 bool read(uint8_t* data, uint64_t offset, uint64_t len)
401 if (!m_sub_block) before_end_of_elaboration();
403 uint64_t remain_len = 0;
404 uint64_t data_ptr_offset = 0;
406 if (offset + len > m_size) {
411 SubBlock<>& blk = m_sub_block->access(offset + data_ptr_offset);
413 remain_len = blk.read_sub_blocks(&data[data_ptr_offset], offset + data_ptr_offset, len);
415 data_ptr_offset += remain_len;
421 bool write(
const uint8_t* data, uint64_t offset, uint64_t len)
423 if (!m_sub_block) before_end_of_elaboration();
425 uint64_t remain_len = 0;
426 uint64_t data_ptr_offset = 0;
428 if (offset + len > m_size) {
433 SubBlock<>& blk = m_sub_block->access(offset + data_ptr_offset);
435 remain_len = blk.write_sub_blocks(&data[data_ptr_offset], offset + data_ptr_offset, len);
437 data_ptr_offset += remain_len;
445 tlm_utils::multi_passthrough_target_socket<gs_memory<BUSWIDTH>, BUSWIDTH> socket;
447 cci::cci_param<bool> p_rom;
448 cci::cci_param<bool> p_dmi;
449 cci::cci_param<sc_core::sc_time> p_latency;
450 cci::cci_param<std::string> p_mapfile;
451 cci::cci_param<uint64_t> p_max_block_size;
452 cci::cci_param<uint64_t> p_min_block_size;
453 cci::cci_param<bool> p_shmem;
454 cci::cci_param<std::string> p_shmem_prefix;
455 cci::cci_param<bool> p_init_mem;
456 cci::cci_param<int> p_init_mem_val;
465 gs_memory(sc_core::sc_module_name name, uint64_t _size = 0)
466 : m_sub_block(
nullptr)
467 , m_broker(cci::cci_get_broker())
468 , socket(
"target_socket")
470 , p_rom(
"read_only",
false,
"Read Only memory (default false)")
471 , p_dmi(
"dmi_allow",
true,
"DMI allowed (default true)")
472 , p_latency(
"latency", sc_core::sc_time(10, sc_core::SC_NS),
"Latency reported for DMI access")
473 , p_mapfile(
"map_file",
"",
"(optional) file to map this memory")
474 , p_max_block_size(
"max_block_size", 0x100000000,
"Maximum size of the sub bloc")
475 , p_min_block_size(
"min_block_size", get_page_size(),
"Minimum size of the sub bloc")
476 , p_shmem(
"shared_memory",
false,
"Allocate using shared memory")
477 , p_shmem_prefix(
"shared_memory_prefix",
"",
"(optional) prefix_for shared memory file")
478 , p_init_mem(
"init_mem",
false,
"Initialize allocated memory")
479 , p_init_mem_val(
"init_mem_val", 0,
"Value to initialize memory to")
480 , load(
"load", [&](
const uint8_t* data, uint64_t offset, uint64_t len) ->
void {
481 if (!write(data, offset, len)) {
482 SCP_WARN(()) <<
" Offset : 0x" << std::hex << offset <<
" of the out of range";
486 SCP_DEBUG(()) <<
"Memory constructor";
487 MemoryServices::get().init();
489 std::string ts_name = std::string(sc_module::name()) +
".target_socket";
490 if (!m_broker.has_preset_value(ts_name +
".size")) {
491 m_broker.set_preset_cci_value(ts_name +
".size", cci::cci_value(_size));
495 socket.register_b_transport(
this, &gs_memory::b_transport);
496 socket.register_transport_dbg(
this, &gs_memory::transport_dbg);
497 socket.register_get_direct_mem_ptr(
this, &gs_memory::get_direct_mem_ptr);
499 reset.register_value_changed_cb([&](
bool value) {
501 SCP_WARN(()) <<
"Reset";
502 m_sub_block->doreset();
507 static size_t get_page_size()
513 page_size = si.dwPageSize;
515 page_size = sysconf(_SC_PAGE_SIZE);
520 void before_end_of_elaboration()
526 std::string ts_name = std::string(sc_module::name()) +
".target_socket";
531 m_sub_block = std::make_unique<gs_memory<BUSWIDTH>::SubBlock<>>(0, m_size, *
this);
533 SCP_DEBUG(()) <<
"m_address: " << m_address;
534 SCP_DEBUG(()) <<
"m_size: " << m_size;
536 m_relative_addresses =
true;
537 if (gs::cci_get<bool>(m_broker, ts_name +
".relative_addresses", m_relative_addresses)) {
538 m_broker.lock_preset_value(ts_name +
".relative_addresses");
542 gs_memory() =
delete;
543 gs_memory(
const gs_memory&) =
delete;
555 std::string ts_name = std::string(sc_module::name()) +
".target_socket";
556 std::string ts_name_alias;
557 if (gs::cci_get<std::string>(m_broker, ts_name +
".0", ts_name_alias)) {
559 if (m_broker.has_preset_value(ts_name +
".size") &&
560 m_broker.get_preset_cci_value(ts_name +
".size").is_number()) {
562 (
"The configuration alias provided ({}) will be ignored as a valid size is "
566 ts_name = ts_name_alias;
567 if (ts_name[0] ==
'&') ts_name = (ts_name.erase(0, 1)) +
".target_socket";
570 m_size = gs::cci_get<uint64_t>(m_broker, ts_name +
".size");
582 if (!m_address_valid) {
583 std::string ts_name = std::string(sc_module::name()) +
".target_socket";
584 std::string ts_name_alias;
585 if (gs::cci_get<std::string>(m_broker, ts_name +
".0", ts_name_alias)) {
587 if (gs::cci_get<uint64_t>(m_broker, ts_name +
".address", m_address)) {
589 (
"The configuration alias provided ({}) will be ignored as a valid address is "
593 ts_name = ts_name_alias;
594 if (ts_name[0] ==
'&') ts_name = (ts_name.erase(0, 1)) +
".target_socket";
597 if (!m_broker.has_preset_value(ts_name +
".address")) {
599 SCP_WARN(()) <<
"Can't find " << ts_name <<
".address";
601 m_address = gs::cci_get<uint64_t>(m_broker, ts_name +
".address");
603 m_broker.lock_preset_value(ts_name +
".address");
604 m_address_valid =
true;