oneAPI Accelerator

hls4ml/backends/__init__.py

@@ -2,6 +2,7 @@
 from hls4ml.backends.fpga.fpga_backend import FPGABackend  # noqa: F401
 from hls4ml.backends.libero.libero_backend import LiberoBackend
 from hls4ml.backends.oneapi.oneapi_backend import OneAPIBackend
+from hls4ml.backends.oneapi_accelerator.oneapi_accelerator_backend import OneAPIAcceleratorBackend
 from hls4ml.backends.plugin_loader import load_backend_plugins
 from hls4ml.backends.quartus.quartus_backend import QuartusBackend
 from hls4ml.backends.symbolic.symbolic_backend import SymbolicExpressionBackend
@@ -22,6 +23,7 @@ def _register_builtin_backends():
     register_backend('Catapult', CatapultBackend)
     register_backend('SymbolicExpression', SymbolicExpressionBackend)
     register_backend('oneAPI', OneAPIBackend)
+    register_backend('oneAPIAccelerator', OneAPIAcceleratorBackend)  # Can only be registered after oneAPI
     register_backend('Libero', LiberoBackend)
 
 

hls4ml/backends/oneapi/oneapi_backend.py

@@ -31,8 +31,8 @@
 
 
 class OneAPIBackend(FPGABackend):
-    def __init__(self):
-        super().__init__('oneAPI')
+    def __init__(self, name='oneAPI'):  # the default name should be used in most cases
+        super().__init__(name)
         self._register_layer_attributes()
         self._register_flows()
 
@@ -145,7 +145,14 @@ def get_writer_flow(self):
         return self._writer_flow
 
     def create_initial_config(
-        self, part='Agilex7', clock_period=5, hyperopt_handshake=False, io_type='io_parallel', write_tar=False, **_
+        self,
+        part='Agilex7',
+        clock_period=5,
+        hyperopt_handshake=False,
+        io_type='io_parallel',
+        max_parallel=10,
+        write_tar=False,
+        **_,
     ):
         """Create initial configuration of the oneAPI backend.
 
@@ -155,6 +162,7 @@ def create_initial_config(
             hyperopt_handshake (bool, optional): Should hyper-optimized handshaking be used? Defaults to False
             io_type (str, optional): Type of implementation used. One of
                 'io_parallel' or 'io_stream'. Defaults to 'io_parallel'.
+            max_parallel(int, optional): The maximum invocations (events) processed in parallel, io_stream only.
             write_tar (bool, optional): If True, compresses the output directory into a .tar.gz file. Defaults to False.
 
         Returns:
@@ -167,6 +175,7 @@ def create_initial_config(
         config['ClockPeriod'] = clock_period
         config['HyperoptHandshake'] = hyperopt_handshake
         config['IOType'] = io_type
+        config['MaxParallelInvocations'] = max_parallel
         config['HLSConfig'] = {}
         config['WriterConfig'] = {
             # TODO:  add namespace

hls4ml/backends/oneapi/oneapi_template.py

@@ -52,8 +52,8 @@ def _default_function_params(self, layer):
         params = self._default_params(layer)
         params['name'] = layer.name
         params['config'] = f'config{layer.index}'
-        params['input_pipe'] = layer.get_input_variable().pipe_name
-        params['output_pipe'] = layer.get_output_variable().pipe_name
+        params['input_pipe'] = layer.get_input_variable(layer.inputs[0]).pipe_name
+        params['output_pipe'] = layer.get_output_variable(layer.outputs[0]).pipe_name
 
         return params
 

hls4ml/backends/oneapi/passes/bn_quant.py

@@ -33,7 +33,8 @@
 bn_include_list = ['nnet_utils/nnet_batchnorm.h', 'nnet_utils/nnet_batchnorm_stream.h']
 
 batchnorm_quantized_tanh_task_sequence_template = (
-    'task_sequence<nnet::normalize_{quantize}_tanh_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::normalize_{quantize}_tanh_stream<{input_pipe}, {output_pipe}, {config}>, '
+    'MAX_INVOC, MAX_INVOC> {name};'
 )
 
 batchnorm_quantized_tanh_stream_function_template = '{name}.async({threshold});'

hls4ml/backends/oneapi/passes/clone_templates.py

@@ -17,7 +17,9 @@ def format(self, node):
 
         output_pipes = ', '.join([f'{{output{i + 1}_pipe}}' for i in range(len(node.outputs))])
 
-        template = f'task_sequence<nnet::clone_stream<{{input_pipe}}, {output_pipes}, {{size}}>> {{name}};'
+        template = (
+            f'task_sequence<nnet::clone_stream<{{input_pipe}}, {output_pipes}, {{size}}>, MAX_INVOC, MAX_INVOC> {{name}};'
+        )
         return template.format(**params)
 
 

hls4ml/backends/oneapi/passes/convolution_templates.py

@@ -62,7 +62,7 @@
 conv1d_function_template = 'nnet::conv_1d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
 
 conv1d_task_sequence_template = (
-    'task_sequence<nnet::conv_1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::conv_1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
 )
 
 conv_stream_function_template = '{name}.async({w}, {b});'
@@ -192,7 +192,7 @@ def __init__(self):
 conv2d_function_template = 'nnet::conv_2d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
 
 conv2d_task_sequence_template = (
-    'task_sequence<nnet::conv_2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::conv_2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
 )
 
 conv2d_include_list = ['nnet_utils/nnet_conv2d.h', 'nnet_utils/nnet_conv2d_stream.h']

hls4ml/backends/oneapi/passes/core_templates.py

@@ -35,7 +35,9 @@
 }};\n"""
 
 dense_function_template = 'nnet::dense_{strategy}<{input_t}, {output_t}, {config}>({input}, {output}, {w}, {b});'
-dense_task_sequence_template = 'task_sequence<nnet::dense_{strategy}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+dense_task_sequence_template = (
+    'task_sequence<nnet::dense_{strategy}_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 dense_stream_function_template = '{name}.async({w}, {b});'
 dense_include_list = ['nnet_utils/nnet_dense.h', 'nnet_utils/nnet_dense_stream.h']
 
@@ -108,7 +110,9 @@ def format(self, node):
 }};\n"""
 
 batchnorm_function_template = 'nnet::normalize<{input_t}, {output_t}, {config}>({input}, {output}, {scale}, {bias});'
-batchnorm_task_sequence_template = 'task_sequence<nnet::normalize_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+batchnorm_task_sequence_template = (
+    'task_sequence<nnet::normalize_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 batchnorm_stream_function_template = '{name}.async({scale}, {bias});'
 batchnorm_include_list = ['nnet_utils/nnet_batchnorm.h', 'nnet_utils/nnet_batchnorm_stream.h']
 
@@ -205,7 +209,9 @@ def format(self, node):
 activ_function_template = 'nnet::{activation}<{input_t}, {output_t}, {config}>({input}, {output});'
 param_activ_function_template = 'nnet::{activation}<{input_t}, {output_t}, {config}>({input}, {param}, {output});'
 
-activ_task_sequence_template = 'task_sequence<nnet::{activation}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+activ_task_sequence_template = (
+    'task_sequence<nnet::{activation}_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 activ_stream_function_template = '{name}.async();'
 param_activ_stream_function_template = '{name}.async({param});'
 

hls4ml/backends/oneapi/passes/embedding_templates.py

@@ -5,7 +5,9 @@
 from hls4ml.backends.oneapi.oneapi_template import StreamFunctionCallTemplate, TaskSequenceTemplate
 from hls4ml.model.layers import Embedding
 
-embed_task_sequence_template = 'task_sequence<nnet::embedding_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+embed_task_sequence_template = (
+    'task_sequence<nnet::embedding_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 embed_stream_function_template = '{name}.async({e});'
 
 

hls4ml/backends/oneapi/passes/merge_templates.py

@@ -16,7 +16,8 @@
 merge_function_template = 'nnet::{merge}<{input1_t}, {input2_t}, {output_t}, {config}>({input1}, {input2}, {output});'
 
 merge_task_sequence_template = (
-    'task_sequence<nnet::{merge}_stream<{input1_pipe}, {input2_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::{merge}_stream<{input1_pipe}, {input2_pipe}, {output_pipe}, {config}>, '
+    'MAX_INVOC, MAX_INVOC> {name};'
 )
 
 merge_stream_function_template = '{name}.async();'

hls4ml/backends/oneapi/passes/pointwise.py

@@ -24,11 +24,13 @@
 )
 
 pointwise_conv1d_task_sequence_template = (
-    'task_sequence<nnet::pintwise_conv_1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::pintwise_conv_1d_{data_format}_stream'
+    '<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
 )
 
 pointwise_conv2d_task_sequence_template = (
-    'task_sequence<nnet::pintwise_conv_2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::pintwise_conv_2d_{data_format}_stream'
+    '<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
 )
 
 pointwise_conv_stream_function_template = '{name}.async({w}, {b});'

hls4ml/backends/oneapi/passes/pooling_templates.py

@@ -75,18 +75,22 @@
 )
 
 pooling1d_task_sequence_template = (
-    'task_sequence<nnet::pooling1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>>({name});'
+    'task_sequence<nnet::pooling1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>, '
+    'MAX_INVOC, MAX_INVOC>({name});'
 )
 pooling2d_task_sequence_template = (
-    'task_sequence<nnet::pooling2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>>({name});'
+    'task_sequence<nnet::pooling2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>, '
+    'MAX_INVOC, MAX_INVOC>({name});'
 )
+
 global_pooling1d_task_sequence_template = (
-    'task_sequence<nnet::global_pooling1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>>({name});'
+    'task_sequence<nnet::global_pooling1d_{data_format}_stream'
+    '<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC>({name});'
 )
 global_pooling2d_task_sequence_template = (
-    'task_sequence<nnet::global_pooling2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>>({name});'
+    'task_sequence<nnet::global_pooling2d_{data_format}_stream'
+    '<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC>({name});'
 )
-
 pooling_stream_function_template = '{name}.async();'
 
 pooling_include_list = ['nnet_utils/nnet_pooling.h', 'nnet_utils/nnet_pooling_stream.h']

hls4ml/backends/oneapi/passes/recurrent_templates.py

@@ -100,7 +100,9 @@
 gru_function_initial_state_template = (
     'nnet::gru_init_state<{input_t}, {h_t}, {output_t}, {config}>({input}, {init_state}, {output}, {w}, {wr}, {b}, {br});'
 )
-gru_task_sequence_template = 'task_sequence<nnet::gru_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+gru_task_sequence_template = (
+    'task_sequence<nnet::gru_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 gru_stream_function_template = '{name}.async({w}, {wr}, {b}, {br});'
 
 

hls4ml/backends/oneapi/passes/reshaping_templates.py

@@ -33,10 +33,12 @@
 zeropad2d_function_template = 'nnet::zeropad2d_{data_format}<{input_t}, {output_t}, {config}>({input}, {output});'
 
 zeropad1d_task_sequence_template = (
-    'task_sequence<nnet::zeropad1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::zeropad1d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>, '
+    'MAX_INVOC, MAX_INVOC> {name};'
 )
 zeropad2d_task_sequence_template = (
-    'task_sequence<nnet::zeropad2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::zeropad2d_{data_format}_stream<{input_pipe}, {output_pipe}, {config}>, '
+    'MAX_INVOC, MAX_INVOC> {name};'
 )
 
 reshaping_stream_function_template = '{name}.async();'
@@ -116,7 +118,7 @@ def format(self, node):
 
 resize_function_template = 'nnet::resize_{algorithm}<{input_t}, {output_t}, {config}>({input}, {output});'
 resize_task_sequence_template = (
-    'task_sequence<nnet::resize_{algorithm}_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+    'task_sequence<nnet::resize_{algorithm}_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
 )
 resize_include_list = ['nnet_utils/nnet_resize.h', 'nnet_utils/nnet_resize_stream.h']
 
@@ -172,7 +174,9 @@ def format(self, node):
 }};\n"""
 
 transpose_function_template = 'nnet::transpose<{input_t}, {output_t}, {config}>({input}, {output});'
-transpose_task_sequence_template = 'task_sequence<nnet::transpose_stream<{input_pipe}, {output_pipe}, {config}>> {name};'
+transpose_task_sequence_template = (
+    'task_sequence<nnet::transpose_stream<{input_pipe}, {output_pipe}, {config}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 transpose_include_list = ['nnet_utils/nnet_transpose.h', 'nnet_utils/nnet_transpose_stream.h']
 
 
@@ -215,7 +219,9 @@ def format(self, node):
 
 
 # Reshape template (only used in streaming)
-reshape_task_sequence_template = 'task_sequence<nnet::repack_stream<{input_pipe}, {output_pipe}, {size}>> {name};'
+reshape_task_sequence_template = (
+    'task_sequence<nnet::repack_stream<{input_pipe}, {output_pipe}, {size}>, MAX_INVOC, MAX_INVOC> {name};'
+)
 reshape_include_list = ['nnet_utils/nnet_stream.h']
 
 

hls4ml/backends/oneapi_accelerator/oneapi_accelerator_backend.py

@@ -0,0 +1,68 @@
+from hls4ml.backends import OneAPIBackend
+from hls4ml.model.flow import register_flow
+
+
+class OneAPIAcceleratorBackend(OneAPIBackend):
+    """
+    This is the backend to run oneAPI code on an accelerator using the oneAPI framework.
+    """
+
+    def __init__(self):
+        super().__init__(name='oneAPIAccelerator')
+
+    def _register_flows(self):
+        writer_passes = ['make_stamp', 'oneapiaccelerator:write_hls']
+        self._writer_flow = register_flow('write', writer_passes, requires=['oneapi:ip'], backend=self.name)
+
+        oneapi_types = [
+            'oneapiaccelerator:transform_types',
+            'oneapi:register_bram_weights',
+            'oneapi:apply_resource_strategy',
+            'oneapi:apply_winograd_kernel_transformation',
+        ]
+        oneapi_types_flow = register_flow('specific_types', oneapi_types, requires=['oneapi:init_layers'], backend=self.name)
+
+        streaming_passes = [
+            'oneapi:clone_output',
+            'oneapiaccelerator:extract_sideband',
+            'oneapiaccelerator:merge_sideband',
+        ]
+        streaming_flow = register_flow('streaming', streaming_passes, requires=['oneapi:init_layers'], backend=self.name)
+
+        template_flow = register_flow(
+            'apply_templates', self._get_layer_templates, requires=['oneapi:init_layers'], backend=self.name
+        )
+
+        accel_flow_requirements = [
+            'optimize',
+            'oneapi:init_layers',
+            streaming_flow,
+            'oneapi:quantization',
+            'oneapi:optimize',
+            oneapi_types_flow,
+            template_flow,
+        ]
+
+        accel_flow_requirements = list(filter(None, accel_flow_requirements))
+        self._default_flow = register_flow('accel', None, requires=accel_flow_requirements, backend=self.name)
+
+    def create_initial_config(
+        self, part, clock_period=5, hyperopt_handshake=False, io_type='io_parallel', max_parallel=10, write_tar=False, **_
+    ):
+        """Create initial configuration of the oneAPI backend.
+
+        Args:
+            part (str): The path to the board support package to be used. Can add :<board-variant>
+            clock_period (int, optional): The clock period in ns. Defaults to 5.
+            hyperopt_handshake (bool, optional): Should hyper-optimized handshaking be used? Defaults to False
+            io_type (str, optional): Type of implementation used. One of
+                'io_parallel' or 'io_stream'. Defaults to 'io_parallel'.
+            max_parallel(int, optional): The maximum invocations (events) processed in parallel, io_stream only.
+            write_tar (bool, optional): If True, compresses the output directory into a .tar.gz file. Defaults to False.
+
+        Returns:
+            dict: initial configuration.
+        """
+        config = super().create_initial_config(part, clock_period, hyperopt_handshake, io_type, max_parallel, write_tar, **_)
+        config['UseOneAPIBSP'] = True
+        return config

hls4ml/backends/oneapi_accelerator/oneapi_accelerator_layers.py

@@ -0,0 +1,33 @@
+from hls4ml.model.attributes import Attribute
+from hls4ml.model.layers import Layer, register_layer
+
+SIDEBAND_SHAPE = 2
+
+
+class SidebandExtraction(Layer):
+    """This layer extract the sideband and sends it to a different strem"""
+
+    _expected_attributes = [Attribute('n_in')]
+
+    def initialize(self):
+        inp = self.get_input_variable()
+        self.set_attr('n_in', inp.size())
+        self.add_output_variable(inp.shape, precision=inp.type.precision)
+
+
+class SidebandMerging(Layer):
+    """This layer gets the sideband from a different input and merges it"""
+
+    _expected_attributes = [
+        Attribute('n_in'),
+    ]
+
+    def initialize(self):
+        inp = self.get_input_variable()
+        self.set_attr('n_in', inp.size())
+        self.add_output_variable(inp.shape, precision=inp.type.precision)
+
+
+# register the layers
+register_layer('SidebandExtraction', SidebandExtraction)
+register_layer('SidebandMerging', SidebandMerging)