diff --git a/include/aidge/backend/cpu/operator/AddImpl.hpp b/include/aidge/backend/cpu/operator/AddImpl.hpp
index 57669c628b4fa650f137c2b28c8c0a4584bf6c35..1d3b29d43678e8d97e05b9b169a98f7e757838d8 100644
--- a/include/aidge/backend/cpu/operator/AddImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp b/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
index bfb2b1947281fc30e38fd1fe1663bd5de415d3ee..1b62de7e145dfab02e78319600c1b30b29fd715b 100644
--- a/include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/BatchNormImpl.hpp b/include/aidge/backend/cpu/operator/BatchNormImpl.hpp
index a599aeb7b427161eb7541829242820c0306d0d31..3743c40a706156c45e6b1e7bf5dfdd50f40ed195 100644
--- a/include/aidge/backend/cpu/operator/BatchNormImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ConcatImpl.hpp b/include/aidge/backend/cpu/operator/ConcatImpl.hpp
index d0d3e06365c524da1af485583dda6d6208ef3fb9..559d5026d3b7430489ffb1cf08ef143df013c4c4 100644
--- a/include/aidge/backend/cpu/operator/ConcatImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
index f72890d8903ca4a9876809759587ed4b1ac22e67..470e189d3a9a8ce52dd067794cfd1bf6a7404696 100644
--- a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ConvImpl.hpp b/include/aidge/backend/cpu/operator/ConvImpl.hpp
index 9bc2f27412f388a7fd03db06ac97c612044fab5f..5e739b06118e788f716f6e5d6a41a58cab9b5203 100644
--- a/include/aidge/backend/cpu/operator/ConvImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/DivImpl.hpp b/include/aidge/backend/cpu/operator/DivImpl.hpp
index 710e288d8e0f95b69a2f4973679f1195e6d9cb6a..06a1ae49ffacf3fbf0ae923081d8d9cf1a5a40d6 100644
--- a/include/aidge/backend/cpu/operator/DivImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ErfImpl.hpp b/include/aidge/backend/cpu/operator/ErfImpl.hpp
index 5c0a6fd49f4e2d435eed8e8baa979f59dbd84e68..1402868ea5b8cb441c12dbefaad17304fdfdc749 100644
--- a/include/aidge/backend/cpu/operator/ErfImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/FCImpl.hpp b/include/aidge/backend/cpu/operator/FCImpl.hpp
index 86bb7fd1271e5857b595dda8efc0354851c94b7e..514cb999b3ecb3c935a773a3a356c7e8063ce3ad 100644
--- a/include/aidge/backend/cpu/operator/FCImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/GatherImpl.hpp b/include/aidge/backend/cpu/operator/GatherImpl.hpp
index 1d235ff14ca01955c268a7b061e6ecb7b2bbbb2a..fce777d0ac4d53134aa65689b6ac2ec02b805d98 100644
--- a/include/aidge/backend/cpu/operator/GatherImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp b/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp
index 4a1da034935e6b1f6c2069b4f91153b77a9f0636..40dcd3c8c4044efccbc81398f8df7095569402b9 100644
--- a/include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/MatMulImpl.hpp b/include/aidge/backend/cpu/operator/MatMulImpl.hpp
index 437ba404b1cc39973448f3c5567aec2fe35994e3..e4b76d64baadbcb1baa7d24180c4bb13ed47215b 100644
--- a/include/aidge/backend/cpu/operator/MatMulImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp b/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp
index 6cde34d9b123b4f83cbfce412ffa62e0144af8d4..15629b59b31f6f2228802861f6ae0d7d70b2bff9 100644
--- a/include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/MemorizeImpl.hpp b/include/aidge/backend/cpu/operator/MemorizeImpl.hpp
index 6569478001189b60795f21cf618c77c65aeefbfb..10d18d780e1e450d1a2c58faa932e9d851a41f19 100644
--- a/include/aidge/backend/cpu/operator/MemorizeImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/MulImpl.hpp b/include/aidge/backend/cpu/operator/MulImpl.hpp
index a6f63ba284baf4cc12190d6b96a89f0baa821c95..230094475088c6f7802f8a8af75986ded55e9137 100644
--- a/include/aidge/backend/cpu/operator/MulImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/PadImpl.hpp b/include/aidge/backend/cpu/operator/PadImpl.hpp
index 2320662710f9802878811e51ec4439bd812aea67..a1efb0f699beb7a45cc104e7c6ab723c1952a5b1 100644
--- a/include/aidge/backend/cpu/operator/PadImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/PopImpl.hpp b/include/aidge/backend/cpu/operator/PopImpl.hpp
index 86c20349d5554e400c15a6e3488cb547f86abee2..29272f5d759b5b39c6bfd704ab1e84b0777e33c5 100644
--- a/include/aidge/backend/cpu/operator/PopImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/PowImpl.hpp b/include/aidge/backend/cpu/operator/PowImpl.hpp
index c6e4cd36746141d7f1d1092c9bd45af41d8a9173..3d63160aee4a112d599effd6c16d39f4a6da7f6d 100644
--- a/include/aidge/backend/cpu/operator/PowImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ReLUImpl.hpp b/include/aidge/backend/cpu/operator/ReLUImpl.hpp
index 3338d0c40c057995fe37b1652966241bf4a96b59..71d2f175b6521581639bd4c0b419d7bc024d0a88 100644
--- a/include/aidge/backend/cpu/operator/ReLUImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp b/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp
index 9b85eb812caffca3820a711d46775e1134db863f..16c5c56de95aa342e83f318ea26c12d590248fd5 100644
--- a/include/aidge/backend/cpu/operator/ReduceMeanImpl.hpp
+++ b/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);
diff --git a/include/aidge/backend/cpu/operator/ReshapeImpl.hpp b/include/aidge/backend/cpu/operator/ReshapeImpl.hpp
index d5754b34e952d52b2071744e9f8e863074ef9fa3..d2d819e8d56df59437904aa9b4ae91185c8288f2 100644
--- a/include/aidge/backend/cpu/operator/ReshapeImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ReshapeImpl.hpp
@@ -32,7 +32,7 @@ class ReshapeImplBackward_cpu
 
 class ReshapeImpl_cpu : public OperatorImpl {
 public:
-    ReshapeImpl_cpu(const Reshape_Op& op) : OperatorImpl(op) {}
+    ReshapeImpl_cpu(const Reshape_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ReshapeImpl_cpu> create(const Reshape_Op& op) {
         return std::make_unique<ReshapeImpl_cpu>(op);
diff --git a/include/aidge/backend/cpu/operator/ScalingImpl.hpp b/include/aidge/backend/cpu/operator/ScalingImpl.hpp
index bbcb4553d7aa4b17d733e0f455373bebb9c3581c..088625e963b158811aad85665a25b68bf2892bb9 100644
--- a/include/aidge/backend/cpu/operator/ScalingImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ScalingImpl.hpp
@@ -34,7 +34,7 @@ class ScalingImplBackward_cpu
 
 class ScalingImpl_cpu : public OperatorImpl {
 public:
-    ScalingImpl_cpu(const Scaling_Op& op) : OperatorImpl(op) {}
+    ScalingImpl_cpu(const Scaling_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<ScalingImpl_cpu> create(const Scaling_Op& op) {
         return std::make_unique<ScalingImpl_cpu>(op);
diff --git a/include/aidge/backend/cpu/operator/SigmoidImpl.hpp b/include/aidge/backend/cpu/operator/SigmoidImpl.hpp
index 8678a5a56500ec9e37689df7a37ae72bfb3f74d4..f54a6c84aa83414cbe8a7a1713f36dd3311dda3f 100644
--- a/include/aidge/backend/cpu/operator/SigmoidImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SigmoidImpl.hpp
@@ -33,7 +33,7 @@ class SigmoidImplBackward_cpu
 
 class SigmoidImpl_cpu : public OperatorImpl {
 public:
-    SigmoidImpl_cpu(const Sigmoid_Op& op) : OperatorImpl(op) {}
+    SigmoidImpl_cpu(const Sigmoid_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<SigmoidImpl_cpu> create(const Sigmoid_Op& op) {
         return std::make_unique<SigmoidImpl_cpu>(op);
diff --git a/include/aidge/backend/cpu/operator/SliceImpl.hpp b/include/aidge/backend/cpu/operator/SliceImpl.hpp
index 1cba5906064c51a4f0da2f1f3682b0828a080d43..72d6105388924dc1553cbeba2124da66d804980f 100644
--- a/include/aidge/backend/cpu/operator/SliceImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SliceImpl.hpp
@@ -40,7 +40,7 @@ class SliceImplBackward_cpu
 
 class SliceImpl_cpu : public OperatorImpl {
 public:
-    SliceImpl_cpu(const Slice_Op& op) : OperatorImpl(op) {}
+    SliceImpl_cpu(const Slice_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<SliceImpl_cpu> create(const Slice_Op& op) {
         return std::make_unique<SliceImpl_cpu>(op);
diff --git a/include/aidge/backend/cpu/operator/SoftmaxImpl.hpp b/include/aidge/backend/cpu/operator/SoftmaxImpl.hpp
index 005b52f646f9e9ddf14af09cc22d9e2a44ba6dd4..9eb5323702358650f3af91b46a8a1a0872b02675 100644
--- a/include/aidge/backend/cpu/operator/SoftmaxImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SoftmaxImpl.hpp
@@ -33,7 +33,7 @@ class SoftmaxImplBackward_cpu
 
 class SoftmaxImpl_cpu : public OperatorImpl {
 public:
-    SoftmaxImpl_cpu(const Softmax_Op& op) : OperatorImpl(op) {}
+    SoftmaxImpl_cpu(const Softmax_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<SoftmaxImpl_cpu> create(const Softmax_Op& op) {
         return std::make_unique<SoftmaxImpl_cpu>(op);
diff --git a/include/aidge/backend/cpu/operator/SqrtImpl.hpp b/include/aidge/backend/cpu/operator/SqrtImpl.hpp
index b3723f27b077b9d5ea7e69fd33bd012d02654ffe..9bb3fe91835803030107169dfa30700c1d50aa3a 100644
--- a/include/aidge/backend/cpu/operator/SqrtImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SqrtImpl.hpp
@@ -33,7 +33,7 @@ class SqrtImplBackward_cpu
 
 class SqrtImpl_cpu : public OperatorImpl {
 public:
-    SqrtImpl_cpu(const Sqrt_Op& op) : OperatorImpl(op) {}
+    SqrtImpl_cpu(const Sqrt_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<SqrtImpl_cpu> create(const Sqrt_Op& op) {
         return std::make_unique<SqrtImpl_cpu>(op);
diff --git a/include/aidge/backend/cpu/operator/SubImpl.hpp b/include/aidge/backend/cpu/operator/SubImpl.hpp
index b329ec6eb0ed7f450b62cdbe289d69acf4f4edc4..2d957aa67b3061994f7fb2bf9550e4d5338d3967 100644
--- a/include/aidge/backend/cpu/operator/SubImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SubImpl.hpp
@@ -33,7 +33,7 @@ class SubImplBackward_cpu
 
 class SubImpl_cpu : public OperatorImpl {
 public:
-    SubImpl_cpu(const Sub_Op& op) : OperatorImpl(op) {}
+    SubImpl_cpu(const Sub_Op& op) : OperatorImpl(op, "cpu") {}
 
     static std::unique_ptr<SubImpl_cpu> create(const Sub_Op& op) {
         return std::make_unique<SubImpl_cpu>(op);