Add operator implementation name to each operator

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

@@ -12,16 +12,17 @@
 #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_H_
 #define AIDGE_CPU_OPERATOR_ADDIMPL_H_
 
+#include <cstddef>  // std::size_t
+#include <memory>   // std::unique_ptr, std::make_unique
+#include <string>
+#include <vector>
+
 #include "aidge/backend/OperatorImpl.hpp"
 #include "aidge/operator/Add.hpp"
 #include "aidge/utils/Registrar.hpp"
 #include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-#include <memory>
-#include <vector>
 
 namespace Aidge {
-// class Add_Op<2>;
 
 // compute kernel registry for forward and backward
 class AddImplForward_cpu
@@ -33,7 +34,7 @@ class AddImplBackward_cpu
 
 class AddImpl_cpu : public OperatorImpl {
 public:
-    AddImpl_cpu(const Add_Op& op) : OperatorImpl(op) {}
+    AddImpl_cpu(const Add_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<AddImpl_cpu> create(const Add_Op& op) {
         return std::make_unique<AddImpl_cpu>(op);

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

@@ -38,7 +38,7 @@ class AvgPoolingImpl2DBackward_cpu
 
 class AvgPoolingImpl2D_cpu : public OperatorImpl {
 public:
-    AvgPoolingImpl2D_cpu(const AvgPooling_Op<2> &op) : OperatorImpl(op) {}
+    AvgPoolingImpl2D_cpu(const AvgPooling_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<AvgPoolingImpl2D_cpu> create(const AvgPooling_Op<2> &op) {
         return std::make_unique<AvgPoolingImpl2D_cpu>(op);

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

@@ -53,7 +53,7 @@ class BatchNormImpl2DBackward_cpu
 
 class BatchNormImpl2D_cpu : public OperatorImpl {
 public:
-    BatchNormImpl2D_cpu(const BatchNorm_Op<2> &op) : OperatorImpl(op) {}
+    BatchNormImpl2D_cpu(const BatchNorm_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<BatchNormImpl2D_cpu> create(const BatchNorm_Op<2> &op) {
         return std::make_unique<BatchNormImpl2D_cpu>(op);

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

@@ -41,7 +41,7 @@ class ConcatImplBackward_cpu
 
 class ConcatImpl_cpu : public OperatorImpl {
 public:
-    ConcatImpl_cpu(const Concat_Op& op) : OperatorImpl(op) {}
+    ConcatImpl_cpu(const Concat_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ConcatImpl_cpu> create(const Concat_Op& op) {
         return std::make_unique<ConcatImpl_cpu>(op);

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

@@ -40,7 +40,7 @@ class ConvDepthWiseImpl2DBackward_cpu
 
 class ConvDepthWiseImpl2D_cpu : public OperatorImpl {
 public:
-    ConvDepthWiseImpl2D_cpu(const ConvDepthWise_Op<2> &op) : OperatorImpl(op) {}
+    ConvDepthWiseImpl2D_cpu(const ConvDepthWise_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ConvDepthWiseImpl2D_cpu> create(const ConvDepthWise_Op<2> &op) {
         return std::make_unique<ConvDepthWiseImpl2D_cpu>(op);

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

@@ -40,7 +40,7 @@ class ConvImpl2DBackward_cpu
 
 class ConvImpl2D_cpu : public OperatorImpl {
    public:
-    ConvImpl2D_cpu(const Conv_Op<2>& op) : OperatorImpl(op) {}
+    ConvImpl2D_cpu(const Conv_Op<2>& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ConvImpl2D_cpu> create(const Conv_Op<2> &op) {
         return std::make_unique<ConvImpl2D_cpu>(op);

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

@@ -34,7 +34,7 @@ class DivImplBackward_cpu
 
 class DivImpl_cpu : public OperatorImpl {
 public:
-    DivImpl_cpu(const Div_Op& op) : OperatorImpl(op) {}
+    DivImpl_cpu(const Div_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<DivImpl_cpu> create(const Div_Op& op) {
         return std::make_unique<DivImpl_cpu>(op);

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

@@ -32,7 +32,7 @@ class ErfImplBackward_cpu
 
 class ErfImpl_cpu : public OperatorImpl {
 public:
-    ErfImpl_cpu(const Erf_Op& op) : OperatorImpl(op) {}
+    ErfImpl_cpu(const Erf_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ErfImpl_cpu> create(const Erf_Op& op) {
         return std::make_unique<ErfImpl_cpu>(op);

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

@@ -36,7 +36,7 @@ class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu,
 
 class FCImpl_cpu : public OperatorImpl {
 public:
-    FCImpl_cpu(const FC_Op &op) : OperatorImpl(op) {}
+    FCImpl_cpu(const FC_Op &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<FCImpl_cpu> create(const FC_Op &op) {
         return std::make_unique<FCImpl_cpu>(op);

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

@@ -32,7 +32,7 @@ class GatherImplBackward_cpu
 
 class GatherImpl_cpu : public OperatorImpl {
 public:
-    GatherImpl_cpu(const Gather_Op& op) : OperatorImpl(op) {}
+    GatherImpl_cpu(const Gather_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<GatherImpl_cpu> create(const Gather_Op& op) {
         return std::make_unique<GatherImpl_cpu>(op);

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

@@ -33,7 +33,7 @@ class LeakyReLUImplBackward_cpu
 
 class LeakyReLUImpl_cpu : public OperatorImpl {
 public:
-    LeakyReLUImpl_cpu(const LeakyReLU_Op& op) : OperatorImpl(op) {}
+    LeakyReLUImpl_cpu(const LeakyReLU_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<LeakyReLUImpl_cpu> create(const LeakyReLU_Op& op) {
         return std::make_unique<LeakyReLUImpl_cpu>(op);

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

@@ -35,7 +35,7 @@ class MatMulImplBackward_cpu
 
 class MatMulImpl_cpu : public OperatorImpl {
 public:
-    MatMulImpl_cpu(const MatMul_Op &op): OperatorImpl(op) {}
+    MatMulImpl_cpu(const MatMul_Op &op): OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MatMulImpl_cpu> create(const MatMul_Op &op) {
         return std::make_unique<MatMulImpl_cpu>(op);

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

@@ -38,7 +38,7 @@ class MaxPoolingImpl2DBackward_cpu
 
 class MaxPoolingImpl2D_cpu : public OperatorImpl {
 public:
-    MaxPoolingImpl2D_cpu(const MaxPooling_Op<2> &op) : OperatorImpl(op) {}
+    MaxPoolingImpl2D_cpu(const MaxPooling_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MaxPoolingImpl2D_cpu> create(const MaxPooling_Op<2> &op) {
         return std::make_unique<MaxPoolingImpl2D_cpu>(op);

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

@@ -23,7 +23,7 @@
 namespace Aidge {
 class MemorizeImpl_cpu : public OperatorImpl {
 public:
-    MemorizeImpl_cpu(const Memorize_Op& op) : OperatorImpl(op) {}
+    MemorizeImpl_cpu(const Memorize_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MemorizeImpl_cpu> create(const Memorize_Op& op) {
         return std::make_unique<MemorizeImpl_cpu>(op);

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

@@ -33,7 +33,7 @@ class MulImplBackward_cpu
 
 class MulImpl_cpu : public OperatorImpl {
 public:
-    MulImpl_cpu(const Mul_Op& op) : OperatorImpl(op) {}
+    MulImpl_cpu(const Mul_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<MulImpl_cpu> create(const Mul_Op& op) {
         return std::make_unique<MulImpl_cpu>(op);

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

@@ -40,7 +40,7 @@ class PadImpl2DBackward_cpu
 
 class PadImpl2D_cpu : public OperatorImpl {
 public:
-    PadImpl2D_cpu(const Pad_Op<2> &op) : OperatorImpl(op) {}
+    PadImpl2D_cpu(const Pad_Op<2> &op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<PadImpl2D_cpu> create(const Pad_Op<2> &op) {
         return std::make_unique<PadImpl2D_cpu>(op);

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

@@ -33,7 +33,7 @@ class PopImplBackward_cpu
 
 class PopImpl_cpu : public OperatorImpl {
 public:
-    PopImpl_cpu(const Pop_Op& op) : OperatorImpl(op) {}
+    PopImpl_cpu(const Pop_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<PopImpl_cpu> create(const Pop_Op& op) {
         return std::make_unique<PopImpl_cpu>(op);

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

@@ -33,7 +33,7 @@ class PowImplBackward_cpu
 
 class PowImpl_cpu : public OperatorImpl {
 public:
-    PowImpl_cpu(const Pow_Op& op) : OperatorImpl(op) {}
+    PowImpl_cpu(const Pow_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<PowImpl_cpu> create(const Pow_Op& op) {
         return std::make_unique<PowImpl_cpu>(op);

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

@@ -33,7 +33,7 @@ class ReLUImplBackward_cpu
 
 class ReLUImpl_cpu : public OperatorImpl {
 public:
-    ReLUImpl_cpu(const ReLU_Op& op) : OperatorImpl(op) {}
+    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);

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

@@ -57,7 +57,7 @@ class ReduceMeanImpl3DBackward_cpu
 
 class ReduceMeanImpl1D_cpu : public OperatorImpl {
    public:
-    ReduceMeanImpl1D_cpu(const ReduceMean_Op<1>& op) : OperatorImpl(op) {}
+    ReduceMeanImpl1D_cpu(const ReduceMean_Op<1>& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ReduceMeanImpl1D_cpu> create(const ReduceMean_Op<1> &op) {
         return std::make_unique<ReduceMeanImpl1D_cpu>(op);
@@ -70,7 +70,7 @@ class ReduceMeanImpl1D_cpu : public OperatorImpl {
 
 class ReduceMeanImpl2D_cpu : public OperatorImpl {
    public:
-    ReduceMeanImpl2D_cpu(const ReduceMean_Op<2>& op) : OperatorImpl(op) {}
+    ReduceMeanImpl2D_cpu(const ReduceMean_Op<2>& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ReduceMeanImpl2D_cpu> create(const ReduceMean_Op<2> &op) {
         return std::make_unique<ReduceMeanImpl2D_cpu>(op);
@@ -83,7 +83,7 @@ class ReduceMeanImpl2D_cpu : public OperatorImpl {
 
 class ReduceMeanImpl3D_cpu : public OperatorImpl {
    public:
-    ReduceMeanImpl3D_cpu(const ReduceMean_Op<3>& op) : OperatorImpl(op) {}
+    ReduceMeanImpl3D_cpu(const ReduceMean_Op<3>& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ReduceMeanImpl3D_cpu> create(const ReduceMean_Op<3> &op) {
         return std::make_unique<ReduceMeanImpl3D_cpu>(op);