Rename "unrolled" -> "resource_unrolled"

vloncar · vloncar · commit c4af46af9835 · 2024-10-07T10:41:34.000+02:00
diff --git a/hls4ml/backends/vitis/passes/feature_check.py b/hls4ml/backends/vitis/passes/feature_check.py
@@ -35,17 +35,17 @@ def transform(self, model, node):
             )
 
 
-class ValidateUnrolledStrategy(OptimizerPass):
+class ValidateResourceUnrolledStrategy(OptimizerPass):
     _unrolled_layer_cls = ['Conv1D', 'Conv2D', 'Dense', 'GRU', 'LSTM']
 
     def match(self, node):
         is_unrolled_layer = len([layer_cls for layer_cls in self._unrolled_layer_cls if layer_cls in node.class_name]) > 0
-        is_unrolled_strategy = node.get_attr('strategy', 'latency').lower() == 'unrolled'
+        is_unrolled_strategy = node.get_attr('strategy', 'latency').lower() == 'resource_unrolled'
 
         return is_unrolled_layer and is_unrolled_strategy
 
     def transform(self, model, node):
         print(
-            f'WARNING: "Unrolled" strategy in "{node.name}" ({node.class_name}) may have unexpected II in Vitis backend.\n'
-            'Verify that the final design satisfies the latency/II constraints.'
+            f'WARNING: "ResourceUnrolled" strategy in "{node.name}" ({node.class_name}) may have unexpected II in'
+            'Vitis backend.\nVerify that the final design satisfies the latency/II constraints.'
         )
diff --git a/hls4ml/backends/vitis/vitis_backend.py b/hls4ml/backends/vitis/vitis_backend.py
@@ -16,7 +16,7 @@ def _register_flows(self):
         validation_passes = [
             'vitis:validate_conv_implementation',
             'vitis:validate_resource_strategy',
-            'vitis:validate_unrolled_strategy',
+            'vitis:validate_resource_unrolled_strategy',
         ]
         validation_flow = register_flow('validation', validation_passes, requires=['vivado:init_layers'], backend=self.name)
 
diff --git a/hls4ml/backends/vivado/passes/convolution_templates.py b/hls4ml/backends/vivado/passes/convolution_templates.py
@@ -111,8 +111,8 @@ def format(self, node):
             else:
                 mult_params['dense_function'] = 'DenseResource_rf_gt_nin_rem0'
             # The 3rd case is never used
-        elif node.get_attr('strategy').lower() == 'unrolled':
-            mult_params['dense_function'] = f'dense_unrolled_{node.index}'
+        elif node.get_attr('strategy').lower() == 'resource_unrolled':
+            mult_params['dense_function'] = f'dense_resource_unrolled_{node.index}'
 
         mult_config = self.mult_template.format(**mult_params)
 
@@ -236,8 +236,8 @@ def format(self, node):
             else:
                 mult_params['dense_function'] = 'DenseResource_rf_gt_nin_rem0'
             # The 3rd case is never used
-        elif node.get_attr('strategy').lower() == 'unrolled':
-            mult_params['dense_function'] = f'dense_unrolled_{node.index}'
+        elif node.get_attr('strategy').lower() == 'resource_unrolled':
+            mult_params['dense_function'] = f'dense_resource_unrolled_{node.index}'
 
         mult_config = self.mult_template.format(**mult_params)
 
diff --git a/hls4ml/backends/vivado/passes/core_templates.py b/hls4ml/backends/vivado/passes/core_templates.py
@@ -51,8 +51,8 @@ def format(self, node):
             else:
                 params['dense_function'] = 'DenseResource_rf_gt_nin_rem0'
             # The 3rd case is never used
-        elif node.get_attr('strategy').lower() == 'unrolled':
-            params['dense_function'] = f'dense_unrolled_{node.index}'
+        elif node.get_attr('strategy').lower() == 'resource_unrolled':
+            params['dense_function'] = f'dense_resource_unrolled_{node.index}'
 
         return self.template.format(**params)
 
diff --git a/hls4ml/backends/vivado/passes/pipeline_style.py b/hls4ml/backends/vivado/passes/pipeline_style.py
@@ -25,7 +25,7 @@ def transform(self, model):
             if self._maybe_set_dataflow_resource_strategy(model):
                 return True
 
-            if self._maybe_set_pipeline_unrolled_strategy(model):
+            if self._maybe_set_pipeline_resource_unrolled_strategy(model):
                 return True
 
             if self._maybe_set_pipeline_io_parallel(model):
@@ -65,10 +65,10 @@ def _maybe_set_dataflow_resource_strategy(self, model):
 
         return False
 
-    def _maybe_set_pipeline_unrolled_strategy(self, model):
+    def _maybe_set_pipeline_resource_unrolled_strategy(self, model):
         have_unrolled = False
         for layer in model.get_layers():
-            if model.config.get_strategy(layer).lower() == 'unrolled':
+            if model.config.get_strategy(layer).lower() == 'resource_unrolled':
                 self._set_pipeline_style(model, 'pipeline')
                 have_unrolled = True
                 break
diff --git a/hls4ml/backends/vivado/passes/recurrent_templates.py b/hls4ml/backends/vivado/passes/recurrent_templates.py
@@ -149,8 +149,8 @@ def format(self, node):
             else:
                 mult_params1['dense_function'] = 'DenseResource_rf_gt_nin_rem0'
             # The 3rd case is never used
-        elif node.get_attr('strategy').lower() == 'unrolled':
-            mult_params1['dense_function'] = f'dense_unrolled_{node.index}_1'
+        elif node.get_attr('strategy').lower() == 'resource_unrolled':
+            mult_params1['dense_function'] = f'dense_resource_unrolled_{node.index}_1'
 
         if node.get_attr('return_sequences'):
             mult_params2['n_in'] = node.get_output_variable().shape[1]
@@ -174,8 +174,8 @@ def format(self, node):
             else:
                 mult_params2['dense_function'] = 'DenseResource_rf_gt_nin_rem0'
             # The 3rd case is never used
-        elif node.get_attr('strategy').lower() == 'unrolled':
-            mult_params2['dense_function'] = f'dense_unrolled_{node.index}_2'
+        elif node.get_attr('strategy').lower() == 'resource_unrolled':
+            mult_params2['dense_function'] = f'dense_resource_unrolled_{node.index}_2'
 
         mult_config1 = self.mult1_template.format(**mult_params1)
         mult_config2 = self.mult2_template.format(**mult_params2)
diff --git a/hls4ml/backends/vivado/passes/resource_strategy.py b/hls4ml/backends/vivado/passes/resource_strategy.py
@@ -9,7 +9,7 @@ class ApplyResourceStrategy(OptimizerPass):
 
     def match(self, node):
         node_matches = isinstance(node, (Dense, Conv1D, SeparableConv1D, Conv2D, SeparableConv2D, LSTM, GRU))
-        is_resource_strategy = node.get_attr('strategy', '').lower() in ['resource', 'unrolled']
+        is_resource_strategy = node.get_attr('strategy', '').lower() in ['resource', 'resource_unrolled']
         already_transformed = node.get_attr('_weights_transposed', False) is True
 
         return node_matches and is_resource_strategy and not already_transformed
diff --git a/hls4ml/backends/vivado/passes/unrolled_codegen.py b/hls4ml/backends/vivado/passes/unrolled_codegen.py
@@ -15,14 +15,14 @@ def match(self, node):
         # TODO - Extend (& test) for Separable Conv / Depthwise Conv / Recurrent layers
         layers_with_dense = (Dense, Conv1D, Conv2D, LSTM, GRU)
 
-        # Unrolled Dense mimicks the hardware implementation of Resource strategy -> apply after Resource optimizer
+        # Unrolled Dense mimics the hardware implementation of Resource strategy -> apply after Resource optimizer
         weights_transposed = node.get_attr('_weights_transposed', False)
 
         # RF = 1 will optimize DSPs anyway, so no need to unroll code
         rf_gt_one = node.get_attr('reuse_factor', 1) > 1
 
         # User requested unrolled implementation of Dense
-        is_unrolled = node.get_attr('strategy', 'latency') == 'unrolled'
+        is_unrolled = node.get_attr('strategy', 'latency') == 'resource_unrolled'
 
         return isinstance(node, layers_with_dense) and weights_transposed and rf_gt_one and is_unrolled
 
@@ -34,15 +34,15 @@ def transform(self, model, node):
             weights = node.weights['weight']
             code_str = self._generate_unrolled_function(n_in, n_out, reuse_factor, weights, str(node.index) + '_1')
             code_str = self._add_backend_specific_pragmas_to_generated_code(code_str, model.config.backend)
-            node.set_attr('unrolled_dense_resource_codegen_1', Source(code_str))
+            node.set_attr('resource_unrolled_dense_codegen_1', Source(code_str))
 
             recr_reuse_factor = node.get_attr('recurrent_reuse_factor')
             recr_weights = node.weights['recurrent_weight']
             code_str = self._generate_unrolled_function(
                 n_in_recr, n_out_recr, recr_reuse_factor, recr_weights, str(node.index) + '_2'
             )
             code_str = self._add_backend_specific_pragmas_to_generated_code(code_str, model.config.backend)
-            node.set_attr('unrolled_dense_resource_codegen_2', Source(code_str))
+            node.set_attr('resource_unrolled_dense_codegen_2', Source(code_str))
 
         else:
             n_in, n_out = node.model.config.backend.get_layer_mult_size(node)
@@ -51,7 +51,7 @@ def transform(self, model, node):
 
             code_str = self._generate_unrolled_function(n_in, n_out, reuse_factor, weights, node.index)
             code_str = self._add_backend_specific_pragmas_to_generated_code(code_str, model.config.backend)
-            node.set_attr('unrolled_dense_resource_codegen', Source(code_str))
+            node.set_attr('resource_unrolled_dense_codegen', Source(code_str))
 
     def _generate_unrolled_function(self, n_in, n_out, reuse_factor, weights, function_suffix):
         """
@@ -72,7 +72,7 @@ def _generate_unrolled_function(self, n_in, n_out, reuse_factor, weights, functi
         # Variable instantiation and function pragmas
         generated_code = (
             'template<class data_T, class res_T, typename CONFIG_T>\n'
-            'class dense_unrolled_{suffix} : public DenseKernel<data_T, res_T, CONFIG_T> {{{{\n'
+            'class dense_resource_unrolled_{suffix} : public DenseKernel<data_T, res_T, CONFIG_T> {{{{\n'
             '    public:\n'
             '    static void dense(\n'
             '    data_T data[CONFIG_T::n_in], res_T res[CONFIG_T::n_out],\n'
diff --git a/hls4ml/backends/vivado/vivado_backend.py b/hls4ml/backends/vivado/vivado_backend.py
@@ -266,11 +266,11 @@ def init_dense(self, layer):
                 index_t = layer.get_weights('weight').type.index_precision
             else:
                 layer.set_attr('strategy', 'resource')
-        elif layer.model.config.get_strategy(layer).lower() == 'unrolled':
+        elif layer.model.config.get_strategy(layer).lower() == 'resource_unrolled':
             use_resource_instead = False
             if layer.get_attr('reuse_factor', 1) == 1:
                 print(
-                    f'Unrolled strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
+                    f'Unrolled resource strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
@@ -281,7 +281,7 @@ def init_dense(self, layer):
                 layer.set_attr('strategy', 'resource')
             else:
                 self.set_closest_reuse_factor(layer, n_in, n_out, include_max_rf=False)
-                layer.set_attr('strategy', 'unrolled')
+                layer.set_attr('strategy', 'resource_unrolled')
         else:
             layer.set_attr('strategy', 'latency')
         layer.set_attr('index_t', NamedType(f'layer{layer.index}_index', index_t))
@@ -297,17 +297,17 @@ def init_conv1d(self, layer):
             n_in, n_out = self.get_layer_mult_size(layer)
             self.set_target_reuse_factor(layer)
             self.set_closest_reuse_factor(layer, n_in, n_out)
-        elif layer.model.config.get_strategy(layer).lower() == 'unrolled':
+        elif layer.model.config.get_strategy(layer).lower() == 'resource_unrolled':
             use_resource_instead = False
             if layer.get_attr('reuse_factor', 1) == 1:
                 print(
-                    f'Unrolled strategy cannot be combined with reuse factor 1 in layer "{layer.name}".'
+                    f'Unrolled resource strategy cannot be combined with reuse factor 1 in layer "{layer.name}".'
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
             elif layer.model.config.get_config_value('IOType') == 'io_parallel':
                 print(
-                    f'Unrolled strategy cannot be combined with io_parallel in layer "{layer.name}". '
+                    f'Unrolled resource strategy cannot be combined with io_parallel in layer "{layer.name}". '
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
@@ -318,7 +318,7 @@ def init_conv1d(self, layer):
                 layer.set_attr('strategy', 'resource')
             else:
                 self.set_closest_reuse_factor(layer, n_in, n_out, include_max_rf=False)
-                layer.set_attr('strategy', 'unrolled')
+                layer.set_attr('strategy', 'resource_unrolled')
         else:
             layer.set_attr('strategy', 'latency')
 
@@ -418,17 +418,17 @@ def init_conv2d(self, layer):
             self.set_target_reuse_factor(layer)
             n_in, n_out = self.get_layer_mult_size(layer)
             self.set_closest_reuse_factor(layer, n_in, n_out)
-        elif layer.model.config.get_strategy(layer).lower() == 'unrolled':
+        elif layer.model.config.get_strategy(layer).lower() == 'resource_unrolled':
             use_resource_instead = False
             if layer.get_attr('reuse_factor', 1) == 1:
                 print(
-                    f'Unrolled strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
+                    f'Unrolled resource strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
             elif layer.model.config.get_config_value('IOType') == 'io_parallel':
                 print(
-                    f'Unrolled strategy cannot be combined with io_parallel in layer "{layer.name}". '
+                    f'Unrolled resource strategy cannot be combined with io_parallel in layer "{layer.name}". '
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
@@ -439,7 +439,7 @@ def init_conv2d(self, layer):
                 layer.set_attr('strategy', 'resource')
             else:
                 self.set_closest_reuse_factor(layer, n_in, n_out, include_max_rf=False)
-                layer.set_attr('strategy', 'unrolled')
+                layer.set_attr('strategy', 'resource_unrolled')
         else:
             layer.set_attr('strategy', 'latency')
 
@@ -563,11 +563,11 @@ def init_lstm(self, layer):
             self.set_closest_reuse_factor(layer, n_in, n_out)
             self.set_closest_reuse_factor(layer, n_in_recr, n_out_recr, attribute='recurrent_reuse_factor')
             layer.set_attr('strategy', 'resource')
-        elif layer.model.config.get_strategy(layer).lower() == 'unrolled':
+        elif layer.model.config.get_strategy(layer).lower() == 'resource_unrolled':
             use_resource_instead = False
             if layer.get_attr('reuse_factor', 1) == 1:
                 print(
-                    f'Unrolled strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
+                    f'Unrolled resource strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
@@ -581,7 +581,7 @@ def init_lstm(self, layer):
                 self.set_closest_reuse_factor(
                     layer, n_in_recr, n_out_recr, attribute='recurrent_reuse_factor', include_max_rf=False
                 )
-                layer.set_attr('strategy', 'unrolled')
+                layer.set_attr('strategy', 'resource_unrolled')
         else:
             layer.set_attr('strategy', 'latency')
 
@@ -597,11 +597,11 @@ def init_gru(self, layer):
             self.set_closest_reuse_factor(layer, n_in, n_out)
             self.set_closest_reuse_factor(layer, n_in_recr, n_out_recr, attribute='recurrent_reuse_factor')
             layer.set_attr('strategy', 'resource')
-        elif layer.model.config.get_strategy(layer).lower() == 'unrolled':
+        elif layer.model.config.get_strategy(layer).lower() == 'resource_unrolled':
             use_resource_instead = False
             if layer.get_attr('reuse_factor', 1) == 1:
                 print(
-                    f'Unrolled strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
+                    f'Unrolled resource strategy cannot be combined with reuse factor 1 in layer "{layer.name}". '
                     'Using "resource" strategy instead.'
                 )
                 use_resource_instead = True
@@ -615,7 +615,7 @@ def init_gru(self, layer):
                 self.set_closest_reuse_factor(
                     layer, n_in_recr, n_out_recr, attribute='recurrent_reuse_factor', include_max_rf=False
                 )
-                layer.set_attr('strategy', 'unrolled')
+                layer.set_attr('strategy', 'resource_unrolled')
         else:
             layer.set_attr('strategy', 'latency')
 
diff --git a/hls4ml/model/graph.py b/hls4ml/model/graph.py
@@ -10,6 +10,7 @@
 from hls4ml.model.flow import get_flow
 from hls4ml.model.layers import layer_map
 from hls4ml.model.optimizer import get_available_passes, optimize_model
+from hls4ml.utils.string_utils import convert_to_snake_case
 
 
 class HLSConfig:
@@ -35,7 +36,7 @@ def __init__(self, config):
         self.layer_type_targ_cycles = {}
         self.layer_name_targ_cycles = {}
 
-        self.model_strategy = 'Latency'
+        self.model_strategy = convert_to_snake_case('Latency')
         self.layer_type_strategy = {}
         self.layer_name_strategy = {}
 
@@ -217,7 +218,7 @@ def parse_name_config(self, layer_name, layer_cfg):
 
         strategy = layer_cfg.get('Strategy')
         if strategy is not None:
-            self.layer_name_strategy[layer_name.lower()] = strategy
+            self.layer_name_strategy[layer_name.lower()] = convert_to_snake_case(strategy)
 
         conv_implementation = layer_cfg.get('ConvImplementation')
         if conv_implementation is not None:
@@ -265,7 +266,7 @@ def _parse_hls_config(self):
             self.model_rf = model_cfg.get('ReuseFactor')
             self.model_targ_cycles = model_cfg.get('TargetCycles')
             self.model_conv_implementation = model_cfg.get('ConvImplementation', 'LineBuffer')
-            self.model_strategy = model_cfg.get('Strategy', 'Latency')
+            self.model_strategy = convert_to_snake_case(model_cfg.get('Strategy', 'Latency'))
             self.model_compression = bool(model_cfg.get('Compression', 0))
             self.pipeline_style = model_cfg.get('PipelineStyle', 'auto')
             self.pipeline_ii = model_cfg.get('PipelineInterval', None)
@@ -290,7 +291,7 @@ def _parse_hls_config(self):
 
                 strategy = layer_cfg.get('Strategy')
                 if strategy is not None:
-                    self.layer_type_strategy[layer_type.lower()] = strategy
+                    self.layer_type_strategy[layer_type.lower()] = convert_to_snake_case(strategy)
 
                 conv_implementation = layer_cfg.get('ConvImplementation')
                 if conv_implementation is not None:
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_common.h b/hls4ml/templates/vivado/nnet_utils/nnet_common.h
@@ -23,7 +23,7 @@ namespace nnet {
 
 // Common type definitions
 enum io_type { io_parallel = 0, io_stream };
-enum strategy { latency, resource, unrolled };
+enum strategy { latency, resource, resource_unrolled };
 
 /* ---
  * Balanced tree reduce implementation.
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv1d_stream.h
@@ -60,7 +60,7 @@ void conv_1d_buffer_cl(hls::stream<data_T> &data, hls::stream<res_T> &res,
                        typename CONFIG_T::bias_t biases[CONFIG_T::n_filt]) {
     assert(CONFIG_T::pad_left == 0 && CONFIG_T::pad_right == 0);
 
-    if (CONFIG_T::strategy == nnet::unrolled && CONFIG_T::reuse_factor > 1) {
+    if (CONFIG_T::strategy == nnet::resource_unrolled && CONFIG_T::reuse_factor > 1) {
         #pragma HLS allocation instances=compute_output_buffer_1d limit=1 function
     }
 
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_conv2d_stream.h
@@ -75,7 +75,7 @@ void conv_2d_buffer_cl(
                                                                                     [CONFIG_T::n_chan];
     #pragma HLS ARRAY_PARTITION variable = line_buffer complete dim = 2
 
-    if (CONFIG_T::strategy == nnet::unrolled && CONFIG_T::reuse_factor > 1) {
+    if (CONFIG_T::strategy == nnet::resource_unrolled && CONFIG_T::reuse_factor > 1) {
         #pragma HLS allocation instances=compute_output_buffer_1d limit=1 function
         #pragma HLS allocation instances=compute_output_buffer_2d limit=1 function
     }
diff --git a/hls4ml/utils/string_utils.py b/hls4ml/utils/string_utils.py
@@ -10,7 +10,8 @@ def convert_to_snake_case(pascal_case):
     Returns:
         str: converted string
     """
-    return re.sub(r'(?<!^)(?=[A-Z])', '_', pascal_case).lower()
+    camel_case = re.sub(r'(?<!^)(?=[A-Z])', '_', pascal_case).lower()
+    return re.sub(r'_{2,}', '_', camel_case)  # Removes duplicate underscores
 
 
 def convert_to_pascal_case(snake_case):
diff --git a/test/pytest/test_dense_unrolled.py b/test/pytest/test_dense_unrolled.py
diff --git a/test/pytest/test_pipeline_style.py b/test/pytest/test_pipeline_style.py

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ def _register_flows(self):`
`16`	`16`	`validation_passes = [`
`17`	`17`	`'vitis:validate_conv_implementation',`
`18`	`18`	`'vitis:validate_resource_strategy',`
`19`		`- 'vitis:validate_unrolled_strategy',`
	`19`	`+ 'vitis:validate_resource_unrolled_strategy',`
`20`	`20`	`]`
`21`	`21`	`validation_flow = register_flow('validation', validation_passes, requires=['vivado:init_layers'], backend=self.name)`
`22`	`22`