Add unification module to the chain of transactions

Author: jgavillalobos

modules/Makefile

@@ -25,9 +25,10 @@ ifdef USING_TLM_TB_EN
 EDGE_DIR=../edge-detector
 GRAY_DIR=../rgb2gray
 FILTER_DIR=../filter
+UNIFICATION_DIR=../unification
 
-SRCDIRS=$(SRCDIR) $(EDGE_DIR)/src $(GRAY_DIR)/src $(FILTER_DIR)/src
-INCDIR+=-I$(EDGE_DIR)/include -I$(GRAY_DIR)/include -I$(FILTER_DIR)/include
+SRCDIRS=$(SRCDIR) $(EDGE_DIR)/src $(GRAY_DIR)/src $(FILTER_DIR)/src $(UNIFICATION_DIR)/src
+INCDIR+=-I$(EDGE_DIR)/include -I$(GRAY_DIR)/include -I$(FILTER_DIR)/include -I$(UNIFICATION_DIR)/include
 endif # USING_TLM_TB_EN
 
 ifdef INCLUDE_OPENCV

modules/edge-detector/include/AddressMap.h

@@ -1,15 +1,23 @@
 #ifndef ADDRESSMAP_H
 #define ADDRESSMAP_H
 
-#define IMG_FILTER_KERNEL 0x00000003u
-#define SOBEL_INPUT_0     0x00000027u
-#define SOBEL_INPUT_1     0x0000002Fu
-#define SOBEL_OUTPUT      0x00000030u
-#define MEM_START         0x00000034u
-#define IMG_INPUT         0x00000034u
-#define IMG_INPROCESS_A   0x000E1034u
-#define IMG_INPROCESS_B   0x0012C034u
-#define IMG_INPROCESS_C   0x001C2034u
-#define IMG_COMPRESSED    0x00258034u
+#define IMG_FILTER_KERNEL  0x00000003u
+#define SOBEL_INPUT_0      0x00000027u
+#define SOBEL_INPUT_1      0x0000002Fu
+#define SOBEL_OUTPUT       0x00000030u
+#define IMG_INPUT          0x00000034u
+#define IMG_INPROCESS_A    0x000E1034u
+#define IMG_INPROCESS_B    0x0012C034u
+#define IMG_INPROCESS_C    0x001C2034u
+#define IMG_COMPRESSED     0x00258034u
+
+#define IMG_INPUT_SZ       0x000E1000u
+#define IMG_INPROCESS_A_SZ 0x0004B000u
+#define IMG_INPROCESS_B_SZ 0x00096000u
+#define IMG_INPROCESS_C_SZ 0x00096000u
+#define IMG_COMPRESSED_SZ  0x0004B000u
+
+#define MEM_START          IMG_INPUT
+#define MEM_FINISH         IMG_COMPRESSED + IMG_COMPRESSED_SZ
 
 #endif // ADDRESSMAP_H

modules/router/Makefile

@@ -52,6 +52,11 @@ ifdef IPS_FILTER_LT_EN
 	LFLAGS += -DIPS_FILTER_LT_EN
 endif # IPS_FILTER_LT_EN
 
+ifdef IMG_UNIFICATE_PV_EN
+	CFLAGS += -DIMG_UNIFICATE_PV_EN
+	LFLAGS += -DIMG_UNIFICATE_PV_EN
+endif # UNIFICATE_PV_EN
+
 .PHONY: print-all
 print-all:
 		@echo "Incdir is $(INCDIR)"

modules/router/run_all.sh

@@ -2,15 +2,15 @@
 
 case $1 in
   "save_log")
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 USING_TLM_TB_EN=1 all > output.log
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 all > output.log
     ;;
   "print_all")
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 USING_TLM_TB_EN=1 print-all
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 print-all
     ;;
   "compile")
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 USING_TLM_TB_EN=1 compile
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 compile
     ;;
   *)
-    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 USING_TLM_TB_EN=1 all
+    make RGB2GRAY_PV_EN=1 IPS_FILTER_LT_EN=1 EDGE_DETECTOR_AT_EN=1 IMG_UNIFICATE_PV_EN=1 USING_TLM_TB_EN=1 all
     ;;
 esac

modules/router/src/memory_tlm.cpp

@@ -23,7 +23,7 @@ void memory_tlm::do_when_read_transaction(unsigned char*& data, unsigned int dat
 
   for (int i = 0; i < max_data_length; i++)
   {
-    local_data[i] = *(mem_array + address + i);
+    local_data[i] = *(mem_array + address - MEM_START + i);
   }
   for (int i = max_data_length; i < 8; i++)
   {

modules/router/src/tb_edge_detector_tlm.cpp

@@ -29,9 +29,10 @@ using namespace std;
 #include "ImportantDefines.h"
 
 #include "memory_tlm.hpp"
-#include "rgb2gray_tlm.hpp"
+#include "rgb2gray_pv_model.hpp"
 #include "ips_filter_tlm.hpp"
 #include "sobel_edge_detector_tlm.hpp"
+#include "unification_pv_model.hpp"
 #include "img_initiator.cpp"
 
 #if !defined(RGB2GRAY_PV_EN) || !defined(EDGE_DETECTOR_AT_EN)
@@ -47,6 +48,7 @@ SC_MODULE(Tb_top)
   memory_tlm *memory_DUT;
   img_initiator *filter_initiator;
   ips_filter_tlm *filter_DUT;
+  img_unification_module* unification_DUT;
 
   SC_CTOR(Tb_top)
   {
@@ -57,6 +59,7 @@ SC_MODULE(Tb_top)
     memory_DUT = new memory_tlm("memory_DUT");
     filter_initiator = new img_initiator("filter_initiator");
     filter_DUT = new ips_filter_tlm("filter_DUT");
+    unification_DUT = new img_unification_module("unification_DUT");
 
     sobel_initiator->start_img_initiators();
     sobel_initiator->set_delays(sc_time(10, SC_NS), sc_time(10, SC_NS));
@@ -83,6 +86,7 @@ SC_MODULE(Tb_top)
     unsigned char localR, localG, localB;
     unsigned short int localResult;
     unsigned char* local_results;
+    unsigned char* local_read;
     int local_count = 0;
 
     short int localGradientX, localGradientY;
@@ -178,7 +182,7 @@ SC_MODULE(Tb_top)
         rgb2gray_DUT->set_rgb_pixel(localR, localG, localB);
         localResult = (unsigned short int)rgb2gray_DUT->obtain_gray_value();
 
-        dbgprint("Data_returned: %0d", localResult);
+        dbgprint("Data_returned gray_result: %0d", localResult);
 
         grayImagePrevMem.at<uchar>(i, j) = (unsigned char)localResult;
 
@@ -194,6 +198,7 @@ SC_MODULE(Tb_top)
         if (local_count == 8)
         {
           dbgprint("Before doing a write in TB");
+          sanity_check_address(IMG_INPROCESS_A + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), IMG_INPROCESS_A, IMG_INPROCESS_A + IMG_INPROCESS_A_SZ);
           memory_initiator->write(local_results, IMG_INPROCESS_A + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), 8 * sizeof(char));
           dbgprint("After doing a write in TB");
           local_count = 0;
@@ -246,7 +251,7 @@ SC_MODULE(Tb_top)
         filter_initiator->read(read_ptr, IMG_FILTER_KERNEL, sizeof(IPS_OUT_TYPE_TB));
         dbgprint("After doing a read in TB");
         data_returned_ptr = reinterpret_cast<IPS_OUT_TYPE_TB*>(read_ptr);
-        dbgprint("Data_returned: %f\n", *data_returned_ptr);
+        dbgprint("Data_returned filtered_result: %f", *data_returned_ptr);
 
         data_returned = *data_returned_ptr;
 
@@ -274,6 +279,7 @@ SC_MODULE(Tb_top)
         if (local_count == 8)
         {
           dbgprint("Before doing a write in TB");
+          sanity_check_address(IMG_COMPRESSED + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), IMG_COMPRESSED, IMG_COMPRESSED + IMG_COMPRESSED_SZ);
           memory_initiator->write(local_results, IMG_COMPRESSED + ((i * IMAG_COLS) + (local_group_count * 8 * sizeof(char))), 8 * sizeof(char));
           dbgprint("After doing a write in TB");
           local_count = 0;
@@ -333,8 +339,8 @@ SC_MODULE(Tb_top)
         sobel_initiator->read(read_ptr, SOBEL_OUTPUT, 8 * sizeof(char));
         dbgprint("After doing a read in TB");
         data_returned_ptr = reinterpret_cast<short int*>(read_ptr);
-        dbgprint("Data_returned: %0d\n", *data_returned_ptr);
-        dbgprint("Data_returned: %0d\n", *(data_returned_ptr+1));
+        dbgprint("Data_returned localGradientX: %0d", *data_returned_ptr);
+        dbgprint("Data_returned localGradientY: %0d", *(data_returned_ptr+1));
 
         localGradientX = *data_returned_ptr;
         localGradientY = *(data_returned_ptr+1);
@@ -357,16 +363,6 @@ SC_MODULE(Tb_top)
         else {
           detectedImagePrevMemY.at<uchar>(i, j) = (unsigned char)localGradientY;
         }
-      
-        localResult = (unsigned short int)sqrt((float)(pow(localGradientX, 2)) + (float)(pow(localGradientY, 2)));
-        if (localResult > 255)
-        {
-          detectedImagePrevMem.at<uchar>(i, j) = 255;
-        }
-        else
-        {
-          detectedImagePrevMem.at<uchar>(i, j) = (unsigned char)localResult;
-        }
 
         if (local_count == 0)
         {
@@ -381,10 +377,12 @@ SC_MODULE(Tb_top)
         {
           write_ptr = local_results;
           dbgprint("Before doing a write in TB");
+          sanity_check_address(IMG_INPROCESS_B + ((i * IMAG_COLS * sizeof(short int)) + (local_group_count * 4 * sizeof(short int))), IMG_INPROCESS_B, IMG_INPROCESS_B + IMG_INPROCESS_B_SZ);
           memory_initiator->write(write_ptr, IMG_INPROCESS_B + ((i * IMAG_COLS * sizeof(short int)) + (local_group_count * 4 * sizeof(short int))), 4 * sizeof(short int));
           dbgprint("After doing a write in TB");
           write_ptr = (local_results + 8);
           dbgprint("Before doing a write in TB");
+          sanity_check_address(IMG_INPROCESS_C + ((i * IMAG_COLS * sizeof(short int)) + (local_group_count * 4 * sizeof(short int))), IMG_INPROCESS_C, IMG_INPROCESS_C + IMG_INPROCESS_C_SZ);
           memory_initiator->write(write_ptr, IMG_INPROCESS_C + ((i * IMAG_COLS * sizeof(short int)) + (local_group_count * 4 * sizeof(short int))), 4 * sizeof(short int));
           dbgprint("After doing a write in TB");
           local_count = 0;
@@ -435,6 +433,78 @@ SC_MODULE(Tb_top)
       }
     }
 
+    for (int i = 0; i < IMAG_ROWS; i++)
+    {
+      int local_group_count = 0;
+      for (int j = 0; j < IMAG_COLS; j++)
+      {
+        unsigned char* read_ptr;
+        short int* gradients_ptr;
+        unsigned char unification_result;
+        
+        if (local_count == 0)
+        {
+          local_read = new unsigned char[16];
+        
+          dbgprint("Before doing a read in TB");
+          memory_initiator->read(read_ptr, IMG_INPROCESS_B + ((i * IMAG_COLS * sizeof(short int)) + (local_group_count * 4 * sizeof(short int))), 4 * sizeof(short int));
+          dbgprint("After doing a read in TB");
+          memcpy((local_read                          ), read_ptr, 4 * sizeof(short int));
+          dbgprint("Before doing a read in TB");
+          memory_initiator->read(read_ptr, IMG_INPROCESS_C + ((i * IMAG_COLS * sizeof(short int)) + (local_group_count * 4 * sizeof(short int))), 4 * sizeof(short int));
+          dbgprint("After doing a read in TB");
+          memcpy((local_read + (4 * sizeof(short int))), read_ptr, 4 * sizeof(short int));
+        }
+        
+        gradients_ptr = reinterpret_cast<short int*>(local_read);
+        localGradientX = *(gradients_ptr + local_count);
+        gradients_ptr = reinterpret_cast<short int*>(local_read + (4 * sizeof(short int)));
+        localGradientY = *(gradients_ptr + local_count);
+        
+        unification_DUT->unificate_pixel((int)localGradientX, (int)localGradientY, &unification_result);
+        
+        dbgprint("Data_returned unification_result: %0d", unification_result);
+        
+        detectedImagePrevMem.at<uchar>(i, j) = unification_result;
+        
+        if (local_count == 0)
+        {
+          local_results = new unsigned char[4];
+        }
+        
+        *(local_results + local_count) = unification_result;
+        
+        local_count++;
+        
+        if (local_count == 4)
+        {
+          dbgprint("Before doing a write in TB");
+          sanity_check_address(IMG_INPROCESS_A + ((i * IMAG_COLS) + j), IMG_INPROCESS_A, IMG_INPROCESS_A + IMG_INPROCESS_A_SZ);
+          memory_initiator->write(local_results, IMG_INPROCESS_A + ((i * IMAG_COLS) + (local_group_count * 4 * sizeof(char))), 4 * sizeof(char));
+          dbgprint("After doing a write in TB");
+          local_count = 0;
+          local_group_count++;
+        }
+        
+        current_number_of_pixels++;
+        if (((((float)(current_number_of_pixels)) / ((float)(total_number_of_pixels))) * 100.0) >= next_target_of_completion) {
+          dbgprint("Image processing completed at %f", next_target_of_completion);
+          next_target_of_completion += 10.0;
+        }
+      }
+    }
+    
+    // Sanity check that the image was written in memory as expected
+    for (int i = 0; i < IMAG_ROWS; i++)
+    {
+      for (int j = 0; j < IMAG_COLS; j++)
+      {
+        unsigned char* read_ptr;
+        memory_DUT->backdoor_read(read_ptr, 1 * sizeof(char), IMG_INPROCESS_A + ((i * IMAG_COLS) + j));
+        detectedImageAfterMem.at<uchar>(i, j) = *read_ptr;
+      }
+    }
+    
     imwrite("grayImagePrevMem.jpg", grayImagePrevMem);
     imwrite("grayImageAfterMem.jpg", grayImageAfterMem);
     imwrite("filteredImagePrevMem.jpg", filteredImagePrevMem);
@@ -649,6 +719,14 @@ SC_MODULE(Tb_top)
       *(local_window_ptr + 8) = *(read_ptr + 2);
     }
   }
+  
+  void sanity_check_address(unsigned int address, unsigned int lower_address_limit, unsigned int upper_address_limit)
+  {
+    if (((lower_address_limit != 0) && (address < lower_address_limit)) || (address > upper_address_limit))
+    {
+      SC_REPORT_FATAL("TB MEM", "Access to memory crossing boundary");
+    }
+  }
 };
 
 int sc_main(int, char*[])

modules/unification/include/unification_pv_model.hpp

@@ -23,7 +23,7 @@ SC_MODULE (img_unification_module) {
   } // End of Constructor
 
   //------------Methods------------
-  void unificate_pixel(unsigned char x_pixel, unsigned char y_pixel, unsigned char * unificated_pixel);
+  void unificate_pixel(int x_pixel, int y_pixel, unsigned char * unificated_pixel);
   void unificate_img(unsigned char *x_img, unsigned char *y_img, unsigned char *unificated_img, int img_size, int channels);
   int norm(int a, int b);
 };

modules/unification/src/unification_pv_model.cpp

@@ -16,7 +16,7 @@
 //#define USE_INF_NORM
 //-------------------------------------------
 
-void img_unification_module::unificate_pixel(unsigned char x_pixel, unsigned char y_pixel, unsigned char * unificated_pixel) {
+void img_unification_module::unificate_pixel(int x_pixel, int y_pixel, unsigned char * unificated_pixel) {
   //Get the Norm
   *unificated_pixel = (unsigned char) this->norm(x_pixel, y_pixel);
 }
@@ -25,8 +25,8 @@ void img_unification_module::unificate_img(unsigned char *x_img, unsigned char *
   //Iterate over image
   for(unsigned char *x = x_img, *y = y_img, *u = unificated_img; x < x_img + img_size && y < y_img + img_size && u < unificated_img + img_size; x+=channels, y+=channels, u+=channels){
     unsigned char pixel_magnitude;
-    unsigned char pixel_x = int(*x);
-    unsigned char pixel_y = int(*y);
+    int pixel_x = int(*x);
+    int pixel_y = int(*y);
 
     this->unificate_pixel(pixel_x, pixel_y, &pixel_magnitude);
     *u = pixel_magnitude;

modules/unification/src/unification_tb.cpp

@@ -4,6 +4,7 @@
 //Description: Simple TB for pixel unification modules
 //--------------------------------------------------------
 
+#ifndef USING_TLM_TB_EN
 #define STB_IMAGE_IMPLEMENTATION
 #include "include/stb_image.h"
 #define STB_IMAGE_WRITE_IMPLEMENTATION
@@ -87,3 +88,5 @@ int sc_main(int, char*[]) {
   return 0;// Terminate simulation
 
  }
+ 
+#endif // #ifdef USING_TLM_TB_EN