Update TLM model of ethernet to work with new address map

Author: jgavillalobos

modules/edge-detector/include/address_map.hpp

@@ -63,25 +63,39 @@
 #define IMG_INPROCESS_C_ADDRESS_LO (CUSTOM_SW_MEMORY_OFFSET + IMG_INPROCESS_C_OFFSET)
 #define IMG_INPROCESS_C_ADDRESS_HI (IMG_INPROCESS_C_ADDRESS_LO + IMG_INPROCESS_C_SIZE)
 
-//Img Compressed
-#define IMG_COMPRESSED_OFFSET 0x0025803Cu
-#define IMG_COMPRESSED_SIZE 307200
-#define IMG_COMPRESSED_ADDRESS_LO (CUSTOM_SW_MEMORY_OFFSET + IMG_COMPRESSED_OFFSET)
-#define IMG_COMPRESSED_ADDRESS_HI (IMG_COMPRESSED_ADDRESS_LO + IMG_COMPRESSED_SIZE)
+//Img In Process D
+#define IMG_INPROCESS_D_OFFSET 0x0025803Cu
+#define IMG_INPROCESS_D_SIZE 307200
+#define IMG_INPROCESS_D_ADDRESS_LO (CUSTOM_SW_MEMORY_OFFSET + IMG_INPROCESS_D_OFFSET)
+#define IMG_INPROCESS_D_ADDRESS_HI (IMG_INPROCESS_D_ADDRESS_LO + IMG_INPROCESS_D_SIZE)
 
-//Img Compressed
+// Img Output
 #define IMG_OUTPUT_OFFSET 0x002A303Cu
 #define IMG_OUTPUT_SIZE 307200
 #define IMG_OUTPUT_ADDRESS_LO (CUSTOM_HW_MEMORY_OFFSET + IMG_OUTPUT_OFFSET)
 #define IMG_OUTPUT_ADDRESS_HI (IMG_OUTPUT_ADDRESS_LO + IMG_OUTPUT_SIZE)
 
-#define ETHERNET_DATA_WR    0x002A3034u
-#define ETHERNET_DATA_DONE  0x002A303Cu
-#define ETHERNET_CHECK_DONE 0x002A303Du
+// Img Output Size
+#define IMG_OUTPUT_SIZE_OFFSET 0x002EE03Cu
+#define IMG_OUTPUT_SIZE_SIZE 4
+#define IMG_OUTPUT_SIZE_ADDRESS_LO (CUSTOM_HW_MEMORY_OFFSET + IMG_OUTPUT_SIZE_OFFSET)
+#define IMG_OUTPUT_SIZE_ADDRESS_HI (IMG_OUTPUT_SIZE_ADDRESS_LO + IMG_OUTPUT_SIZE_SIZE)
+
+// Img Output Done
+#define IMG_OUTPUT_DONE_OFFSET 0x002EE040u
+#define IMG_OUTPUT_DONE_SIZE 4
+#define IMG_OUTPUT_DONE_ADDRESS_LO (CUSTOM_HW_MEMORY_OFFSET + IMG_OUTPUT_DONE_OFFSET)
+#define IMG_OUTPUT_DONE_ADDRESS_HI (IMG_OUTPUT_DONE_ADDRESS_LO + IMG_OUTPUT_DONE_SIZE)
+
+// Img Output Status
+#define IMG_OUTPUT_STATUS_OFFSET 0x002EE044u
+#define IMG_OUTPUT_STATUS_SIZE 4
+#define IMG_OUTPUT_STATUS_ADDRESS_LO (CUSTOM_HW_MEMORY_OFFSET + IMG_OUTPUT_STATUS_OFFSET)
+#define IMG_OUTPUT_STATUS_ADDRESS_HI (IMG_OUTPUT_STATUS_ADDRESS_LO + IMG_OUTPUT_STATUS_SIZE)
 
 //Memory Definition
 #define MEMORY_OFFSET (IMG_INPUT_OFFSET)
-#define MEMORY_SIZE (IMG_INPUT_SIZE + IMG_INPROCESS_A_SIZE + IMG_INPROCESS_B_SIZE + IMG_INPROCESS_C_SIZE + IMG_COMPRESSED_SIZE)
+#define MEMORY_SIZE (IMG_INPUT_SIZE + IMG_INPROCESS_A_SIZE + IMG_INPROCESS_B_SIZE + IMG_INPROCESS_C_SIZE + IMG_INPROCESS_D_SIZE)
 #define MEMORY_ADDRESS_LO (CUSTOM_HW_MEMORY_OFFSET + MEMORY_OFFSET)
 #define MEMORY_ADDRESS_HI (MEMORY_ADDRESS_LO + MEMORY_SIZE)
 

modules/router/include/memory_tlm.hpp

@@ -11,13 +11,14 @@ using namespace std;
 #include <tlm_utils/peq_with_cb_and_phase.h>
 
 #include "../src/img_target.cpp"
+#include "address_map.hpp"
 
 //Extended Unification TLM
 struct memory_tlm : public img_target
 {
 
     memory_tlm(sc_module_name name) : img_target((std::string(name) + "_target").c_str()) {
-      mem_array = new unsigned char[2764852];
+      mem_array = new unsigned char[MEMORY_SIZE];
 #ifdef DISABLE_MEM_DEBUG
       this->use_prints = false;
 #endif //DISABLE_MEM_DEBUG

modules/router/include/packetGenerator_tlm.hpp

@@ -14,12 +14,14 @@ using namespace std;
 
 #include "packetGenerator.h"
 #include "../src/img_target.cpp"
+#include "address_map.hpp"
 
 //Extended Unification TLM
 struct packetGenerator_tlm : public packetGenerator, public img_target
 {
 
     packetGenerator_tlm(sc_module_name name, sca_core::sca_time sample_time) : packetGenerator((std::string(name) + "_AMS_HW_block").c_str(), sample_time), img_target((std::string(name) + "_target").c_str()), tmp_data_length(0) {
+       tmp_data = new unsigned char[IMG_OUTPUT_SIZE];
 #ifdef DISABLE_PACKET_GENERATOR_DEBUG
         this->use_prints = false;
 #endif // DISABLE_PACKET_GENERATOR_DEBUG
@@ -32,5 +34,6 @@ struct packetGenerator_tlm : public packetGenerator, public img_target
 
     unsigned int tmp_data_length;
     unsigned char* tmp_data;
+
 };
 #endif // PACKET_GENERATOR_TLM_HPP

modules/router/src/img_router.cpp

@@ -126,22 +126,23 @@ struct img_router: sc_module
             return IMG_SOBEL_INITIATOR_ID;
         }
 
-        case ETHERNET_DATA_WR:
-        case ETHERNET_DATA_DONE:
-        case ETHERNET_CHECK_DONE:
+        case IMG_OUTPUT_ADDRESS_LO ... (IMG_OUTPUT_ADDRESS_HI - 1):
+        case IMG_OUTPUT_SIZE_ADDRESS_LO:
+        case IMG_OUTPUT_DONE_ADDRESS_LO:
+        case IMG_OUTPUT_STATUS_ADDRESS_LO:
         {
           dbgmodprint(use_prints, "Decoded address %016llX corresponds to Ethernet module.", address);
 
           return IMG_ETHERNET_INITIATOR_ID;
         }
 
         // To/From Memory Valid addresses
-        case MEMORY_ADDRESS_LO ... MEMORY_ADDRESS_HI : {
+        case MEMORY_ADDRESS_LO ... (MEMORY_ADDRESS_HI - 1) : {
             dbgmodprint(use_prints, "Decoded address %016llX corresponds to Memory.", address);
             return IMG_MEMORY_INITIATOR_ID;
         }
         default: {
-            dbgmodprint(use_prints, "[ERROR] Decoding invalid address %016llX.", address);
+            dbgmodprint(true, "[ERROR] Decoding invalid address %016llX.", address);
             SC_REPORT_FATAL("[IMG ROUTER]", "Received address is invalid, does not match any hardware block");
             return INVALID_INITIATOR_ID;
         }   

modules/router/src/packetGenerator_tlm.cpp

@@ -19,7 +19,7 @@ using namespace std;
 void packetGenerator_tlm::do_when_read_transaction(unsigned char*& data, unsigned int data_length, sc_dt::uint64 address){
   dbgimgtarmodprint(use_prints, "Calling do_when_read_transaction");
 
-  if ((address = ETHERNET_CHECK_DONE) && (data_length == 1))
+  if ((address >= IMG_OUTPUT_STATUS_ADDRESS_LO) && (address < IMG_OUTPUT_STATUS_ADDRESS_HI))
   {
     if (packetGenerator::tmp_data_out_valid == true)
     {
@@ -36,42 +36,29 @@ void packetGenerator_tlm::do_when_write_transaction(unsigned char*& data, unsign
 {
   dbgimgtarmodprint(use_prints, "Calling do_when_write_transaction");
 
-  if ((address >= ETHERNET_DATA_WR) && (address + data_length - 1 < ETHERNET_DATA_DONE))
+  if ((address >= IMG_OUTPUT_ADDRESS_LO) && (address < IMG_OUTPUT_SIZE_ADDRESS_LO))
   {
+    memcpy(tmp_data + address - IMG_OUTPUT_ADDRESS_LO, data, data_length);
+  }
+  else if ((address >= IMG_OUTPUT_SIZE_ADDRESS_LO) && (address < IMG_OUTPUT_DONE_ADDRESS_LO))
+  {
+    unsigned char *data_length_ptr = (unsigned char *)&tmp_data_length;
+    memcpy(data_length_ptr + address - IMG_OUTPUT_SIZE_ADDRESS_LO, data, data_length);
 
-    if (tmp_data_length == 0)
-    {
-      tmp_data = new unsigned char[data_length];
-      memcpy(tmp_data, data, sizeof(char) * data_length);
-    }
-    else
-    {
-      unsigned char* tmp_data_;
-      tmp_data_ = tmp_data;
-      tmp_data = new unsigned char[tmp_data_length + data_length];
-      memcpy(tmp_data, tmp_data_, sizeof(char) * tmp_data_length);
-      memcpy(tmp_data + tmp_data_length, data, data_length);
-
-      delete[] tmp_data_;
-    }
-
-    dbgimgtarmodprint(use_prints, "Previous data_length %0d new data_length %0d", tmp_data_length, tmp_data_length + data_length);
-    tmp_data_length = tmp_data_length + data_length;
+    dbgimgtarmodprint(use_prints, "Current data_length %0d", tmp_data_length);
   }
-  else if ((address == ETHERNET_DATA_DONE) && (data_length == 1) && (*data == 1))
+  else if ((address >= IMG_OUTPUT_DONE_ADDRESS_LO) && (address < IMG_OUTPUT_STATUS_ADDRESS_LO) && (*data == 1))
   {
     if (tmp_data_length == 0)
     {
-      tmp_data = new unsigned char[1];
-      *tmp_data = 0;
+      *(tmp_data) = 0;
       tmp_data_length = 1;
     }
 
     dbgimgtarmodprint(use_prints, "Preparing to send %0d bytes", tmp_data_length);
 
     fill_data(tmp_data, (int)tmp_data_length);
 
-    delete[] tmp_data;
     tmp_data_length = 0;
   }
 }

modules/router/src/tb_edge_detector_tlm.cpp

@@ -51,7 +51,6 @@ struct Ethernet_AMS_Signals {
     sca_tdf::sca_signal<double> mlt3_out_signal;
 
     sca_tdf::sca_signal<bool> data_out_valid;
-    sca_tdf::sca_signal<sc_dt::sc_bv<4>> data_out_signal;
     sca_tdf::sca_signal<sc_dt::sc_bv<4>> data_out;
 
     sca_tdf::sca_signal<bool> tmp_data_out_valid;
@@ -254,6 +253,8 @@ SC_MODULE(Tb_top)
         memory_DUT->backdoor_write(local_results, 3 * sizeof(char), IMG_INPUT_ADDRESS_LO + ((i * IMAG_COLS * 3) + (j * 3)));
       }
     }
+
+    dbgprint("Saved image in memory");
 
     Mat grayImagePrevMem(IMAG_ROWS, IMAG_COLS, CV_8UC1);
     Mat filteredImagePrevMem(IMAG_ROWS, IMAG_COLS, CV_8UC1);
@@ -268,6 +269,8 @@ SC_MODULE(Tb_top)
     Mat detectedImageAfterMem(IMAG_ROWS, IMAG_COLS, CV_8UC1);
 
     total_number_of_pixels = IMAG_ROWS * IMAG_COLS;
+
+    dbgprint("Starting gray scale conversion");
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -331,6 +334,8 @@ SC_MODULE(Tb_top)
     local_count = 0;
     current_number_of_pixels = 0;
     next_target_of_completion = 10.0;
+
+    dbgprint("Starting filtering the image");
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -381,8 +386,8 @@ SC_MODULE(Tb_top)
         if (local_count == 8)
         {
           dbgmodprint(use_prints, "Before doing a write in TB");
-          sanity_check_address(IMG_COMPRESSED_ADDRESS_LO + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), IMG_COMPRESSED_ADDRESS_LO, IMG_COMPRESSED_ADDRESS_LO + IMG_COMPRESSED_SIZE);
-          tb_initiator->write(local_results, IMG_COMPRESSED_ADDRESS_LO + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), 8 * sizeof(char));
+          sanity_check_address(IMG_INPROCESS_D_ADDRESS_LO + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), IMG_INPROCESS_D_ADDRESS_LO, IMG_INPROCESS_D_ADDRESS_LO + IMG_INPROCESS_D_SIZE);
+          tb_initiator->write(local_results, IMG_INPROCESS_D_ADDRESS_LO + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), 8 * sizeof(char));
           dbgmodprint(use_prints, "After doing a write in TB");
           local_count = 0;
           local_group_count++;
@@ -404,14 +409,16 @@ SC_MODULE(Tb_top)
       for (int j = 0; j < IMAG_COLS; j++)
       {
         unsigned char* read_ptr;
-        memory_DUT->backdoor_read(read_ptr, 1 * sizeof(char), IMG_COMPRESSED_ADDRESS_LO + ((i * IMAG_COLS) + j));
+        memory_DUT->backdoor_read(read_ptr, 1 * sizeof(char), IMG_INPROCESS_D_ADDRESS_LO + ((i * IMAG_COLS) + j));
         filteredImageAfterMem.at<uchar>(i, j) = *read_ptr;
       }
     }
 
     local_count = 0;
     current_number_of_pixels = 0;
     next_target_of_completion = 10.0;
+
+    dbgprint("Starting calculating sobel gradients of the image");
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -423,7 +430,7 @@ SC_MODULE(Tb_top)
         unsigned char* write_ptr;
         unsigned char* read_ptr;
 
-        extract_window(i, j, IMG_COMPRESSED_ADDRESS_LO, local_window_ptr);
+        extract_window(i, j, IMG_INPROCESS_D_ADDRESS_LO, local_window_ptr);
         for (int k = 9; k < 16; k++)
         {
           *(local_window_ptr + k) = 0;
@@ -540,6 +547,8 @@ SC_MODULE(Tb_top)
     local_count = 0;
     current_number_of_pixels = 0;
     next_target_of_completion = 10.0;
+
+    dbgprint("Starting with the unification of the magnitude of the gradients of the image");
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -618,6 +627,8 @@ SC_MODULE(Tb_top)
     local_count = 0;
     current_number_of_pixels = 0;
     next_target_of_completion = 10.0;
+
+    dbgprint("Starting with the compression of the image");
 
     for (int i = 0; i < IMAG_ROWS; i++)
     {
@@ -672,8 +683,8 @@ SC_MODULE(Tb_top)
       {
         local_results = reinterpret_cast<unsigned char*>(compression_results + (local_group_count * 8 * sizeof(char)));
         dbgmodprint(use_prints, "Before doing a write in TB");
-        sanity_check_address(IMG_COMPRESSED_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), IMG_COMPRESSED_ADDRESS_LO, IMG_COMPRESSED_ADDRESS_LO + IMG_COMPRESSED_SIZE);
-        tb_initiator->write(local_results, IMG_COMPRESSED_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), 8 * sizeof(char));
+        sanity_check_address(IMG_OUTPUT_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), IMG_OUTPUT_ADDRESS_LO, IMG_OUTPUT_ADDRESS_LO + IMG_OUTPUT_SIZE);
+        tb_initiator->write(local_results, IMG_OUTPUT_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), 8 * sizeof(char));
         dbgmodprint(use_prints, "After doing a write in TB");
         local_count = 0;
         local_group_count++;
@@ -692,8 +703,8 @@ SC_MODULE(Tb_top)
     {
       local_results = reinterpret_cast<unsigned char*>(compression_results + (local_group_count * 8 * sizeof(char)));
       dbgmodprint(use_prints, "Before doing a write in TB");
-      sanity_check_address(IMG_COMPRESSED_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), IMG_COMPRESSED_ADDRESS_LO, IMG_COMPRESSED_ADDRESS_LO + IMG_COMPRESSED_SIZE);
-      tb_initiator->write(local_results, IMG_COMPRESSED_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), (compression_output_size % 8) * sizeof(char));
+      sanity_check_address(IMG_OUTPUT_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), IMG_OUTPUT_ADDRESS_LO, IMG_OUTPUT_ADDRESS_LO + IMG_OUTPUT_SIZE);
+      tb_initiator->write(local_results, IMG_OUTPUT_ADDRESS_LO + (local_group_count * 8 * sizeof(char)), (compression_output_size % 8) * sizeof(char));
       dbgmodprint(use_prints, "After doing a write in TB");
       local_count = 0;
       local_group_count++;
@@ -705,80 +716,27 @@ SC_MODULE(Tb_top)
     local_group_count = 0;
     current_number_of_pixels = 0;
     next_target_of_completion = 10.0;
-    for (int i = 0; i < compression_output_size; i++)
-    {
-      if (local_count == 0)
-      {
-        unsigned char* read_ptr;
-        local_read = new unsigned char[8];
-      
-        dbgmodprint(use_prints, "Before doing a read in TB");
-        tb_initiator->read(read_ptr, IMG_COMPRESSED + (local_group_count * 8 * sizeof(char)), 8 * sizeof(char));
-        dbgmodprint(use_prints, "After doing a read in TB");
-        memcpy(local_read, read_ptr, 8 * sizeof(char));
-        delete[] read_ptr;
-      }
-
-      local_count++;
-
-      if (local_count == 8)
-      {
-        unsigned char* write_ptr;
-        unsigned char* read_ptr;
 
-        tb_initiator->read(read_ptr, ETHERNET_CHECK_DONE, 1 * sizeof(char));
-        while (*read_ptr == 1)
-        {
-          delete[] read_ptr;
-          wait(100, SC_NS);
-          tb_initiator->read(read_ptr, ETHERNET_CHECK_DONE, 1 * sizeof(char));
-        }
-
-        write_ptr = new unsigned char[1];
-        *write_ptr = 1;
-        tb_initiator->write(local_read, ETHERNET_DATA_WR, 8 * sizeof(char));
-        tb_initiator->write(write_ptr, ETHERNET_DATA_DONE, 1 * sizeof(char));
-        delete[] write_ptr;
-        delete[] local_read;
-        local_count = 0;
-        local_group_count++;
-      }
-    }
-    
-    if (compression_output_size % 8 != 0)
-    {
-      unsigned char* write_ptr;
-      unsigned char* read_ptr;
-
-      tb_initiator->read(read_ptr, ETHERNET_CHECK_DONE, 1 * sizeof(char));
-      while (*read_ptr == 1)
-      {
-        delete[] read_ptr;
-        wait(100, SC_NS);
-        tb_initiator->read(read_ptr, ETHERNET_CHECK_DONE, 1 * sizeof(char));
-      }
-
-      dbgmodprint(use_prints, "Before doing a read in TB");
-      tb_initiator->read(read_ptr, IMG_COMPRESSED + (local_group_count * 8 * sizeof(char)), (compression_output_size % 8) * sizeof(char));
-      dbgmodprint(use_prints, "After doing a read in TB");
+    unsigned char* read_ptr;
+    unsigned char* write_ptr;
 
-      write_ptr = new unsigned char[1];
-      *write_ptr = 1;
+    dbgprint("Starting with the transmision of the image");
+    dbgprint("Preparing to transmit %0d bytes", compression_output_size);
 
-      tb_initiator->write(read_ptr, ETHERNET_DATA_WR, (compression_output_size % 8) * sizeof(char));
-      tb_initiator->write(write_ptr, ETHERNET_DATA_DONE, 1 * sizeof(char));
+    write_ptr = (unsigned char *)&compression_output_size;
+    tb_initiator->write(write_ptr, IMG_OUTPUT_SIZE_ADDRESS_LO, sizeof(int));
 
-      delete[] write_ptr;
-      delete[] read_ptr;
-    }
+    write_ptr = new unsigned char[1];
+    *write_ptr = 1;
+    tb_initiator->write(write_ptr, IMG_OUTPUT_DONE_ADDRESS_LO, sizeof(char));
+    delete[] write_ptr;
 
-    unsigned char* read_ptr;
-    tb_initiator->read(read_ptr, ETHERNET_CHECK_DONE, 1 * sizeof(char));
+    tb_initiator->read(read_ptr, IMG_OUTPUT_STATUS_ADDRESS_LO, 1 * sizeof(char));
     while (*read_ptr == 1)
     {
       delete[] read_ptr;
       wait(100, SC_NS);
-      tb_initiator->read(read_ptr, ETHERNET_CHECK_DONE, 1 * sizeof(char));
+      tb_initiator->read(read_ptr, IMG_OUTPUT_STATUS_ADDRESS_LO, 1 * sizeof(char));
     }
 
     dbgprint("Finished with the transmision of the image");
@@ -1078,7 +1036,6 @@ int sc_main(int, char*[])
   sc_trace(wf, top.memory_DUT->mem_we, "memory_we");
 
   sca_util::sca_trace(wf_ams, top.ethernetSignals.mlt3_out_signal, "mlt3_out");
-  sca_util::sca_trace(wf_ams, top.ethernetSignals.data_out_signal, "data_out_signal");
   sca_util::sca_trace(wf_ams, top.ethernetSignals.data_out_valid, "data_out_valid");
   sca_util::sca_trace(wf_ams, top.ethernetSignals.data_out, "data_out");
   sca_util::sca_trace(wf_ams, top.ethernetSignals.data_in, "pkt_gen_data_in");