OPEN: Merge local to public

.gitignore

@@ -9,4 +9,5 @@ application
 **/gmon.out
 .idea
 dory.egg-info
-dory.egg-info/
+dory.egg-info/
+DSCNN_DIR_DEST_DORY/

.gitmodules

@@ -1,12 +1,12 @@
 [submodule "dory_examples"]
 	path = dory/dory_examples
-	url = ../../pulp-platform/dory_examples
+	url = https://github.com/pulp-platform/dory_examples
 [submodule "Hardware-targets/GAP8/Backend_Kernels/pulp-nn"]
 	path = dory/Hardware_targets/PULP/Backend_Kernels/pulp-nn
-	url = ../../pulp-platform/pulp-nn.git
+	url = https://github.com/pulp-platform/pulp-nn.git
 [submodule "Hardware-targets/Diana/Backend_Kernels/dory-hal"]
 	path = dory/Hardware_targets/Diana/Backend_Kernels/dory-hal
-	url = ../../ABurrello/dory-hal.git
+	url = https://github.com/ABurrello/dory-hal.git
 [submodule "dory/Hardware_targets/GAP8/Backend_Kernels/pulp-nn-mixed"]
 	path = dory/Hardware_targets/PULP/Backend_Kernels/pulp-nn-mixed
 	url = https://github.com/pulp-platform/pulp-nn-mixed.git

dory/Frontend_frameworks/NEMO/Parser.py

@@ -34,7 +34,7 @@
 class onnx_manager(Parser_ONNX_to_DORY):
     # Used to manage the ONNX files. By now, supported Convolutions (PW and DW), Pooling, Fully Connected and Relu.
 
-    def __init__(self, onnx, config_file, net_prefix=""):
+    def __init__(self, onnx, config_file, net_prefix="", n_trainable_layers=0):
         layers_accepted = ['Conv', 'Pad', 'Mul', 'Add', 'Div', 'Constant', 'AveragePool', 'GlobalAveragePool', 'MaxPool', 'Cast', 'Clip', 'Floor', 'Flatten', 'Gemm', 'MatMul', 'Shape', 'Gather', 'Unsqueeze', 'Concat', 'Reshape', 'Sigmoid', 'LogSoftmax']
         layers_neglected = ['Cast', 'Floor', 'Flatten', 'Shape', 'Gather', 'Unsqueeze', 'Concat', 'Reshape', 'Sigmoid', 'LogSoftmax']
         layers_to_node = ['AveragePool', 'MaxPool', 'Conv', 'Gemm', 'MatMul', 'GlobalAveragePool']
@@ -45,7 +45,7 @@ def __init__(self, onnx, config_file, net_prefix=""):
             self.n_test_inputs = config_file["n_inputs"]
         except KeyError:
             self.n_test_inputs = 1
-        super().__init__(onnx, rules, layers_accepted, layers_neglected, layers_to_node, net_prefix)
+        super().__init__(onnx, rules, layers_accepted, layers_neglected, layers_to_node, net_prefix, n_trainable_layers)
 
     def frontend_mapping_to_DORY_nodes(self):
         print("\nNEMO Frontend: Matching patterns from generated ONNX to DORY.")
@@ -55,6 +55,7 @@ def frontend_mapping_to_DORY_nodes(self):
             string_matching, indexes = self.pattern_matching(node, i)
             if isinstance(string_matching, str):
                 self.DORY_Graph = Pattern_rewriter(self.DORY_Graph).execute(string_matching, indexes)
+
         print("\nNEMO Frontend: Updating Add nodes with constants.")
         for i, node in enumerate(self.DORY_Graph):
             if "Addition" in node.name:

dory/Frontend_frameworks/Quantlab/Parser.py

@@ -35,7 +35,7 @@
 class onnx_manager(Parser_ONNX_to_DORY):
     # Used to manage the ONNX files. By now, supported Convolutions (PW and DW), Pooling, Fully Connected and Relu.
 
-    def __init__(self, onnx, config_file, net_prefix=""):
+    def __init__(self, onnx, config_file, net_prefix="", n_trainable_layers=0):
         layers_accepted = ['Conv', 'Pad', 'Mul', 'Add', 'Div', 'Constant', 'AveragePool', 'GlobalAveragePool', 'MaxPool', 'Cast', 'Clip', 'Floor', 'Flatten', 'Gemm', 'MatMul', 'Shape', 'Gather', 'Unsqueeze', 'Squeeze', 'Concat', 'Reshape', 'Sigmoid', 'LogSoftmax']
         layers_neglected = ['Cast', 'Floor', 'Flatten', 'Shape', 'Gather', 'Unsqueeze', 'Concat', 'Reshape', 'Sigmoid', 'LogSoftmax', 'Squeeze']
         layers_to_node = ['AveragePool', 'MaxPool', 'Conv', 'Gemm', 'MatMul', 'GlobalAveragePool']
@@ -53,7 +53,7 @@ def __init__(self, onnx, config_file, net_prefix=""):
             self.n_test_inputs = config_file["n_inputs"]
         except KeyError:
             self.n_test_inputs = 1
-        super().__init__(onnx, rules, layers_accepted, layers_neglected, layers_to_node, net_prefix)
+        super().__init__(onnx, rules, layers_accepted, layers_neglected, layers_to_node, net_prefix, n_trainable_layers)
 
     def frontend_mapping_to_DORY_nodes(self):
         print("\nQuantlab Frontend: Matching patterns from generated ONNX to DORY.")
@@ -93,7 +93,11 @@ def frontend_mapping_to_DORY_nodes(self):
                 # input 1 parameters
                 #### Look at the order of inputs in Onnx. If the lowest index
                 #is not the first argument, revert the order inmul1 and inmul2
-                if int(node.input_indexes[0]) > int(node.input_indexes[1]):
+                def pos_in_schedule(node: str) -> int:
+                    for idx, node_iterating in enumerate(list(self.graph.graph.node)):
+                        if node_iterating.output[0] == node:
+                            return idx
+                if pos_in_schedule(node.input_indexes[0]) > pos_in_schedule(node.input_indexes[1]):
                     temp_shift = node.in1_shift
                     temp_mul   = node.in1_mul
                     temp_add   = node.in1_add

dory/Hardware_targets/PULP/Backend_Kernels/BackendKernelsAdapter.py

@@ -177,24 +177,32 @@ def _check_valid_node(self, node: HW_node) -> None:
         if self.accelerator_name == "ne16":
             assert True  # TODO
 
-    def _get_ne16_src_files(self) -> List[str]:
-        return ["src/pulp_nnx_ne16.c", "ne16/hal/ne16_hal.c"]
+    def _get_acc_src_files(self) -> List[str]:
+        return [
+            f"{self.accelerator_name}/hal/{self.accelerator_name}.c",
+            f"{self.accelerator_name}/hal/{self.accelerator_name}_task.c",
+            f"{self.accelerator_name}/bsp/{self.accelerator_name}_pulp_bsp.c",
+            f"src/pulp_nnx_{self.accelerator_name}.c",
+        ]
 
-    def _get_ne16_inc_files(self) -> List[str]:
+    def _get_acc_inc_files(self) -> List[str]:
         return [
-            "ne16/gvsoc/ne16_gvsoc_logging.h",
-            "ne16/hal/ne16_defs.h",
-            "ne16/hal/ne16_hal.h",
+            f"{self.accelerator_name}/gvsoc/{self.accelerator_name}_gvsoc.h",
+            f"{self.accelerator_name}/hal/{self.accelerator_name}_task_defs.h",
+            f"{self.accelerator_name}/hal/{self.accelerator_name}.h",
+            f"{self.accelerator_name}/hal/{self.accelerator_name}_task.h",
+            f"{self.accelerator_name}/bsp/{self.accelerator_name}_pulp_bsp.h",
+            f"inc/pulp_nnx_{self.accelerator_name}.h",
         ]
 
     def _get_src_files(self) -> List[str]:
-        src_files = ["util/pulp_nnx_util.c"]
+        src_files = ["util/pulp_nnx_util.c", "util/hwpe.c"]
         if self.accelerator_name == "ne16":
-            src_files += self._get_ne16_src_files()
+            src_files += self._get_acc_src_files()
         return [os.path.join(self._root_dir(), file) for file in src_files]
 
     def _get_inc_files(self) -> List[str]:
-        inc_files = ["inc/pulp_nnx.h", "util/pulp_nnx_util.h"]
+        inc_files = ["util/pulp_nnx_util.h", "util/hwpe.h"]
         if self.accelerator_name == "ne16":
-            inc_files += self._get_ne16_inc_files()
-        return [os.path.join(self._root_dir(), file) for file in inc_files]
+            inc_files += self._get_acc_inc_files()
+        return [os.path.join(self._root_dir(), file) for file in inc_files]

dory/Hardware_targets/PULP/Common/C_Parser.py

@@ -93,8 +93,8 @@ def mapping_layers_to_C_files(self):
 
             if n_memory_levels > 2 and (node.L3_input != 0 or (node.tiling_dimensions["L3"]["output_dimensions"] != node.tiling_dimensions["L2"]["output_dimensions"]) or (node.tiling_dimensions["L3"]["weights_dimensions"] != node.tiling_dimensions["L2"]["weights_dimensions"])):
                 tk = Layer2D_writer.print_template_layer_L3(node)
-                TemplateWriter.write(tk, {os.path.join(self.src_dir, node.prefixed_name + ".c"): os.path.join(self.tmpl_dir, "layer_L3_c_template.c"),
-                                          os.path.join(self.inc_dir, node.prefixed_name + ".h"): os.path.join(self.tmpl_dir, "layer_L3_h_template.h")})
+                TemplateWriter.write(tk, {os.path.join(self.src_dir, node.prefixed_name + ".c"): os.path.join(self.layer_tmpl_dir, "layer_L3_c_template.c"),
+                                          os.path.join(self.inc_dir, node.prefixed_name + ".h"): os.path.join(self.layer_tmpl_dir, "layer_L3_h_template.h")})
                 if node.tiling_dimensions["L3"]["input_dimensions"][1] > node.tiling_dimensions["L2"]["input_dimensions"][1]:
                     node.tiling_dimensions["L2"]["output_dimensions"][1]  = int(np.floor((node.tiling_dimensions["L2"]["input_dimensions"][1] - node.kernel_shape[0] + node.strides[0]) / node.strides[0]))
                 if node.tiling_dimensions["L3"]["output_dimensions"][1] > node.tiling_dimensions["L2"]["output_dimensions"][1]:

dory/Hardware_targets/PULP/Common/Templates/layer_templates/layer_L3_c_template.c

@@ -17,11 +17,9 @@
  * limitations under the License. 
  */
 #include "${func_name_L3}.h"
-#include "${func_name[0]}.h"
-% if len(func_name)>1:
-#include "${func_name[1]}.h"
-#include "${func_name[2]}.h"
-%endif
+% for name in func_name:
+#include "${name}.h"
+% endfor
 #include "dory_get_tile.h"
 #include "pmsis.h"
 #include "bsp/fs.h"

dory/Hardware_targets/PULP/Common/Templates/main.c.t

@@ -96,7 +96,8 @@ int main () {
 #ifndef TARGET_CHIP_FAMILY_GAP9
   PMU_set_voltage(1000, 0);
 #else
-  pi_pmu_voltage_set(PI_PMU_VOLTAGE_DOMAIN_CHIP, PI_PMU_VOLT_800);
+  pi_pmu_voltage_set(PI_PMU_VOLTAGE_DOMAIN_CHIP, PI_VOLT_800); // GAP9
+  // pi_pmu_voltage_set(PI_PMU_VOLTAGE_DOMAIN_CHIP, PI_PMU_VOLT_800); // GAP8
 #endif
   pi_time_wait_us(10000);
   pi_freq_set(PI_FREQ_DOMAIN_FC, ${fc_frequency});

dory/Hardware_targets/PULP/Common/Templates/network.c.t

@@ -62,11 +62,11 @@ void ${prefix}network_initialize() {
   L3_input = ram_malloc(L3_INPUT_SIZE);
   L3_output = ram_malloc(L3_OUTPUT_SIZE);
 
-#ifdef VERBOSE
+% if 'Yes' in performance:
   printf("\nL3 Buffer alloc initial\t@ %d:\t%s\n", (unsigned int)L3_weights, L3_weights?"Ok":"Failed");
   printf("\nL3 Buffer alloc initial\t@ %d:\t%s\n", (unsigned int)L3_input, L3_input?"Ok":"Failed");
   printf("\nL3 Buffer alloc initial\t@ %d:\t%s\n", (unsigned int)L3_output, L3_output?"Ok":"Failed");
-#endif
+% endif
 
   void *w_ptr = L3_weights;
   for (int i = 0; i < ${weights_number}; i++) {
@@ -113,7 +113,7 @@ struct ${prefix}network_run_token ${prefix}network_run_async(void *l2_buffer, si
   pi_cluster_conf_init(&conf);
   conf.id=0;
 <%
-    n_args = 4 if l3_supported else 5
+    n_args = 5 if l3_supported else 6
 %>\
   unsigned int args[${n_args}];
   args[0] = (unsigned int) l2_buffer;
@@ -141,8 +141,10 @@ struct ${prefix}network_run_token ${prefix}network_run_async(void *l2_buffer, si
 void ${prefix}network_run_wait(struct ${prefix}network_run_token token)
 {
   pi_cluster_close(&token.cluster_dev);
-  % if 'Perf_final' in verbose_level:
+  % if 'Yes' in performance:
+  #ifdef VERBOSE
   print_perf("Final", ${prefix}cycle_network_execution, ${MACs});
+  #endif
   % endif
 }
 
@@ -215,6 +217,7 @@ void ${prefix}network_run_cluster(void *args) {
 /* -------- SECTION 2 BEGIN --------- */
 /* ---------------------------------- */
   int weight_l_cnt = 0; // count how many layers with weights we have processed to increment the weights_L3 pointer
+
   for (int i = 0; i < ${len(DORY_HW_graph)}; i++) {
 /* MEMORY ALLOCATION
   - allocate memory if layer is executed from L3;
@@ -235,6 +238,7 @@ void ${prefix}network_run_cluster(void *args) {
     L2_weights = Weights_name[i];
 % endif
 
+% if 'Yes' in performance:
 % if 'Check_all' in verbose_level:
 #ifdef VERBOSE
         % if l3_supported:
@@ -256,6 +260,7 @@ void ${prefix}network_run_cluster(void *args) {
     else
       printf("Switching branch, already checked activation\n");
 #endif
+% endif
 % endif
 
     layer_args_t largs = {
@@ -292,7 +297,9 @@ void ${prefix}network_run_cluster(void *args) {
 % endif
 
 % if 'Yes' in performance:
+    #ifdef VERBOSE
     print_perf(Layers_name[i], perf_cyc, NODEs_MACS[i]);
+    #endif
 % endif
 
     // TODO: What error?
@@ -304,6 +311,7 @@ void ${prefix}network_run_cluster(void *args) {
     L3_output = temp;
     asm volatile("": : :"memory");
 
+% if 'Yes' in performance:
 #ifdef VERBOSE
     printf("Layer %s %d ended: \n", Layers_name[i], i);
 % if 'Check_all' in verbose_level:
@@ -323,6 +331,7 @@ void ${prefix}network_run_cluster(void *args) {
         checksum("final layer", L2_output, activations_out_size[i], activations_out_checksum[i][exec]);
 % endif
 #endif
+% endif
 
     // Free memory
     % if l3_supported:

dory/Hardware_targets/PULP/Common/Tiler/tiler_add.py

@@ -91,62 +91,47 @@ def get_tiling_Add_L2(self):
         # return immediatly if the memory fits the L1
         if buffer_total <= L1_memory:
             return ([], self.HW_node.tiling_dimensions["L2"]["input_dimensions"] , self.HW_node.tiling_dimensions["L2"]["output_dimensions"] )
-        else:
-            db = self.double_buffering
+
+        db = self.double_buffering
 
         parameters = pywrapcp.Solver.DefaultSolverParameters()
         solver = pywrapcp.Solver("simple_CP", parameters)
 
-        # integer positive variables.
-        tile_n = solver.IntVar(1, in_ch, 'tile_n')
-        tile_h_in =  solver.IntVar(ks[0], inp_dim[0], 'tile_h_in')
-        tile_w_in =  solver.IntVar(ks[1], inp_dim[1], 'tile_w_in')
-        tile_h_out = solver.IntVar(1, out_dim[0], 'tile_h_out')
-        tile_w_out = solver.IntVar(1, out_dim[1], 'tile_w_out')
+        assert in_ch == out_ch
 
-        # scaling is used to ensure datasize is integer
-        solver.Add(tile_h_out == tile_h_in)
-        solver.Add(tile_w_out == tile_w_in)
-        solver.Add(tile_n == in_ch)
+        # integer positive variables.
+        tile_n = in_ch
+        tile_h = solver.IntVar(1, inp_dim[0], 'tile_h_in')
+        tile_w = inp_dim[1]
 
         # CONSTRAINTS: managing of correct dimensions (no decimal h_out and any
         # type of rounding)
-        input_tile_dimension  = (db * in_ch * tile_h_in * inp_dim[1] * self.HW_node.input_activation_bits + 7 ) // 8 # the 7 is to account for bit precision of 1, which still occupy an entire byte
-        output_tile_dimension = (db * out_ch * tile_h_out * out_dim[1] * self.HW_node.output_activation_bits + 7 ) // 8 # the 7 is to account for bit precision of 1, which still occupy an entire byte
+        input_tile_dimension  = (db * tile_n * tile_h * tile_w * self.HW_node.input_activation_bits + 7 ) // 8 # the 7 is to account for bit precision of 1, which still occupy an entire byte
+        output_tile_dimension = (db * tile_n * tile_h * tile_w * self.HW_node.output_activation_bits + 7 ) // 8 # the 7 is to account for bit precision of 1, which still occupy an entire byte
         constraint_all = input_tile_dimension * int(np.ceil(1+self.HW_node.second_input_activation_bits/self.HW_node.input_activation_bits)) + output_tile_dimension
         solver.Add(constraint_all <= L1_memory)
+
         # objective
         obj_expr = solver.IntVar(0, 1000000000000, "obj_expr")
-        solver.Add(obj_expr == 1000000 * constraint_all
-                   + 10 * tile_w_in
-                   + 1 * tile_h_in
-                   + 1000 * tile_n)
+        solver.Add(obj_expr == constraint_all)
         objective = solver.Maximize(obj_expr, 1)
 
-        decision_builder = solver.Phase([tile_n, tile_h_in, tile_w_in, tile_h_out, tile_w_out],
+        decision_builder = solver.Phase([tile_h],
                                         solver.CHOOSE_FIRST_UNBOUND,
                                         solver.ASSIGN_MIN_VALUE)
 
         # Create a solution collector.
         collector = solver.LastSolutionCollector()
         # Add the decision variables.
-        collector.Add(tile_n)
-        collector.Add(tile_h_in)
-        collector.Add(tile_w_in)
-        collector.Add(tile_h_out)
-        collector.Add(tile_w_out)
+        collector.Add(tile_h)
         # Add the objective.
         collector.AddObjective(obj_expr)
 
         solver.Solve(decision_builder, [objective, collector])
         if collector.SolutionCount() > 0:
             best_solution = collector.SolutionCount() - 1
-            tile_n = collector.Value(best_solution, tile_n)
-            tile_h_in = collector.Value(best_solution, tile_h_in)
-            tile_w_in = collector.Value(best_solution, tile_w_in)
-            tile_h_out = collector.Value(best_solution, tile_h_out)
-            tile_w_out = collector.Value(best_solution, tile_w_out)
-            return ([], [tile_n, tile_h_in, tile_w_in], [tile_n, tile_h_out, tile_w_out])
+            tile_h = collector.Value(best_solution, tile_h)
+            return ([], [tile_n, tile_h, tile_w], [tile_n, tile_h, tile_w])
         print("  Add ERROR: no tiling found. Exiting...")
         os._exit(0)
         return None

dory/Hardware_targets/PULP/GAP8_L2/HW_description.json

@@ -31,7 +31,7 @@
 	"accelerator frequency": 100000000,
 	"HW specific parameters":{
 		"accelerator core0 stack": 3500,
-		"accelerator core1-7 stack": 3400		
+		"accelerator core1-7 stack": 3400
 	},
     "split_ints": true,
     "double_buffering": 1

dory/Hardware_targets/PULP/GAP9/HW_description.json

@@ -3,7 +3,7 @@
 	"memory": {
 		"levels": 3,
 		"L1": {
-			"dimension": 120000,
+			"dimension": 110000,
 			"bandwidth": 32,
 			"latency": 1,
 			"frequency": 100000000

dory/Hardware_targets/PULP/GAP9/Templates/layer_templates/layer_L2_c_addition_template.c

@@ -119,8 +119,8 @@ static void kernel(Layer tile, Layer tile2) {
     tile.addr.input,
     tile2.addr.input,
     tile.addr.output,
-    ${inmul2},
     ${inmul1},
+    ${inmul2},
     ${outshift},
     tile.input.width,
     tile.input.height,