6 add binary reader for cycle accurate simulator (#10)

* Add specifications for the binary reader

* Implementing the Map associating logical addresses and values (for Instructions)

* edits

* added back build_scratchpad

* Add specifications for the binary reader

* Implementing the Map associating logical addresses and values (for Instructions)

* edits

* added back build_scratchpad

* binary file instructions

* Solve package naming conflict
Add BinaryReader
Add Test on binary reader

* adding binary files to resources

* changed names of binary files and edits scala files

* tests binaryreader

* data types and tests for INP, WGT, INSNs

* implementation in progress of Success/Failure and offsets

* success/failure implementation and offset test

* edits

* imported binary data for ComputeTest

* new files

* binary files more examples

* binary files

* computeTest attempts

* Clean BinaryReader

* Add modification with precision for datatype
Add integration to ComputeTest

* BinaryReader - modified computeAddresses so that it returns an array of bits

* BinaryReader - computeAddresses fixed to return Map of address and its element in bits

* ComputeTest - tests for 16x16_relu and average pooling

* ComputeTest - import of binary files for average pooling and disregarding load instructions

* ComputeTest - operations gemm alu tests, issue with Average Pooling 16x16 test (missing a division by 2)

* ComputeTest - rectified binary data for lenet5 layer1

* Compiler - started implementing memory address file generating

* Compiler - removed implementation for base address file generation

* BinaryReaderTest - fixed the tests

* BinaryReader - removed FIXME

* ComputeTest - added more binary files for tests and added tests

* ComputeTest - debugging tests

* ComputeTest - debugging tests

* ComputeTest - debugging tests and adding binary files for tests

* ComputeTest - resolution issue with expected_out and debugging tests

* ComputeTest - rectified binary data for conv1

* ComputeTest - debug almost done for tests

* Add debug parameters to manage the print (default: debug = false -> no print)

* ComputeTest - updated binary files for tests

* ComputeTest - tests are working, remains the issue of indexes in expected_out for average_pooling

* BinaryReader - worked on readability

* Update average_pooling.py

* Compiler - generating cvs file for base memory addresses

* Compiler - generating a new binary file average_pooling_sram that keeps all of the sram data

* ComputeTest - csv reader and started implementing in computetest

* ComputeTest - implementation of base addresses computing and expected_out_sram generating completed

* Compiler - fixed avg_pool_sram so that the right values are in X_padded (version that works for layer1 but not for average_pooling in ComputeTest)

* Compiler - modified avg_pool_sram so that it works for average_pooling test in ComputeTest (the function no longer generates the right expected_out_sram for lenet5_layer1)

* Compiler - changed back avg_pool_sram so that it works for layer1 (binary files for layer1 and average_pooling are ok)

* BinaryReader - implementation of boolean fromResources to get files from compiler_output or a resources folder

* Set debug to false and LeNet-5 tests are tagged as LongTests

* Update add debug variable to others tests

* Fix some issues with debug parameters

---------

Co-authored-by: kevin delmas <[email protected]>
Co-authored-by: FAURE-GIGNOUX Anthony <[email protected]>

Author: 3 people

compiler/data_definition/average_pooling.py

@@ -55,6 +55,28 @@ def reference_average_pooling(matrix, kernel_size=2, stride=2, debug=False):
     return pooled_matrix, channel_size, pooled_height
 
 
+def avg_pool_sram(matrix, kernel_size=2, stride=2, debug=False):
+    # Get the height (H) and width (W) of the input matrix
+    pooled_matrix = matrix.copy()
+    H, W = pooled_matrix.shape
+
+    # Compute the size of the square channel tensor (sqrt(H))
+    channel_size = int(np.sqrt(H))  # Each column will be reshaped into channel_size x channel_size
+    
+    # Calculate the dimensions of the pooled matrix after the pooling operation
+    pooled_height = (channel_size - kernel_size) // stride + 1
+
+    # Add 2 by 2
+    for idx in range(0, H, 2):
+        pooled_matrix[idx] = pooled_matrix[idx, :] + pooled_matrix[idx+1, :]
+
+    # Add line + shift right
+    for i in range(0, channel_size - kernel_size + 1, stride): # Row
+        for k in range(0, channel_size - kernel_size + 1, stride): # Col
+            pooled_matrix[i*channel_size + k] = np.floor( (pooled_matrix[i*channel_size + k, :] + pooled_matrix[(i+1)*channel_size + k, :])/(kernel_size**2) )
+
+    return pooled_matrix, channel_size, pooled_height
+
 # Index computation
 # -------------
 def average_pooling_indexes(in_tensor_size=4, out_tensor_size=2, kernel_size=2, stride=2):
@@ -94,14 +116,21 @@ def average_pooling_indexes(in_tensor_size=4, out_tensor_size=2, kernel_size=2,
 # -------------
 if __name__ == '__main__':
     kernel = 2
-    stride = 1
+    stride = 2
 
-    test_matrix = np.random.randint(-128, 127, size=(3**2, 2), dtype=np.int8)
+    # INIT MATRIX
+    test_matrix = np.random.randint(-128, 127, size=(16, 2), dtype=np.int32)
     print(f"The matrix: \n{test_matrix} \n")
 
+    # REFERENCE
     pooled_matrix, in_tensor, out_tensor = reference_average_pooling(test_matrix, kernel, stride, debug=True)
     print(f"The pooled matrix: \n{pooled_matrix} \n")
 
+    # SRAM RESULT
+    sram_matrix, _, _ = avg_pool_sram(test_matrix, kernel, stride, debug=True)
+    print(f"The SRAM matrix: \n{sram_matrix} \n")
+
+    # INDEXES COMPUTATION
     indexes = average_pooling_indexes(in_tensor, out_tensor, kernel, stride)
     print("The indexes:")
     for index in indexes:

compiler/data_definition/main_matrix_generator.py

@@ -2,6 +2,7 @@
 # ---------------
 import os
 import sys
+import csv
 import importlib
 import numpy as np
 import matrix_generator as MG
@@ -70,15 +71,34 @@ def main(config_file):
     if (config.doAvgPool):
         if (config.isInitRandom):
             ACC_pooled_ref, in_tensor, out_tensor = AP.reference_average_pooling(ACC_matrix, config.Avg_kernel, config.Avg_stride)
+            ACC_pooled_sram, _, _ = AP.avg_pool_sram(ACC_matrix, config.Avg_kernel, config.Avg_stride)
         else:
             ACC_pooled_ref, in_tensor, out_tensor = AP.reference_average_pooling(X_padded, config.Avg_kernel, config.Avg_stride)
+            ACC_pooled_sram, _, _ = AP.avg_pool_sram(X_padded, config.Avg_kernel, config.Avg_stride)
 
         # Write the result
         ACC_pooled = MG.matrix_padding(matrix=ACC_pooled_ref, block_size=config.block_size, isWeight=False, isSquare=config.isSquare)
         C_pooled = MM.truncate_to_int8(ACC_pooled)
+        ACC_pooled_sram2 = MG.matrix_padding(matrix=ACC_pooled_sram, block_size=config.block_size, isWeight=False, isSquare=config.isSquare)
+        C_pooled_sram = MM.truncate_to_int8(ACC_pooled_sram2)
 
         # Overwrite the result
         C_blocks, _ = MS.matrix_splitting(matrix=C_pooled, block_size=config.block_size, isWeight=False, isSquare=config.isSquare)
+        C_blocks_sram, _ = MS.matrix_splitting(matrix=C_pooled_sram, block_size=config.block_size, isWeight=False, isSquare=config.isSquare)
+
+    C_empty = MG.matrix_creation(n_row=C_padded.shape[0], n_col=C_padded.shape[1], isInitRandom=False, dtype=np.int8)
+
+    # Compute memory addresses for data
+
+    object_info = [(A_padded.shape[0] * A_blocks_col * 16, 16),      # INP
+                   (B_padded.shape[0] * B_blocks_col * 16, 256),     # WGT
+                   ((C_pooled if config.doAvgPool else C_padded).shape[0] * C_blocks_col * 16, 16),      # OUT
+                   (20 * 4, 4),                                      # UOP - 20 chosen arbitrarily as number of UOPs rarely exceeds 10
+                   (X_padded.shape[0] * X_blocks_col * 64, 64)]      # ACC     
+
+
+    memory_addresses = MA.memory_base_address(object_info)
+
 
     # Write binary files
     if (config.doWriteBinaryFile):
@@ -87,7 +107,29 @@ def main(config_file):
         B_blocks_file_path = os.path.join(output_dir, 'weight.bin')
         X_blocks_file_path = os.path.join(output_dir, 'accumulator.bin')
         C_padded_file_path = os.path.join(output_dir, 'expected_out.bin')
-
+        C_padded_sram_file_path = os.path.join(output_dir, 'expected_out_sram.bin')
+        C_empty_file_path = os.path.join(output_dir, 'out.bin')
+        memory_addresses_data_file_path = os.path.join(output_dir, 'memory_addresses.csv')
+        
+        alloc_names = {
+            'Alloc1': 'inp',
+            'Alloc2': 'wgt',
+            'Alloc3': 'out',
+            'Alloc4': 'uop',
+            'Alloc5': 'acc'}
+        
+        # Write memory addresses
+        with open(memory_addresses_data_file_path, 'w', newline='') as csvfile:
+            writer = csv.writer(csvfile)
+            for ligne in memory_addresses:
+                if alloc_names[ligne['object']] in ['inp', 'wgt', 'out']:
+                    writer.writerow([alloc_names[ligne['object']], '0x0000'])
+                else:
+                    writer.writerow([alloc_names[ligne['object']], ligne['phys_hex']])
+        
+        # Write C empty matrix
+        C_empty.tofile(C_empty_file_path)
+        
         # Write A_block matrix
         with open(A_blocks_file_path, 'wb') as f:
             for block in A_blocks:
@@ -105,7 +147,15 @@ def main(config_file):
                 block.tofile(f)
 
         # Write C_padded (expected result)
-        C_padded.tofile(C_padded_file_path)
+        with open(C_padded_file_path, 'wb') as f:
+            for block in C_blocks:
+                block.tofile(f)
+                
+        # Write C_padded_sram (expected result with all vectors for average pooling comparison)
+        if (config.doAvgPool):
+            with open(C_padded_sram_file_path, 'wb') as f:
+                for block in C_blocks_sram:
+                    block.tofile(f)
 
         # Confirm the binary files generation
         print("\nBinary files successfully generated.\n")
@@ -199,7 +249,6 @@ def main(config_file):
         print("\n\n DRAM 'physical' VTA ADDRESSES:")
         for addr in vta_addr:
             print(addr)
-
     # End of the execution
     return 0