add support for cloning of 7 outputs (#58)

makoeppel · Marius Koppel · web-flow · commit 17787e80f43c · 2025-05-15T09:16:57.000+02:00
Co-authored-by: Marius Koppel &lt;makoppel@olhsw-07.cern.ch&gt;
diff --git a/hls4ml/backends/fpga/passes/clone.py b/hls4ml/backends/fpga/passes/clone.py
@@ -79,9 +79,9 @@ def transform(self, model, node):
             n_outputs = len(output_map[output]) + in_output
             if n_outputs == 1:
                 continue
-            if n_outputs > 6:
+            if n_outputs > 7:
                 msg = f'ERROR: Cloning output {output} of {node.class_name}\
-                      ({node.name}) more than 6 times not currently supported'
+                      ({node.name}) more than 7 times not currently supported'
                 raise ValueError(msg)
 
             out_var = node.get_output_variable(output)
diff --git a/hls4ml/templates/catapult/nnet_utils/nnet_stream.h b/hls4ml/templates/catapult/nnet_utils/nnet_stream.h
@@ -130,6 +130,31 @@ void clone_stream(ac_channel<data_T> &data, ac_channel<res_T> &res1, ac_channel<
     }
 }
 
+template <class data_T, class res_T, int N>
+void clone_stream(ac_channel<data_T> &data, ac_channel<res_T> &res1, ac_channel<res_T> &res2, ac_channel<res_T> &res3,
+                  ac_channel<res_T> &res4, ac_channel<res_T> &res5, ac_channel<res_T> &res6, ac_channel<res_T> &res7) {
+#ifndef __SYNTHESIS__
+    while (data.available(1))
+#endif
+    {
+        data_T in_data = data.read();
+        res_T out_data;
+
+    ClonePack:
+        for (int j = 0; j < data_T::size; j++) {
+            out_data[j] = in_data[j];
+        }
+
+        res1.write(out_data);
+        res2.write(out_data);
+        res3.write(out_data);
+        res4.write(out_data);
+        res5.write(out_data);
+        res6.write(out_data);
+        res7.write(out_data);
+    }
+}
+
 template <class data_T, class res_T, int N> void repack_stream(ac_channel<data_T> &data, ac_channel<res_T> &res) {
     if (data_T::size == res_T::size) {
         for (int i = 0; i < N / data_T::size; i++) {
diff --git a/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_stream.h b/hls4ml/templates/oneapi/firmware/nnet_utils/nnet_stream.h
@@ -170,6 +170,51 @@ void clone_stream() {
     }
 }
 
+template <class data_pipe, class res1_pipe, class res2_pipe, class res3_pipe, class res4_pipe, class res5_pipe,
+          class res6_pipe, class res7_pipe, int N>
+void clone_stream() {
+    using data_T = typename ExtractPipeType<data_pipe>::value_type;
+    using res1_T = typename ExtractPipeType<res1_pipe>::value_type;
+    using res2_T = typename ExtractPipeType<res2_pipe>::value_type;
+    using res3_T = typename ExtractPipeType<res3_pipe>::value_type;
+    using res4_T = typename ExtractPipeType<res4_pipe>::value_type;
+    using res5_T = typename ExtractPipeType<res5_pipe>::value_type;
+    using res6_T = typename ExtractPipeType<res6_pipe>::value_type;
+    using res7_T = typename ExtractPipeType<res7_pipe>::value_type;
+    constexpr auto datasize = std::tuple_size<data_T>{};
+CloneLoop:
+    [[intel::initiation_interval(1)]] for (int i = 0; i < N / datasize; i++) {
+        data_T in_data = data_pipe::read();
+        res1_T out_data1;
+        res2_T out_data2;
+        res3_T out_data3;
+        res4_T out_data4;
+        res5_T out_data5;
+        res6_T out_data6;
+        res7_T out_data7;
+
+    ClonePack:
+        #pragma unroll
+        for (int j = 0; j < datasize; j++) {
+            out_data1[j] = in_data[j];
+            out_data2[j] = in_data[j];
+            out_data3[j] = in_data[j];
+            out_data4[j] = in_data[j];
+            out_data5[j] = in_data[j];
+            out_data6[j] = in_data[j];
+            out_data7[j] = in_data[j];
+        }
+
+        res1_pipe::write(out_data1);
+        res2_pipe::write(out_data2);
+        res3_pipe::write(out_data3);
+        res4_pipe::write(out_data4);
+        res5_pipe::write(out_data5);
+        res6_pipe::write(out_data6);
+        res6_pipe::write(out_data7);
+    }
+}
+
 template <class data_pipe, class res_pipe, int N> void repack_stream() {
     using data_T = typename ExtractPipeType<data_pipe>::value_type;
     using res_T = typename ExtractPipeType<res_pipe>::value_type;
diff --git a/hls4ml/templates/quartus/firmware/nnet_utils/nnet_stream.h b/hls4ml/templates/quartus/firmware/nnet_utils/nnet_stream.h
@@ -150,6 +150,43 @@ void clone_stream(stream<data_T> &data, stream<res_T> &res1, stream<res_T> &res2
     }
 }
 
+template <class data_T, class res_T, int N>
+void clone_stream(stream<data_T> &data, stream<res_T> &res1, stream<res_T> &res2, stream<res_T> &res3, stream<res_T> &res4,
+                  stream<res_T> &res5, stream<res_T> &res6, stream<res_T> &res7) {
+CloneLoop:
+    #pragma ii 1
+    for (int i = 0; i < N / data_T::size; i++) {
+        data_T in_data = data.read();
+        res_T out_data1;
+        res_T out_data2;
+        res_T out_data3;
+        res_T out_data4;
+        res_T out_data5;
+        res_T out_data6;
+        res_T out_data7;
+
+    ClonePack:
+        #pragma unroll
+        for (int j = 0; j < data_T::size; j++) {
+            out_data1[j] = in_data[j];
+            out_data2[j] = in_data[j];
+            out_data3[j] = in_data[j];
+            out_data4[j] = in_data[j];
+            out_data5[j] = in_data[j];
+            out_data6[j] = in_data[j];
+            out_data7[j] = in_data[j];
+        }
+
+        res1.write(out_data1);
+        res2.write(out_data2);
+        res3.write(out_data3);
+        res4.write(out_data4);
+        res5.write(out_data5);
+        res6.write(out_data6);
+        res7.write(out_data7);
+    }
+}
+
 template <class data_T, class res_T, int N> void repack_stream(stream<data_T> &data, stream<res_T> &res) {
     if (data_T::size == res_T::size) {
         #pragma ii 1
diff --git a/hls4ml/templates/vivado/nnet_utils/nnet_stream.h b/hls4ml/templates/vivado/nnet_utils/nnet_stream.h
@@ -179,6 +179,51 @@ void clone_stream(hls::stream<data_T> &data, hls::stream<res_T> &res1, hls::stre
     }
 }
 
+template <class data_T, class res_T, int N>
+void clone_stream(hls::stream<data_T> &data, hls::stream<res_T> &res1, hls::stream<res_T> &res2, hls::stream<res_T> &res3,
+                  hls::stream<res_T> &res4, hls::stream<res_T> &res5, hls::stream<res_T> &res6, hls::stream<res_T> &res7) {
+CloneLoop:
+    for (int i = 0; i < N / data_T::size; i++) {
+        #pragma HLS PIPELINE
+
+        data_T in_data = data.read();
+        res_T out_data1;
+        res_T out_data2;
+        res_T out_data3;
+        res_T out_data4;
+        res_T out_data5;
+        res_T out_data6;
+        res_T out_data7;
+        PRAGMA_DATA_PACK(out_data1)
+        PRAGMA_DATA_PACK(out_data2)
+        PRAGMA_DATA_PACK(out_data3)
+        PRAGMA_DATA_PACK(out_data4)
+        PRAGMA_DATA_PACK(out_data5)
+        PRAGMA_DATA_PACK(out_data6)
+        PRAGMA_DATA_PACK(out_data7)
+
+    ClonePack:
+        for (int j = 0; j < data_T::size; j++) {
+            #pragma HLS UNROLL
+            out_data1[j] = in_data[j];
+            out_data2[j] = in_data[j];
+            out_data3[j] = in_data[j];
+            out_data4[j] = in_data[j];
+            out_data5[j] = in_data[j];
+            out_data6[j] = in_data[j];
+            out_data7[j] = in_data[j];
+        }
+
+        res1.write(out_data1);
+        res2.write(out_data2);
+        res3.write(out_data3);
+        res4.write(out_data4);
+        res5.write(out_data5);
+        res6.write(out_data6);
+        res7.write(out_data7);
+    }
+}
+
 template <class data_T, class res_T, int N> void repack_stream(hls::stream<data_T> &data, hls::stream<res_T> &res) {
     if (data_T::size == res_T::size) {
         for (int i = 0; i < N / data_T::size; i++) {
diff --git a/test/pytest/test_stream_clone.py b/test/pytest/test_stream_clone.py
@@ -22,11 +22,12 @@ def model_clone_precision_inheritance():
 
 @pytest.fixture(scope='module')
 def model_multi_clone():
-    # inp will be cloned 6 times
-    # a will be cloned 5 times
-    # ab will be cloned 4 times
-    # abac will be cloned 3 times
-    # abacabad will be cloned 2 times
+    # inp will be cloned 7 times
+    # a will be cloned 6 times
+    # ab will be cloned 5 times
+    # abac will be cloned 4 times
+    # abacabad will be cloned 3 times
+    # abacabadabacabae will be cloned 2 times
 
     inp = keras.Input(shape=(10,))
     a = Dense(10, name='dense_5_copies')(inp)
@@ -35,21 +36,28 @@ def model_multi_clone():
     d = Dense(10)(inp)
     e = Dense(10)(inp)
     f = Dense(10)(inp)
+    g = Dense(10)(inp)
     ab = Add(name='add_4_copies')([a, b])
     ac = Add()([a, c])
     ad = Add()([a, d])
     ae = Add()([a, e])
     af = Add()([a, f])
+    ag = Add()([a, g])
     abac = Add(name='add_3_copies')([ab, ac])
     abad = Add()([ab, ad])
     abae = Add()([ab, ae])
     abaf = Add()([ab, af])
+    abag = Add()([ab, ag])
     abacabad = Add(name='add_2_copies')([abac, abad])
     abacabae = Add()([abac, abae])
     abacabaf = Add()([abac, abaf])
+    abacabag = Add()([abac, abag])
     abacabadabacabae = Add()([abacabad, abacabae])
     abacabadabacabaf = Add()([abacabad, abacabaf])
-    out = Add()([abacabadabacabae, abacabadabacabaf])
+    abacabadabacabag = Add()([abacabad, abacabag])
+    abacabadabacabaeabacabadabacabaf = Add()([abacabadabacabae, abacabadabacabaf])
+    abacabadabacabaeabacabadabacabag = Add()([abacabadabacabae, abacabadabacabag])
+    out = Add()([abacabadabacabaeabacabadabacabaf, abacabadabacabaeabacabadabacabag])
     model = keras.Model(inp, out)
     return model
 
