mem_write and mem_read in test_coram_axi/avalon are useful to abstract away the dram_stub.

Author: shtaxxx

pycoram/template/test_coram_avalon.txt

@@ -722,6 +722,37 @@ module test;
     $finish;
   end
 
+  //----------------------------------------------------------------------------
+  // DRAM read/write task
+  //----------------------------------------------------------------------------
+  task mem_write;
+    input [SIM_ADDR_WIDTH-1:0] addr;
+    input [7:0] size;
+    input [255:0] data;
+    integer i;
+    begin
+      for(i=0; i<size; i=i+1) begin
+        inst_dram_stub.memory[addr + i] = (data >> (8 * i)) & 8'hFF;
+      end
+    end
+  endtask
+
+  task mem_read;
+    input [SIM_ADDR_WIDTH-1:0] addr;
+    input [7:0] size;
+    output [255:0] data;
+    integer i;
+    begin
+      data = 256'h0;
+      for(i=0; i<size; i=i+1) begin
+        data = data | ((inst_dram_stub.memory[addr + i] & 8'hFF) << (i * 8));
+      end
+    end
+  endtask
+
+  //----------------------------------------------------------------------------
+  // iochannel/ioregister read/write task
+  //----------------------------------------------------------------------------
 {%- for thread in threads | sort(attribute='name') %}
 {% for iochannel in thread.iochannels | sort(attribute='name') %}
   task iochannel_write_{{ thread.name }}_{{ iochannel.name }};

pycoram/template/test_coram_axi.txt

@@ -1389,6 +1389,37 @@ module test;
     $finish;
   end
 
+  //----------------------------------------------------------------------------
+  // DRAM read/write task
+  //----------------------------------------------------------------------------
+  task mem_write;
+    input [SIM_ADDR_WIDTH-1:0] addr;
+    input [7:0] size;
+    input [255:0] data;
+    integer i;
+    begin
+      for(i=0; i<size; i=i+1) begin
+        inst_dram_stub.memory[addr + i] = (data >> (8 * i)) & 8'hFF;
+      end
+    end
+  endtask
+
+  task mem_read;
+    input [SIM_ADDR_WIDTH-1:0] addr;
+    input [7:0] size;
+    output [255:0] data;
+    integer i;
+    begin
+      data = 256'h0;
+      for(i=0; i<size; i=i+1) begin
+        data = data | ((inst_dram_stub.memory[addr + i] & 8'hFF) << (i * 8));
+      end
+    end
+  endtask
+
+  //----------------------------------------------------------------------------
+  // iochannel/ioregister read/write task
+  //----------------------------------------------------------------------------
 {%- for thread in threads | sort(attribute='name') %}
 {% for iochannel in thread.iochannels | sort(attribute='name') %}
   task iochannel_write_{{ thread.name }}_{{ iochannel.name }};

sample/app/matrix-mult/matrix-mult-memory/testbench.v

@@ -8,30 +8,18 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<matrix_size; y=y+1) begin
     for(x=0; x<matrix_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (matrix_size * y + x) * 4, 4, tmp_data);
+      mem_read(data_offset + ((d + 1) % loader_size) * 4, 4, tmp_data);
+      mem_write(b_offset + (matrix_size * x + y) * 4, 4, tmp_data);
+      mem_write(c_offset + (matrix_size * x + y) * 4, 4, 0);
       d = d + 2;
     end
   end

sample/app/matrix-mult/matrix-mult-separate/testbench.v

@@ -1,4 +1,5 @@
-parameter matrix_size = 208;
+//parameter matrix_size = 208;
+parameter matrix_size = 16 * 4;
 parameter a_offset = 1 * 1024 * 1024;
 parameter b_offset = 2 * 1024 * 1024;
 parameter c_offset = 3 * 1024 * 1024;
@@ -7,30 +8,18 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<matrix_size; y=y+1) begin
     for(x=0; x<matrix_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (matrix_size * y + x) * 4, 4, tmp_data);
+      mem_read(data_offset + ((d + 1) % loader_size) * 4, 4, tmp_data);
+      mem_write(b_offset + (matrix_size * x + y) * 4, 4, tmp_data);
+      mem_write(c_offset + (matrix_size * x + y) * 4, 4, 0);
       d = d + 2;
     end
   end

sample/app/matrix-mult/matrix-mult-stream-light/testbench.v

@@ -8,30 +8,18 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<matrix_size; y=y+1) begin
     for(x=0; x<matrix_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (matrix_size * y + x) * 4, 4, tmp_data);
+      mem_read(data_offset + ((d + 1) % loader_size) * 4, 4, tmp_data);
+      mem_write(b_offset + (matrix_size * x + y) * 4, 4, tmp_data);
+      mem_write(c_offset + (matrix_size * x + y) * 4, 4, 0);
       d = d + 2;
     end
   end

sample/app/matrix-mult/matrix-mult-stream/testbench.v

@@ -8,30 +8,18 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<matrix_size; y=y+1) begin
     for(x=0; x<matrix_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (matrix_size * y + x) * 4, 4, tmp_data);
+      mem_read(data_offset + ((d + 1) % loader_size) * 4, 4, tmp_data);
+      mem_write(b_offset + (matrix_size * x + y) * 4, 4, tmp_data);
+      mem_write(c_offset + (matrix_size * x + y) * 4, 4, 0);
       d = d + 2;
     end
   end

sample/app/matrix-mult/matrix-mult/testbench.v

@@ -8,30 +8,18 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<matrix_size; y=y+1) begin
     for(x=0; x<matrix_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (matrix_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (matrix_size * x + y) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + ((d + 1) % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[c_offset + (matrix_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (matrix_size * y + x) * 4, 4, tmp_data);
+      mem_read(data_offset + ((d + 1) % loader_size) * 4, 4, tmp_data);
+      mem_write(b_offset + (matrix_size * x + y) * 4, 4, tmp_data);
+      mem_write(c_offset + (matrix_size * x + y) * 4, 4, 0);
       d = d + 2;
     end
   end

sample/app/stencil-9p/stencil-9p-memory-base/testbench.v

@@ -9,22 +9,16 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<mesh_size; y=y+1) begin
     for(x=0; x<mesh_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (mesh_size * y + x) * 4, 4, tmp_data);
+      mem_write(b_offset + (mesh_size * y + x) * 4, 4, 0);
       d = d + 1;
     end
   end

sample/app/stencil-9p/stencil-9p-memory/testbench.v

@@ -9,22 +9,16 @@ parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<mesh_size; y=y+1) begin
     for(x=0; x<mesh_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (mesh_size * y + x) * 4, 4, tmp_data);
+      mem_write(b_offset + (mesh_size * y + x) * 4, 4, 0);
       d = d + 1;
     end
   end

sample/app/stencil-9p/stencil-9p-separate/testbench.v

@@ -1,28 +1,24 @@
-parameter mesh_size = 96;
-parameter iter_num = 200;
+//parameter mesh_size = 96;
+//parameter iter_num = 200;
+parameter mesh_size = 32 * 2;
+parameter iter_num = 2 * 2;
 parameter a_offset = 1 * 1024 * 1024;
 parameter b_offset = 2 * 1024 * 1024;
 
 parameter data_offset = 256 * 1024;
 parameter loader_size = 64 * 1024;
 
 integer x, y, d;
+
+reg [31:0] tmp_data;
+
 initial begin
   d = 0;
   for(y=0; y<mesh_size; y=y+1) begin
     for(x=0; x<mesh_size; x=x+1) begin
-      {inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[a_offset + (mesh_size * y + x) * 4 + 0]} =
-          {inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 3],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 2],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 1],
-           inst_dram_stub.memory[data_offset + (d % loader_size) * 4 + 0]};
-      {inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 3],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 2],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 1],
-       inst_dram_stub.memory[b_offset + (mesh_size * y + x) * 4 + 0]} = 0;
+      mem_read(data_offset + (d % loader_size) * 4, 4, tmp_data);
+      mem_write(a_offset + (mesh_size * y + x) * 4, 4, tmp_data);
+      mem_write(b_offset + (mesh_size * y + x) * 4, 4, 0);
       d = d + 1;
     end
   end