diff --git a/include/aidge/backend/cpu.hpp b/include/aidge/backend/cpu.hpp
index 13d2aae47491185e119a88dbf7a3527ba0420ac3..a1417de1517a8212b4b4308e5128a5ee3fce1e39 100644
--- a/include/aidge/backend/cpu.hpp
+++ b/include/aidge/backend/cpu.hpp
@@ -31,7 +31,6 @@
#include "aidge/backend/cpu/operator/ReLUImpl.hpp"
#include "aidge/backend/cpu/operator/ScalingImpl.hpp"
#include "aidge/backend/cpu/operator/SigmoidImpl.hpp"
-#include "aidge/backend/cpu/operator/SliceImpl.hpp"
#include "aidge/backend/cpu/operator/SqrtImpl.hpp"
#include "aidge/backend/cpu/operator/SoftmaxImpl.hpp"
#include "aidge/backend/cpu/operator/SubImpl.hpp"
diff --git a/include/aidge/backend/cpu/operator/SliceImpl.hpp b/include/aidge/backend/cpu/operator/SliceImpl.hpp
deleted file mode 100644
index 1583435c12a243ef5861299434a7fc1409307538..0000000000000000000000000000000000000000
--- a/include/aidge/backend/cpu/operator/SliceImpl.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/********************************************************************************
- * 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_SLICEIMPL_H_
-#define AIDGE_CPU_OPERATOR_SLICEIMPL_H_
-
-#include <memory>
-#include <vector>
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Slice.hpp"
-
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-
-namespace Aidge {
-// class Slice_Op;
-
-// compute kernel registry for forward and backward
-class SliceImplForward_cpu
- : public Registrable<SliceImplForward_cpu, std::tuple<DataType>,
- void(const typename Slice_Op::Attrs&,
- const std::vector<std::size_t>,
- const void*,
- void*)> {};
-class SliceImplBackward_cpu
- : public Registrable<SliceImplBackward_cpu, std::tuple<DataType>,
- void(const typename Slice_Op::Attrs&,
- const std::vector<std::size_t>,
- const void*,
- void*)> {};
-
-class SliceImpl_cpu : public OperatorImpl {
-public:
- 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);
- }
-
- void forward() override;
- void backward() override;
-};
-
-namespace {
-static Registrar<Slice_Op> registrarSliceImpl_cpu("cpu", Aidge::SliceImpl_cpu::create);
-}
-} // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_SLICEIMPL_H_ */
diff --git a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
deleted file mode 100644
index d92e9008aff2a4e3c9e392fcc51871001020ce5a..0000000000000000000000000000000000000000
--- a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/********************************************************************************
- * 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_SLICEIMPL_FORWARD_KERNEL_H_
-#define AIDGE_CPU_OPERATOR_SLICEIMPL_FORWARD_KERNEL_H_
-
-#include <cstddef>
-#include <vector>
-
-#include "aidge/backend/cpu/operator/SliceImpl.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/operator/Slice.hpp"
-#include "aidge/utils/Registrar.hpp"
-
-namespace Aidge {
-template <class I>
-void SliceImpl_cpu_forward_kernel(const typename Slice_Op::Attrs& attrs,
- const std::vector<std::size_t> inputDims,
- const void* input_,
- void* output_) {
- std::vector<std::size_t> slicedDims = inputDims;
-
- std::size_t beginning = 0;
- DimSize_t nbAxes = std::get<2>(attrs).size();
- for (std::size_t i = 0; i < nbAxes; ++i) {
- // For each slice operation get the params and cast them to size_t
- const std::int64_t axis_ = std::get<2>(attrs)[i];
- const std::int64_t start_ = std::get<0>(attrs)[i];
- const std::int64_t end_ = std::get<1>(attrs)[i];
- const std::size_t axis = axis_ >= 0 ? axis_ : static_cast<std::size_t>(axis_) + inputDims.size();
- const std::size_t start = start_ >= 0 ? start_ : start_ + inputDims[axis];
- const std::size_t end = end_ >= 0 ? end_ : end_ + inputDims[axis];
- std::size_t stride = 1;
- for (std::size_t j = inputDims.size() - 1; j > axis; --j) stride *= inputDims[j];
- beginning += start * stride;
- const std::size_t sliceLength = end - start + 1;
- slicedDims[axis] = sliceLength;
- }
-
- const I* input = static_cast<const I*>(input_) + beginning;
- I* output = static_cast<I*>(output_);
- const std::size_t nbDims = slicedDims.size();
-
- // for inputDims = {4,5,5,3} & slicedDims = {3,2,2,1}, substractDims = {1,5,5,3}
- std::vector<std::size_t> substractedDims = std::vector<std::size_t>(nbDims);
- for (std::size_t i = 0; i < nbDims; ++i) {
- substractedDims[i] = inputDims[i] - slicedDims[i];
- }
-
- // for slicedDims = {3,2,2,1}, prodSlicedDims = {12,4,2,1}
- std::vector<std::size_t> prodSlicedDims = std::vector<std::size_t>(nbDims);
- std::vector<std::size_t> prodInputDims = std::vector<std::size_t>(nbDims + 1);
- prodSlicedDims[nbDims - 1] = slicedDims[nbDims - 1];
- prodInputDims[nbDims - 1] = inputDims[nbDims - 1];
- prodInputDims[nbDims] = 1;
- for (std::size_t i = 2; i <= nbDims; ++i) {
- prodSlicedDims[nbDims - i] = prodSlicedDims[nbDims - i + 1] * slicedDims[nbDims - i];
- prodInputDims[nbDims - i] = prodInputDims[nbDims - i + 1] * inputDims[nbDims - i];
- }
-
- std::size_t j = 0;
- std::size_t i = 0;
- for (; j < prodSlicedDims[0];) {
- output[j] = input[i++];
- ++j;
- for (std::size_t idx = nbDims - 1; idx > 0; --idx) {
- i += j % prodSlicedDims[idx] == 0 ? substractedDims[idx] * prodInputDims[idx + 1] : 0;
- }
- }
-}
-
-namespace {
-
-static Registrar<SliceImplForward_cpu> registrarSliceImplForward_cpu_Float32(
- {DataType::Float32}, Aidge::SliceImpl_cpu_forward_kernel<float>);
-static Registrar<SliceImplForward_cpu> registrarSliceImplForward_cpu_Int32(
- {DataType::Int32}, Aidge::SliceImpl_cpu_forward_kernel<int>);
-static Registrar<SliceImplForward_cpu> registrarSliceImplForward_cpu_Float64(
- {DataType::Float64}, Aidge::SliceImpl_cpu_forward_kernel<double>);
-} // namespace
-} // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_SLICEIMPL_FORWARD_KERNEL_H_ */
diff --git a/src/operator/SliceImpl.cpp b/src/operator/SliceImpl.cpp
deleted file mode 100644
index d78c25d72dfcd3b46cd23dfa2a2ff4701c20260d..0000000000000000000000000000000000000000
--- a/src/operator/SliceImpl.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#include <cassert>
-#include <numeric> // std::accumulate
-#include <functional> // std::multiplies
-
-#include "aidge/operator/Slice.hpp"
-
-#include "aidge/backend/cpu/operator/SliceImpl.hpp"
-#include "aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp"
-#include "aidge/utils/Types.h"
-#include <vector>
-#include <cassert>
-#include <tuple>
-
-void Aidge::SliceImpl_cpu::forward() {
- // FIXME: uncomment the following code once memory handling will work
- assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<SliceImplForward_cpu>::create(
- {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
-
- // Call kernel
- kernelFunc(dynamic_cast<const Slice_Op&>(mOp).getStaticAttributes(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
- std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
- std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()
- );
-}
-
-void Aidge::SliceImpl_cpu::backward() { fmt::print("Not implemented yet.\n"); }
diff --git a/unit_tests/operator/Test_SliceImpl.cpp b/unit_tests/operator/Test_SliceImpl.cpp
deleted file mode 100644
index be0fdb7eed9c39e8b90b7146fcbdadb65487b8f5..0000000000000000000000000000000000000000
--- a/unit_tests/operator/Test_SliceImpl.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/********************************************************************************
- * 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
- *
- ********************************************************************************/
-
-#include <catch2/catch_test_macros.hpp>
-
-#include "aidge/data/Tensor.hpp"
-#include "aidge/operator/Slice.hpp"
-
-#include "aidge/backend/cpu.hpp"
-
-using namespace Aidge;
-
-TEST_CASE("[cpu/operator] Slice(forward)", "[Slice][CPU]") {
- SECTION("1D Tensor") {
- std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<int,10> {
- {0, 1, 2,-3, 4,-5,-6, 7, 8, 9}
- });
- std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array1D<int,4> {
- {0, 1, 2,-3}
- });
-
- std::shared_ptr<Node> mySlice = Slice({0}, {3}, {0});
- auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
- mySlice->getOperator()->associateInput(0,input0);
- mySlice->getOperator()->setDataType(DataType::Int32);
- mySlice->getOperator()->setBackend("cpu");
- mySlice->forward();
-
- REQUIRE(*(op->getOutput(0)) == *expectedOutput);
- REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
- REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
- }
-
- SECTION("2D Tensor") {
- std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array2D<int,2,10> {
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- }
- });
- std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array2D<int,2,3> {
- {
- {-5,-6, 7},
- {-5,-6, 7}
- }
- });
-
- std::shared_ptr<Node> mySlice = Slice({0,5}, {1,7}, {0,1});
- auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
- mySlice->getOperator()->associateInput(0,input0);
- mySlice->getOperator()->setDataType(DataType::Int32);
- mySlice->getOperator()->setBackend("cpu");
- mySlice->forward();
- // mySlice->getOperator()->output(0).print();
- REQUIRE(*(op->getOutput(0)) == *expectedOutput);
- REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
- REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
- }
-
- SECTION("3D Tensor") {
- std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array3D<int,2,2,10> {
- {
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- },
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- }
- }
- });
- std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array3D<int,1,1,3> {
- {
- {
- { 4,-5,-6}
- }
- }
- });
-
- std::shared_ptr<Node> mySlice = Slice({0,1,4}, {0,1,6}, {0,1,2});
- auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
- mySlice->getOperator()->associateInput(0,input0);
- mySlice->getOperator()->setDataType(DataType::Int32);
- mySlice->getOperator()->setBackend("cpu");
- mySlice->forward();
- // mySlice->getOperator()->output(0).print();
- REQUIRE(*(op->getOutput(0)) == *expectedOutput);
- REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
- REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
- }
-
- SECTION("4D Tensor") {
- std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array4D<int,2,2,2,10> {
- {
- {
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- },
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- }
- },
- {
- {
- { 0, 1, 2,-3, 6,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- },
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3,11,-5,-6, 7,-1,10}
- }
- }
- }
- });
- std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array4D<int,2,2,2,10> {
- {
- {
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- },
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- }
- },
- {
- {
- { 0, 1, 2,-3, 6,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3, 4,-5,-6, 7,-1,10}
- },
- {
- { 0, 1, 2,-3, 4,-5,-6, 7, 8, 9},
- {-5, 4, 2,-3,11,-5,-6, 7,-1,10}
- }
- }
- }
- });
-
- std::shared_ptr<Node> mySlice = Slice({0,0,0,0}, {1,1,1,9}, {0,1,2,3});
- auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
- mySlice->getOperator()->associateInput(0,input0);
- mySlice->getOperator()->setDataType(DataType::Int32);
- mySlice->getOperator()->setBackend("cpu");
- mySlice->forward();
- // mySlice->getOperator()->output(0).print();
- REQUIRE(*(op->getOutput(0)) == *expectedOutput);
- REQUIRE(op->getOutput(0)->dims() == expectedOutput->dims());
- REQUIRE(op->getOutput(0)->dataType() == expectedOutput->dataType());
- }
-}