First working concept: check ReLU operator

include/aidge/backend/cpu/operator/AddImpl.hpp

@@ -26,10 +26,10 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class AddImplForward_cpu
-    : public Registrable<AddImplForward_cpu, std::tuple<DataType, DataType>, void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)> {};
+    : public Registrable<AddImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>> {};
 
 class AddImplBackward_cpu
-    : public Registrable<AddImplBackward_cpu, std::tuple<DataType, DataType>, void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)> {};
+    : public Registrable<AddImplBackward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>> {};
 
 
 class AddImpl_cpu : public OperatorImpl {
@@ -40,7 +40,7 @@ public:
         return std::make_unique<AddImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp

@@ -30,19 +30,19 @@ namespace Aidge {
 class AvgPoolingImpl2DForward_cpu
     : public Registrable<AvgPoolingImpl2DForward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const std::array<DimSize_t, 2>&,
+                        std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 4>&,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class AvgPoolingImpl2DBackward_cpu
     : public Registrable<AvgPoolingImpl2DBackward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const std::array<DimSize_t, 2>&,
+                        std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 4>&,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class AvgPoolingImpl2D_cpu : public OperatorImpl {
 public:
@@ -52,7 +52,7 @@ public:
         return std::make_unique<AvgPoolingImpl2D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/BatchNormImpl.hpp

@@ -30,7 +30,7 @@ namespace Aidge {
 class BatchNormImpl2DForward_cpu
     : public Registrable<BatchNormImpl2DForward_cpu,
                          std::tuple<DataType, DataType, DataType>,
-                         void(float,
+                         std::function<void(float,
                             float,
                             const std::array<DimSize_t, 4> &,
                             const void *,
@@ -39,11 +39,11 @@ class BatchNormImpl2DForward_cpu
                             void *,
                             void *,
                             void *,
-                            const bool)> {};
+                            const bool)>> {};
 class BatchNormImpl2DBackward_cpu
     : public Registrable<BatchNormImpl2DBackward_cpu,
                          std::tuple<DataType, DataType, DataType>,
-                         void(float,
+                         std::function<void(float,
                             float,
                             const std::array<DimSize_t, 4> &,
                             const void *,
@@ -51,7 +51,7 @@ class BatchNormImpl2DBackward_cpu
                             const void *,
                             void *,
                             void *,
-                            void *)> {};
+                            void *)>> {};
 
 class BatchNormImpl2D_cpu : public OperatorImpl {
 public:
@@ -61,7 +61,7 @@ public:
         return std::make_unique<BatchNormImpl2D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp

@@ -29,14 +29,14 @@ namespace Aidge {
 class ConvDepthWiseImpl1DForward_cpu
     : public Registrable<ConvDepthWiseImpl1DForward_cpu,
                          std::tuple<DataType, DataType, DataType, DataType>,
-                         void(const std::array<DimSize_t, 1>&,
+                         std::function<void(const std::array<DimSize_t, 1>&,
                             const std::array<DimSize_t, 1>&,
                             const std::array<DimSize_t, 1>&,
                             const std::array<DimSize_t, 3>&,
                             const void *,
                             const void *,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class ConvDepthWiseImpl1D_cpu : public OperatorImpl {
 public:
@@ -46,7 +46,7 @@ public:
         return std::make_unique<ConvDepthWiseImpl1D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 
@@ -59,18 +59,18 @@ static Registrar<ConvDepthWise_Op<1>> registrarConvDepthWiseImpl1D_cpu("cpu", Ai
 class ConvDepthWiseImpl2DForward_cpu
     : public Registrable<ConvDepthWiseImpl2DForward_cpu,
                          std::tuple<DataType, DataType, DataType, DataType>,
-                         void(const std::array<DimSize_t, 2>&,
+                         std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 4> &,
                             const void *,
                             const void *,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class ConvDepthWiseImpl2DBackward_cpu
     : public Registrable<ConvDepthWiseImpl2DBackward_cpu,
                          std::tuple<DataType, DataType, DataType, DataType>,
-                         void(const std::array<DimSize_t, 2>&,
+                         std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             bool,
@@ -78,7 +78,7 @@ class ConvDepthWiseImpl2DBackward_cpu
                             const void *,
                             const void *,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class ConvDepthWiseImpl2D_cpu : public OperatorImpl {
 public:
@@ -88,7 +88,7 @@ public:
         return std::make_unique<ConvDepthWiseImpl2D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/ConvImpl.hpp

@@ -31,7 +31,7 @@ namespace Aidge {
 class ConvImpl1DForward_cpu
     : public Registrable<ConvImpl1DForward_cpu,
                          std::tuple<DataType, DataType, DataType, DataType>,
-                         void(const std::array<DimSize_t, 1>&,
+                         std::function<void(const std::array<DimSize_t, 1>&,
                             const std::array<DimSize_t, 1>&,
                             const std::array<DimSize_t, 1>&,
                             const std::array<DimSize_t, 3> &,
@@ -39,7 +39,7 @@ class ConvImpl1DForward_cpu
                             const void *,
                             const void *,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class ConvImpl1D_cpu : public OperatorImpl {
    public:
@@ -50,7 +50,7 @@ class ConvImpl1D_cpu : public OperatorImpl {
     }
 
    public:
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 
@@ -63,7 +63,7 @@ static Registrar<Conv_Op<1>> registrarConvImpl1D_cpu("cpu", Aidge::ConvImpl1D_cp
 class ConvImpl2DForward_cpu
     : public Registrable<ConvImpl2DForward_cpu,
                          std::tuple<DataType, DataType, DataType, DataType>,
-                         void(const std::array<DimSize_t, 2>&,
+                         std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 4> &,
@@ -71,11 +71,11 @@ class ConvImpl2DForward_cpu
                             const void *,
                             const void *,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class ConvImpl2DBackward_cpu
     : public Registrable<ConvImpl2DBackward_cpu,
                          std::tuple<DataType, DataType, DataType, DataType>,
-                         void(const std::array<DimSize_t, 2>&,
+                         std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             bool,
@@ -83,7 +83,7 @@ class ConvImpl2DBackward_cpu
                             const void *,
                             const void *,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class ConvImpl2D_cpu : public OperatorImpl {
    public:
@@ -94,7 +94,7 @@ class ConvImpl2D_cpu : public OperatorImpl {
     }
 
    public:
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/DivImpl.hpp

@@ -25,11 +25,11 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class DivImplForward_cpu
-    // : public Registrable<DivImplForward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)> {
-    : public Registrable<DivImplForward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::size_t, const std::size_t, const std::size_t, const void*, const void*,void*)> {
+    // : public Registrable<DivImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>> {
+    : public Registrable<DivImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::size_t, const std::size_t, const std::size_t, const void*, const void*,void*)>> {
 };
 class DivImplBackward_cpu
-    : public Registrable<DivImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)> {
+    : public Registrable<DivImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)>> {
 };
 
 class DivImpl_cpu : public OperatorImpl {
@@ -40,7 +40,7 @@ public:
         return std::make_unique<DivImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
 
     void forward() override final;
 };

include/aidge/backend/cpu/operator/ErfImpl.hpp

@@ -24,10 +24,10 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class ErfImplForward_cpu
-    : public Registrable<ErfImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
+    : public Registrable<ErfImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
 };
 class ErfImplBackward_cpu
-    : public Registrable<ErfImplBackward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
+    : public Registrable<ErfImplBackward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
 };
 
 class ErfImpl_cpu : public OperatorImpl {
@@ -38,7 +38,7 @@ public:
         return std::make_unique<ErfImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/FCImpl.hpp

@@ -30,19 +30,19 @@ class FCImplForward_cpu : public Registrable<FCImplForward_cpu,
                                                         DataType,
                                                         DataType,
                                                         DataType>,
-                                             void(const DimSize_t,
+                                             std::function<void(const DimSize_t,
                                                 const DimSize_t,
                                                 const DimSize_t,
                                                 const void *,
                                                 const void *,
                                                 const void *,
-                                                void *)> {};
+                                                void *)>> {};
 class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu,
                                               std::tuple<DataType,
                                                          DataType,
                                                          DataType,
                                                          DataType>,
-                                              void(const DimSize_t,
+                                              std::function<void(const DimSize_t,
                                                 const DimSize_t,
                                                 const DimSize_t,
                                                 const void *,
@@ -50,7 +50,7 @@ class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu,
                                                 const void *,
                                                 void *,
                                                 void *,
-                                                void *)> {};
+                                                void *)>> {};
 
 class FCImpl_cpu : public OperatorImpl {
 public:

include/aidge/backend/cpu/operator/FoldImpl.hpp

@@ -27,13 +27,13 @@ namespace Aidge {
 class FoldImpl2DForward_cpu
     : public Registrable<FoldImpl2DForward_cpu,
                          std::tuple<DataType, DataType>,
-                         void(const std::array<DimSize_t, 2>&,
+                         std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const std::vector<DimSize_t> &,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class FoldImpl2D_cpu : public OperatorImpl {
 public:

include/aidge/backend/cpu/operator/GlobalAveragePoolingImpl.hpp

@@ -26,12 +26,12 @@ namespace Aidge {
 class GlobalAveragePoolingImplForward_cpu
     : public Registrable<
           GlobalAveragePoolingImplForward_cpu, std::tuple<DataType, DataType>,
-          void(const std::vector<DimSize_t> &, const void *, void *)> {};
+          std::function<void(const std::vector<DimSize_t> &, const void *, void *)>> {};
 
 class GlobalAveragePoolingImplBackward_cpu
     : public Registrable<
           GlobalAveragePoolingImplBackward_cpu, std::tuple<DataType, DataType>,
-          void(const std::vector<DimSize_t> &, const void *, void *)> {};
+          std::function<void(const std::vector<DimSize_t> &, const void *, void *)>> {};
 
 class GlobalAveragePoolingImpl_cpu : public OperatorImpl {
 public:

include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp

@@ -27,17 +27,17 @@ namespace Aidge {
 class LeakyReLUImplForward_cpu
     : public Registrable<LeakyReLUImplForward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const float,
+                        std::function<void(const float,
                             std::size_t,
                             const void*,
-                            void*)> {};
+                            void*)>> {};
 class LeakyReLUImplBackward_cpu
     : public Registrable<LeakyReLUImplBackward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const float,
+                        std::function<void(const float,
                             std::size_t,
                             const void*,
-                            void*)> {};
+                            void*)>> {};
 
 class LeakyReLUImpl_cpu : public OperatorImpl {
 public:
@@ -47,7 +47,7 @@ public:
         return std::make_unique<LeakyReLUImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
 
     void forward() override final;
 

include/aidge/backend/cpu/operator/LnImpl.hpp

@@ -25,10 +25,10 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class LnImplForward_cpu
-    : public Registrable<LnImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
+    : public Registrable<LnImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
 };
 class LnImplBackward_cpu
-    : public Registrable<LnImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::size_t, const void*, const void*, void*)> {
+    : public Registrable<LnImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::size_t, const void*, const void*, void*)>> {
 };
 
 class LnImpl_cpu : public OperatorImpl {
@@ -39,7 +39,7 @@ public:
         return std::make_unique<LnImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
 	
     void forward() override final;
 

include/aidge/backend/cpu/operator/MatMulImpl.hpp

@@ -26,12 +26,12 @@ namespace Aidge {
 
 class MatMulImplForward_cpu
     : public Registrable<MatMulImplForward_cpu, std::tuple<DataType, DataType>,
-                         void(const std::size_t, const std::size_t, const std::size_t,
-                              const void *, const void *, void *)> {};
+                         std::function<void(const std::size_t, const std::size_t, const std::size_t,
+                              const void *, const void *, void *)>> {};
 class MatMulImplBackward_cpu
     : public Registrable<MatMulImplBackward_cpu, std::tuple<DataType, DataType>,
-                         void(const std::vector<DimSize_t>&, const std::vector<DimSize_t>&,
-                              const void *, const void *, void *)> {};
+                         std::function<void(const std::vector<DimSize_t>&, const std::vector<DimSize_t>&,
+                              const void *, const void *, void *)>> {};
 
 class MatMulImpl_cpu : public OperatorImpl {
 public:

include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp

@@ -30,21 +30,21 @@ namespace Aidge {
 class MaxPoolingImpl2DForward_cpu
     : public Registrable<MaxPoolingImpl2DForward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const std::array<DimSize_t, 2>&,
+                        std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const bool,
                             const std::array<DimSize_t, 4> &,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class MaxPoolingImpl2DBackward_cpu
     : public Registrable<MaxPoolingImpl2DBackward_cpu,
                         std::tuple<DataType, DataType>,
-                        void(const std::array<DimSize_t, 2>&,
+                        std::function<void(const std::array<DimSize_t, 2>&,
                             const std::array<DimSize_t, 2>&,
                             const bool,
                             const std::array<DimSize_t, 4> &,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class MaxPoolingImpl2D_cpu : public OperatorImpl {
 public:
@@ -54,7 +54,7 @@ public:
         return std::make_unique<MaxPoolingImpl2D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/MulImpl.hpp

@@ -25,10 +25,10 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class MulImplForward_cpu
-    : public Registrable<MulImplForward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)> {
+    : public Registrable<MulImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>> {
 };
 class MulImplBackward_cpu
-    : public Registrable<MulImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)> {
+    : public Registrable<MulImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)>> {
 };
 
 class MulImpl_cpu : public OperatorImpl {
@@ -39,7 +39,7 @@ public:
         return std::make_unique<MulImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/OperatorImpl.hpp

+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CPU_OPERATOR_IMPL_H_
+#define AIDGE_CPU_OPERATOR_IMPL_H_
+
+#include <cstddef>  // std::size_t
+#include <memory>
+#include <tuple>    // std::tuple
+#include <vector>
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+template <class Op, class FwdFunc, class BwdFunc>
+class OperatorImpl_cpu : public OperatorImpl,
+    public Registrable<OperatorImpl_cpu<Op, FwdFunc, BwdFunc>, ImplSpec, Impl<FwdFunc, BwdFunc>>
+{
+public:
+    OperatorImpl_cpu(const Op& op) : OperatorImpl(op, "cpu") {}
+
+    static std::unique_ptr<OperatorImpl_cpu<Op, FwdFunc, BwdFunc>> create(const Op& op) {
+        return std::make_unique<OperatorImpl_cpu<Op, FwdFunc, BwdFunc>>(op);
+    }
+
+    virtual std::shared_ptr<ProdConso> getProdConso() const override {
+        const auto impl = Registrar<OperatorImpl_cpu>::create(getBestMatch(getRequiredSpec()));
+        return impl.prodConso(mOp);
+    }
+
+    virtual std::vector<ImplSpec> getAvailableImplSpecs() const override {
+        return Registrar<OperatorImpl_cpu>::getKeys();
+    }
+
+    void forward() override;
+    void backward() override;
+};
+}  // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_IMPL_H_ */

include/aidge/backend/cpu/operator/PadImpl.hpp

@@ -24,17 +24,23 @@
 #include "aidge/backend/cpu/data/GetCPUPtr.h"
 
 namespace Aidge {
+class Pad_ProdConso_cpu : public ProdConso {
+public:
+    Pad_ProdConso_cpu(const Operator& op): ProdConso(op) {}
+    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+};
+
 // class Pad_Op;
 // compute kernel registry for forward and backward
 class PadImpl1DForward_cpu
     : public Registrable<PadImpl1DForward_cpu,
                          std::tuple<DataType, DataType>,
-                         void(const std::array<DimSize_t, 2>&,
+                         std::function<void(const std::array<DimSize_t, 2>&,
                             const PadBorderType,
                             const double,
                             const std::array<DimSize_t, 3> &,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class PadImpl1D_cpu : public OperatorImpl {
 public:
@@ -44,7 +50,7 @@ public:
         return std::make_unique<PadImpl1D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<Pad_ProdConso_cpu>(mOp); };
     void forward() override;
 };
 
@@ -58,21 +64,21 @@ static Registrar<Pad_Op<1>> registrarPadImpl1D_cpu("cpu", Aidge::PadImpl1D_cpu::
 class PadImpl2DForward_cpu
     : public Registrable<PadImpl2DForward_cpu,
                          std::tuple<DataType, DataType>,
-                         void(const std::array<DimSize_t, 4>&,
+                         std::function<void(const std::array<DimSize_t, 4>&,
                             const PadBorderType,
                             const double,
                             const std::array<DimSize_t, 4> &,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 class PadImpl2DBackward_cpu
     : public Registrable<PadImpl2DBackward_cpu,
                          std::tuple<DataType, DataType>,
-                         void(const std::array<DimSize_t, 4>&,
+                         std::function<void(const std::array<DimSize_t, 4>&,
                             const PadBorderType,
                             const double,
                             const std::array<DimSize_t, 4> &,
                             const void *,
-                            void *)> {};
+                            void *)>> {};
 
 class PadImpl2D_cpu : public OperatorImpl {
 public:
@@ -82,7 +88,7 @@ public:
         return std::make_unique<PadImpl2D_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<Pad_ProdConso_cpu>(mOp); };
     void forward() override;
 };
 

include/aidge/backend/cpu/operator/PowImpl.hpp

@@ -25,10 +25,10 @@ namespace Aidge {
 
 // compute kernel registry for forward and backward
 class PowImplForward_cpu
-    : public Registrable<PowImplForward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)> {
+    : public Registrable<PowImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>> {
 };
 class PowImplBackward_cpu
-    : public Registrable<PowImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)> {
+    : public Registrable<PowImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)>> {
 };
 
 class PowImpl_cpu : public OperatorImpl {
@@ -39,7 +39,7 @@ public:
         return std::make_unique<PowImpl_cpu>(op);
     }
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+    std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
     void forward() override;
     void backward() override;
 };

include/aidge/backend/cpu/operator/ReLUImpl.hpp

@@ -17,39 +17,63 @@
 #include <tuple>    // std::tuple
 #include <vector>
 
-#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/backend/cpu/operator/OperatorImpl.hpp"
 #include "aidge/operator/ReLU.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
 
 namespace Aidge {
-// class ReLU_Op;
-
-// compute kernel registry for forward and backward
-class ReLUImplForward_cpu
-    : public Registrable<ReLUImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
-};
-class ReLUImplBackward_cpu
-    : public Registrable<ReLUImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::size_t, const void*, const void*, void*)> {
-};
-
-class ReLUImpl_cpu : public OperatorImpl {
-public:
-    ReLUImpl_cpu(const ReLU_Op& op) : OperatorImpl(op, "cpu") {}
-
-    static std::unique_ptr<ReLUImpl_cpu> create(const ReLU_Op& op) {
-        return std::make_unique<ReLUImpl_cpu>(op);
-    }
+using ReLUImpl_cpu = OperatorImpl_cpu<ReLU_Op,
+    void(const std::size_t, const void*, void*),
+    void(const std::size_t, const void*, const void*, void*)>;
+
+// class ReLUImpl_cpu : public OperatorImpl_cpu<ReLU_Op,
+//     void(const std::size_t, const void*, void*),
+//     void(const std::size_t, const void*, const void*, void*)>
+// {
+// public:
+//     void forward() override;
+//     void backward() override;
+// };
 
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+template <class I, class O>
+void ReLUImpl_cpu_forward_kernel(std::size_t inputLenght,
+                                     const void* input_,
+                                     void* output_) {
 
-    void forward() override final;
+    const I* input = static_cast<const I*>(input_);
+    O* output = static_cast<O*>(output_);
+
+//#pragma omp parallel for if (inputLenght > 1024)
+    for (std::size_t i = 0; i < inputLenght; ++i) {
+        output[i] = (input[i] > 0) ? input[i] : 0;
+    }
+}
 
-    void backward() override final;
-};
+template <class I, class GI, class GO>
+void ReLUImpl_cpu_backward_kernel(const std::size_t inputLenght,
+                                  const void* input_, const void* grad_output_,
+				  void* grad_input_) {
+    const I* input = static_cast<const I*>(input_);
+    const GO* grad_output = static_cast<const GO*>(grad_output_);
+    GI* grad_input = static_cast<GI*>(grad_input_);
+    for (std::size_t i = 0; i < inputLenght; ++i) {
+        grad_input[i] = (input[i] > 0) ? grad_output[i] : 0;
+    }
+}
 
 namespace {
 static Registrar<ReLU_Op> registrarReLUImpl_cpu("cpu", Aidge::ReLUImpl_cpu::create);
+
+static Registrar<ReLUImpl_cpu> registrarReLUImpl_cpu_float(
+    {DataType::Float32},
+    {ProdConso::inPlaceModel, Aidge::ReLUImpl_cpu_forward_kernel<float, float>, Aidge::ReLUImpl_cpu_backward_kernel<float, float, float>});
+static Registrar<ReLUImpl_cpu> registrarReLUImpl_cpu_double(
+    {DataType::Float64},
+    {ProdConso::inPlaceModel, Aidge::ReLUImpl_cpu_forward_kernel<double, double>, Aidge::ReLUImpl_cpu_backward_kernel<double, double, double>});
+static Registrar<ReLUImpl_cpu> registrarReLUImpl_cpu_int(
+    {DataType::Int32},
+    {ProdConso::inPlaceModel, Aidge::ReLUImpl_cpu_forward_kernel<int, int>, Aidge::ReLUImpl_cpu_backward_kernel<int, int, int>});
 }
 }  // namespace Aidge
 

include/aidge/backend/cpu/operator/ReLUImpl_backward_kernels.hpp

-/********************************************************************************
- * Copyright (c) 2023 CEA-List
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- ********************************************************************************/
-
-#ifndef AIDGE_CPU_OPERATOR_RELUIMPL_BACKWARD_KERNEL_H_
-#define AIDGE_CPU_OPERATOR_RELUIMPL_BACKWARD_KERNEL_H_
-
-#include <cstddef>  // std::size_t
-
-#include "aidge/backend/cpu/operator/ReLUImpl.hpp"
-#include "aidge/utils/Registrar.hpp"
-
-namespace Aidge {
-template <class I, class GI, class GO>
-void ReLUImpl_cpu_backward_kernel(const std::size_t inputLenght,
-                                  const void* input_, const void* grad_output_,
-				  void* grad_input_) {
-    const I* input = static_cast<const I*>(input_);
-    const GO* grad_output = static_cast<const GO*>(grad_output_);
-    GI* grad_input = static_cast<GI*>(grad_input_);
-    for (std::size_t i = 0; i < inputLenght; ++i) {
-        grad_input[i] = (input[i] > 0) ? grad_output[i] : 0;
-    }
-}
-
-namespace {
-static Registrar<ReLUImplBackward_cpu> registrarReLUImplBackward_cpu_Float32(
-    {DataType::Float32, DataType::Float32, DataType::Float32},
-    Aidge::ReLUImpl_cpu_backward_kernel<float, float, float>);
-static Registrar<ReLUImplBackward_cpu> registrarReLUImplBackward_cpu_Int32(
-    {DataType::Int32, DataType::Int32, DataType::Int32},
-    Aidge::ReLUImpl_cpu_backward_kernel<int, int, int>);
-static Registrar<ReLUImplBackward_cpu> registrarReLUImplBackward_cpu_Float64(
-    {DataType::Float64, DataType::Float64, DataType::Float64},
-    Aidge::ReLUImpl_cpu_backward_kernel<double, double, double>);
-}  // namespace
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_RELUIMPL_BACKWARD_KERNEL_H_ */