Add filter testing

jgavillalobos · jgavillalobos · commit 5ae4ff06e023 · 2024-08-09T23:44:50.000-06:00
diff --git a/modules/VirtualPrototype/FreeRTOS/freertos_test.c b/modules/VirtualPrototype/FreeRTOS/freertos_test.c
@@ -313,6 +313,30 @@ static void task_test_grayscale(void *pParameter)
 	convert_to_grayscale();
 }
 
+void filter_image()
+{
+	unsigned char *filter_output_ptr = (unsigned char*) IMG_FILTER_OUTPUT_ADDRESS_LO;
+	unsigned char *output_image_ptr = (unsigned char*) IMG_COMPRESSED_ADDRESS_LO;
+
+	printf("Starting filtering of image\n");
+
+	for (int i = 0; i < IMAG_ROWS; i++)
+	{
+		for (int j = 0; j < IMAG_COLS; j++)
+		{
+			transfer_window(i, j, IMG_INPROCESS_A_ADDRESS_LO, IMG_FILTER_KERNEL_ADDRESS_LO);
+			*(output_image_ptr + ((i * IMAG_COLS) + j)) = *(filter_output_ptr);
+		}
+	}
+
+	printf("Finished filtering of image\n");
+}
+
+static void task_test_filtering(void *pParameter)
+{
+	filter_image();
+}
+
 int main( void )
 {
 
@@ -326,7 +350,8 @@ int main( void )
         xTaskCreate(task_3, "Task3", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL);
         
 	// xTaskCreate(task_test_sobel, "TaskSobel", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL);
-	xTaskCreate(task_test_grayscale, "TaskGrayscale", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL);
+	// xTaskCreate(task_test_grayscale, "TaskGrayscale", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL);
+	xTaskCreate(task_test_filtering, "TaskFiltering", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL);
 	/* Start the kernel.  From here on, only tasks and interrupts will run. */
 	vTaskStartScheduler();
 
diff --git a/modules/VirtualPrototype/include/ips_filter_tlm.hpp b/modules/VirtualPrototype/include/ips_filter_tlm.hpp
@@ -5,10 +5,6 @@ using namespace sc_core;
 using namespace sc_dt;
 using namespace std;
 
-#include <tlm.h>
-#include <tlm_utils/simple_initiator_socket.h>
-#include <tlm_utils/simple_target_socket.h>
-#include <tlm_utils/peq_with_cb_and_phase.h>
 
 #include "ips_filter_lt_model.hpp"
 #include "../src/img_target.cpp"
@@ -20,6 +16,7 @@ struct ips_filter_tlm : public Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTE
 {
     
     ips_filter_tlm(sc_module_name name) : Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE>((std::string(name) + "_HW_block").c_str()), img_target((std::string(name) + "_target").c_str()) {
+        set_mem_attributes(IMG_FILTER_KERNEL_ADDRESS_LO, IMG_FILTER_KERNEL_SIZE+IMG_FILTER_OUTPUT_SIZE);
     }
     
     //Override do_when_transaction functions
diff --git a/modules/VirtualPrototype/src/img_target.cpp b/modules/VirtualPrototype/src/img_target.cpp
@@ -64,25 +64,28 @@ struct img_target: sc_module
         // Generate the appropriate error response
         // *********************************************
         if (adr >= sc_dt::uint64(mem_size)) {
+            dbgmodprint("[DEBUG ERROR] TLM transaction is returned with response status TLM_ADDRESS_ERROR_RESPONSE");
             trans.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);
             return;
         }
         if (byt != nullptr) {
+            dbgmodprint("[DEBUG ERROR] TLM transaction is returned with response status TLM_BYTE_ERROR_RESPONSE");
             trans.set_response_status(tlm::TLM_BYTE_ENABLE_ERROR_RESPONSE);
             return;
         }
         if (len > 4 || wid < len) {
+            dbgmodprint("[DEBUG ERROR] TLM transaction is returned with response status TLM_BURST_ERROR_RESPONSE");
             trans.set_response_status(tlm::TLM_BURST_ERROR_RESPONSE);
             return;
         }
 
         // Obliged to implement read and write commands
         if (cmd == tlm::TLM_READ_COMMAND) {
             this->do_when_read_transaction(ptr, len, adr);
-            //dbgmodprint("Read at address %0x, data: %0x", address_offset, *ptr);
+            // dbgmodprint("Read at address %0x, data: %0x", address_offset, *ptr);
         }
         else if (cmd == tlm::TLM_WRITE_COMMAND) {
-            //dbgmodprint("Write at address %0x, data: %0x", address_offset, *ptr);
+            // dbgmodprint("Write at address %0x, data: %0x", address_offset, *ptr);
             this->do_when_write_transaction(ptr, len, adr);
         }
 
diff --git a/modules/VirtualPrototype/src/ips_filter_tlm.cpp b/modules/VirtualPrototype/src/ips_filter_tlm.cpp
@@ -17,6 +17,8 @@ using namespace std;
 
 void ips_filter_tlm::do_when_read_transaction(unsigned char*& data, unsigned int data_length, sc_dt::uint64 address)
 {
+  dbgimgtarmodprint("Called do_when_read_transaction with an address %016llX and length %d", address, data_length);
+
   this->img_result = *(Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE>::result_ptr);
   *data = (unsigned char) this->img_result;
   //memcpy(data, Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE>::result_ptr, sizeof(IPS_OUT_TYPE_TB));
@@ -25,25 +27,15 @@ void ips_filter_tlm::do_when_read_transaction(unsigned char*& data, unsigned int
 void ips_filter_tlm::do_when_write_transaction(unsigned char*& data, unsigned int data_length, sc_dt::uint64 address)
 {
   IPS_OUT_TYPE_TB* result = new IPS_OUT_TYPE_TB;
-  IPS_IN_TYPE_TB* img_window = new IPS_IN_TYPE_TB[3 * 3];
-
-  dbgprint("[DEBUG]: data: %0d, address %0d, data_length %0d, size of char %0d", *data, address, data_length, sizeof(char));
-  this->img_window[address] = (IPS_IN_TYPE_TB) *data;
-  dbgprint("[DEBUG]: img_window data: %0f", this->img_window[address]);
-  
-  // if ((IPS_FILTER_KERNEL_SIZE * IPS_FILTER_KERNEL_SIZE * sizeof(char)) != data_length)
-  // {
-  //   SC_REPORT_FATAL("IPS_FILTER", "Illegal transaction size");
-  // }
-  
-  // for (int i = 0; i < IPS_FILTER_KERNEL_SIZE; i++)
-  // {
-  //   for (int j = 0; j < IPS_FILTER_KERNEL_SIZE; j++)
-  //   {
-  //     *(img_window + ((i * IPS_FILTER_KERNEL_SIZE) + j)) = (IPS_IN_TYPE_TB)*(data + ((i * IPS_FILTER_KERNEL_SIZE) + j));
-  //     this->img_window[(i * IPS_FILTER_KERNEL_SIZE) + j] = (IPS_IN_TYPE_TB)*(data + ((i * IPS_FILTER_KERNEL_SIZE) + j));
-  //   }
-  // }
+
+  dbgimgtarmodprint("Called do_when_write_transaction with an address %016llX and length %d", address, data_length);
+
+  //dbgprint("[DEBUG]: data: %0d, address %0d, data_length %0d, size of char %0d", *data, address, data_length, sizeof(char));
+  for (int i = 0; i < data_length; i++) {
+    this->img_window[address + i] = (IPS_IN_TYPE_TB) *(data + i);
+  }
+  //dbgprint("[DEBUG]: img_window data: %0f", this->img_window[address]);
+
   if (address == 8) {
     filter(this->img_window, result);
   }
diff --git a/modules/VirtualPrototype/src/sobel_edge_detector_tlm.cpp b/modules/VirtualPrototype/src/sobel_edge_detector_tlm.cpp
@@ -16,7 +16,7 @@ void sobel_edge_detector_tlm::do_when_read_transaction(unsigned char*& data, uns
   unsigned char* sobel_results_ptr;
   sc_uint<8> local_result;
 
-  dbgimgtarmodprint("Called do_when_read_transaction witha address %016llX and length %d", address, data_length);
+  dbgimgtarmodprint("Called do_when_read_transaction with an address %016llX and length %d", address, data_length);
 
   if ((address >= (SOBEL_INPUT_0_SIZE + SOBEL_INPUT_1_SIZE)) && (address < (SOBEL_INPUT_0_SIZE + SOBEL_INPUT_1_SIZE + SOBEL_OUTPUT_SIZE)))
   {
@@ -48,7 +48,7 @@ void sobel_edge_detector_tlm::do_when_read_transaction(unsigned char*& data, uns
 
 void sobel_edge_detector_tlm::do_when_write_transaction(unsigned char*&data, unsigned int data_length, sc_dt::uint64 address)
 {
-  dbgimgtarmodprint("Called do_when_write_transaction witha address %016llX and length %d", address, data_length);
+  dbgimgtarmodprint("Called do_when_write_transaction with an address %016llX and length %d", address, data_length);
 
   if (address < (SOBEL_INPUT_0_SIZE + SOBEL_INPUT_1_SIZE))
   {

Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,6 @@ using namespace sc_core;`
`5`	`5`	`using namespace sc_dt;`
`6`	`6`	`using namespace std;`
`7`	`7`
`8`		`-#include <tlm.h>`
`9`		`-#include <tlm_utils/simple_initiator_socket.h>`
`10`		`-#include <tlm_utils/simple_target_socket.h>`
`11`		`-#include <tlm_utils/peq_with_cb_and_phase.h>`
`12`	`8`
`13`	`9`	`#include "ips_filter_lt_model.hpp"`
`14`	`10`	`#include "../src/img_target.cpp"`
`@@ -20,6 +16,7 @@ struct ips_filter_tlm : public Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTE`
`20`	`16`	`{`
`21`	`17`
`22`	`18`	`ips_filter_tlm(sc_module_name name) : Filter<IPS_IN_TYPE_TB, IPS_OUT_TYPE_TB, IPS_FILTER_KERNEL_SIZE>((std::string(name) + "_HW_block").c_str()), img_target((std::string(name) + "_target").c_str()) {`
	`19`	`+ set_mem_attributes(IMG_FILTER_KERNEL_ADDRESS_LO, IMG_FILTER_KERNEL_SIZE+IMG_FILTER_OUTPUT_SIZE);`
`23`	`20`	`}`
`24`	`21`
`25`	`22`	`//Override do_when_transaction functions`
Original file line number	Diff line number	Diff line change
`@@ -64,25 +64,28 @@ struct img_target: sc_module`
`64`	`64`	`// Generate the appropriate error response`
`65`	`65`	`// *********************************************`
`66`	`66`	`if (adr >= sc_dt::uint64(mem_size)) {`
	`67`	`+ dbgmodprint("[DEBUG ERROR] TLM transaction is returned with response status TLM_ADDRESS_ERROR_RESPONSE");`
`67`	`68`	`trans.set_response_status(tlm::TLM_ADDRESS_ERROR_RESPONSE);`
`68`	`69`	`return;`
`69`	`70`	`}`
`70`	`71`	`if (byt != nullptr) {`
	`72`	`+ dbgmodprint("[DEBUG ERROR] TLM transaction is returned with response status TLM_BYTE_ERROR_RESPONSE");`
`71`	`73`	`trans.set_response_status(tlm::TLM_BYTE_ENABLE_ERROR_RESPONSE);`
`72`	`74`	`return;`
`73`	`75`	`}`
`74`	`76`	`if (len > 4 \|\| wid < len) {`
	`77`	`+ dbgmodprint("[DEBUG ERROR] TLM transaction is returned with response status TLM_BURST_ERROR_RESPONSE");`
`75`	`78`	`trans.set_response_status(tlm::TLM_BURST_ERROR_RESPONSE);`
`76`	`79`	`return;`
`77`	`80`	`}`
`78`	`81`
`79`	`82`	`// Obliged to implement read and write commands`
`80`	`83`	`if (cmd == tlm::TLM_READ_COMMAND) {`
`81`	`84`	`this->do_when_read_transaction(ptr, len, adr);`
`82`		`- //dbgmodprint("Read at address %0x, data: %0x", address_offset, *ptr);`
	`85`	`+ // dbgmodprint("Read at address %0x, data: %0x", address_offset, *ptr);`
`83`	`86`	`}`
`84`	`87`	`else if (cmd == tlm::TLM_WRITE_COMMAND) {`
`85`		`- //dbgmodprint("Write at address %0x, data: %0x", address_offset, *ptr);`
	`88`	`+ // dbgmodprint("Write at address %0x, data: %0x", address_offset, *ptr);`
`86`	`89`	`this->do_when_write_transaction(ptr, len, adr);`
`87`	`90`	`}`
`88`	`91`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ void sobel_edge_detector_tlm::do_when_read_transaction(unsigned char*& data, uns`
`16`	`16`	`unsigned char* sobel_results_ptr;`
`17`	`17`	`sc_uint<8> local_result;`
`18`	`18`
`19`		`- dbgimgtarmodprint("Called do_when_read_transaction witha address %016llX and length %d", address, data_length);`
	`19`	`+ dbgimgtarmodprint("Called do_when_read_transaction with an address %016llX and length %d", address, data_length);`
`20`	`20`
`21`	`21`	`if ((address >= (SOBEL_INPUT_0_SIZE + SOBEL_INPUT_1_SIZE)) && (address < (SOBEL_INPUT_0_SIZE + SOBEL_INPUT_1_SIZE + SOBEL_OUTPUT_SIZE)))`
`22`	`22`	`{`
`@@ -48,7 +48,7 @@ void sobel_edge_detector_tlm::do_when_read_transaction(unsigned char*& data, uns`
`48`	`48`
`49`	`49`	`void sobel_edge_detector_tlm::do_when_write_transaction(unsigned char*&data, unsigned int data_length, sc_dt::uint64 address)`
`50`	`50`	`{`
`51`		`- dbgimgtarmodprint("Called do_when_write_transaction witha address %016llX and length %d", address, data_length);`
	`51`	`+ dbgimgtarmodprint("Called do_when_write_transaction with an address %016llX and length %d", address, data_length);`
`52`	`52`
`53`	`53`	`if (address < (SOBEL_INPUT_0_SIZE + SOBEL_INPUT_1_SIZE))`
`54`	`54`	`{`