diff --git a/include/aidge/backend/cpu.hpp b/include/aidge/backend/cpu.hpp
index 11f9c264098d5a238d0d1f8e6bc4fac0cc099549..ce2d030dd0cff423b449890590d3e432430583f3 100644
--- a/include/aidge/backend/cpu.hpp
+++ b/include/aidge/backend/cpu.hpp
@@ -16,6 +16,7 @@
#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
+#include "aidge/backend/cpu/operator/BitShiftImpl.hpp"
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
#include "aidge/backend/cpu/operator/ConvImpl.hpp"
#include "aidge/backend/cpu/operator/DivImpl.hpp"
diff --git a/include/aidge/backend/cpu/operator/BitShiftImpl.hpp b/include/aidge/backend/cpu/operator/BitShiftImpl.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..52400baad4922d5729ea4b13d260f04a2836ed59
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/BitShiftImpl.hpp
@@ -0,0 +1,51 @@
+/********************************************************************************
+ * 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_BITSHIFTIMPL_H_
+#define AIDGE_CPU_OPERATOR_BITSHIFTIMPL_H_
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/operator/BitShift.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 BitShift_Op;
+
+// compute kernel registry for forward and backward
+class BitShiftImplForward_cpu
+ : public Registrable<BitShiftImplForward_cpu, std::tuple<DataType, DataType, DataType>, void(const Direction,const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)> {
+};
+class BitShiftImplBackward_cpu
+ : public Registrable<BitShiftImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const Direction,const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)> {
+};
+
+class BitShiftImpl_cpu : public OperatorImpl {
+public:
+ BitShiftImpl_cpu(const BitShift_Op& op) : OperatorImpl(op, "cpu") {}
+
+ static std::unique_ptr<BitShiftImpl_cpu> create(const BitShift_Op& op) {
+ return std::make_unique<BitShiftImpl_cpu>(op);
+ }
+
+ Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+ void forward() override;
+};
+
+namespace {
+static Registrar<BitShift_Op> registrarBitShiftImpl_cpu("cpu", Aidge::BitShiftImpl_cpu::create);
+}
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_BITSHIFTIMPL_H_ */
diff --git a/include/aidge/backend/cpu/operator/BitShiftImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/BitShiftImpl_forward_kernels.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..98b34b9d5d388fd9cabb562f8bd7d311644b73c1
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/BitShiftImpl_forward_kernels.hpp
@@ -0,0 +1,74 @@
+/********************************************************************************
+ * 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_BITSHIFTIMPL_FORWARD_KERNEL_H_
+#define AIDGE_CPU_OPERATOR_BITSHIFTIMPL_FORWARD_KERNEL_H_
+
+#include "aidge/utils/Registrar.hpp"
+
+#include <cstdint> // std::int32_t, std::int64_t
+#include "aidge/operator/BitShift.hpp"
+
+#include "aidge/backend/cpu/data/Broadcasting.hpp"
+#include "aidge/backend/cpu/operator/BitShiftImpl.hpp"
+
+
+
+namespace Aidge {
+template <class I1, class I2, class O>
+void BitShiftImpl_cpu_forward_kernel(
+ const Direction direction,
+ const std::vector<std::size_t>& input1Dims,
+ const std::vector<std::size_t>& input2Dims,
+ const std::vector<std::size_t>& outputDims,
+ const void* input1_,
+ const void* input2_,
+ void* output_
+ ) {
+
+ //Cast des entrées en classes I / O
+ const I1* input_1 = static_cast<const I1*>(input1_);
+ const I2* input_2 = static_cast<const I2*>(input2_);
+ O* output = static_cast<O*>(output_);
+
+ size_t totalElements = 1;
+ for (size_t dimSize : outputDims) {
+ totalElements *= dimSize;
+ }
+
+ for (std::size_t oIndex = 0; oIndex < totalElements; ++oIndex)
+ {
+ std::vector<size_t> indexes = getMultiDimIndices(outputDims, oIndex);
+ std::size_t idx1 = getFlattenedIndex(input1Dims, indexes);
+ std::size_t idx2 = getFlattenedIndex(input2Dims, indexes);
+ if(direction == Direction::right)
+ {
+ //BitShift ne fonctionne pas sur les types à virgule flottante
+ output[oIndex]= input_1[idx1] >> input_2[idx2];
+ }
+ else if(direction == Direction::left)
+ {
+ output[oIndex] = input_1[idx1] << input_2[idx2];
+ }
+ }
+}
+
+namespace {
+static Registrar<BitShiftImplForward_cpu> registrarBitShiftImplForward_cpu_Int32(
+ {DataType::Int32, DataType::Int32, DataType::Int32},
+ Aidge::BitShiftImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>);
+static Registrar<BitShiftImplForward_cpu> registrarBitShiftImplForward_cpu_Int64(
+ {DataType::Int64, DataType::Int64, DataType::Int64},
+ Aidge::BitShiftImpl_cpu_forward_kernel<std::int64_t, std::int64_t, std::int64_t>);
+} // namespace
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_BitShiftIMPL_FORWARD_KERNEL_H_ */
diff --git a/src/operator/BitShiftImpl.cpp b/src/operator/BitShiftImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..600c3a4bc930e71ecd9e72e2af7c5fedfa4a1de2
--- /dev/null
+++ b/src/operator/BitShiftImpl.cpp
@@ -0,0 +1,57 @@
+/********************************************************************************
+ * 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 <chrono> // std::chrono::milliseconds
+#include <numeric>
+#include <thread> // std::this_thread::sleep_for
+#include <vector>
+
+
+#include "aidge/utils/Types.h"
+#include "aidge/backend/cpu/data/Broadcasting.hpp"
+#include "aidge/backend/cpu/data/GetCPUPtr.h"
+
+#include "aidge/backend/cpu/operator/BitShiftImpl.hpp"
+#include "aidge/backend/cpu/operator/BitShiftImpl_forward_kernels.hpp"
+
+Aidge::Elts_t Aidge::BitShiftImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
+ // this implementation can be in-place
+ return Elts_t::DataElts(0);
+}
+
+void Aidge::BitShiftImpl_cpu::forward() {
+
+ const auto& op_ = dynamic_cast<const BitShift_Op&>(mOp);
+
+ auto kernelFunc = Registrar<BitShiftImplForward_cpu>::create({
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+
+ const std::vector<std::size_t> inputDims0 = getBroadcastedDims(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims());
+ const std::vector<std::size_t> inputDims1 = getBroadcastedDims(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dims());
+
+ Direction direction = op_.direction();
+
+ // Call kernel
+ kernelFunc(
+ direction,
+ inputDims0,
+ inputDims1,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ getCPUPtr(mOp.getRawInput(0)),
+ getCPUPtr(mOp.getRawInput(1)),
+ getCPUPtr(mOp.getRawOutput(0)));
+
+}
diff --git a/unit_tests/operator/Test_BitShift.cpp b/unit_tests/operator/Test_BitShift.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33c2bd1d879f7ea22d8d8f4448a90fb95ed2e349
--- /dev/null
+++ b/unit_tests/operator/Test_BitShift.cpp
@@ -0,0 +1,245 @@
+/********************************************************************************
+ * 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 <cstddef> // std::size_t
+#include <cstdint> // std::uint16_t
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <numeric>
+#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution
+#include <iomanip>
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/BitShift.hpp"
+#include "aidge/utils/TensorUtils.hpp"
+
+namespace Aidge {
+
+TEST_CASE("[cpu/operator] BitShift_TEST", "[BitShift][CPU]") {
+ constexpr std::uint16_t NBTRIALS = 15;
+ // Create a random number generator
+ std::random_device rd;
+ std::mt19937 gen(rd());
+ std::uniform_int_distribution<int> valueDist(-15, 15); // Random int distribution between -15 and 15
+ std::uniform_int_distribution<std::size_t> dimSizeDist(std::size_t(2), std::size_t(5));
+ std::uniform_int_distribution<std::size_t> nbDimsDist(std::size_t(1), std::size_t(3));
+ std::uniform_int_distribution<int> boolDist(0,1);
+
+ Direction direction = Direction::left;
+
+ if(valueDist(gen) % 2 == 0)
+ {
+ direction = Direction::right;
+ }
+
+ // Create BitShift Operator
+ std::shared_ptr<Node> myBitShift = BitShift(direction); // Left opérator to start
+ auto op = std::static_pointer_cast<OperatorTensor>(myBitShift-> getOperator());
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+
+ // Create 2 input Tensors
+ std::shared_ptr<Tensor> T0 = std::make_shared<Tensor>();
+ op->associateInput(0,T0);
+ T0->setDataType(DataType::Int32);
+ T0->setBackend("cpu");
+ std::shared_ptr<Tensor> T1 = std::make_shared<Tensor>();
+ op -> associateInput(1,T1);
+ T1->setDataType(DataType::Int32);
+ T1->setBackend("cpu");
+
+ // Create results Tensor
+ std::shared_ptr<Tensor> Tres = std::make_shared<Tensor>();
+ Tres->setDataType(DataType::Int32);
+ Tres->setBackend("cpu");
+
+ // To measure execution time of 'BitShift_Op::forward()' member function call
+ std::chrono::time_point<std::chrono::system_clock> start;
+
+ std::chrono::time_point<std::chrono::system_clock> end;
+ std::chrono::duration<double, std::micro> duration{};
+
+ SECTION("BitShiftImpl_cpu::forward()") {
+ SECTION("+1-D Tensor / +1-D Tensor - same dimensions") {
+ std::size_t number_of_operation = 0;
+
+ for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) {
+ // generate 2 random Tensors
+ const std::size_t nbDims = nbDimsDist(gen);
+ std::vector<std::size_t> dims;
+ for (std::size_t i = 0; i < nbDims; ++i) {
+ dims.push_back(dimSizeDist(gen));
+ }
+ const std::size_t nb_elements = std::accumulate(dims.cbegin(), dims.cend(), std::size_t(1), std::multiplies<std::size_t>());
+ number_of_operation += nb_elements;
+
+ // without broadcasting
+ int* array0 = new int[nb_elements];
+ int* array1 = new int[nb_elements];
+ int* result = new int[nb_elements];
+
+ for (std::size_t i = 0; i < nb_elements; ++i) {
+ array0[i] = valueDist(gen);
+ array1[i] = std::abs(valueDist(gen)); // bitshift is impossible with negative value
+ if(direction == Direction::left)
+ {
+ result[i] = array0[i] << array1[i];
+ }
+ else
+ {
+ result[i] = array0[i] >> array1[i];
+ }
+ }
+
+ // input0
+ T0->resize(dims);
+ T0 -> getImpl() -> setRawPtr(array0, nb_elements);
+
+ // input1
+ T1->resize(dims);
+ T1 -> getImpl() -> setRawPtr(array1, nb_elements);
+
+ // results
+ Tres->resize(dims);
+ Tres -> getImpl() -> setRawPtr(result, nb_elements);
+
+ op->forwardDims();
+ start = std::chrono::system_clock::now();
+ myBitShift->forward();
+ end = std::chrono::system_clock::now();
+ duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+
+ bool is_eq = approxEq<int>(*(op->getOutput(0)), *Tres);
+
+ auto Output = *(op->getOutput(0));
+ auto prt = Output.getImpl()->rawPtr();
+
+ REQUIRE(is_eq);
+
+ delete[] array0;
+ delete[] array1;
+ delete[] result;
+
+
+ }
+ std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl;
+ std::cout << "total time: " << duration.count() << "μs" << std::endl;
+ }
+ SECTION("+1-D Tensor / +1-D Tensor - broadcasting") {
+ std::size_t number_of_operation = 0;
+
+ for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) {
+ // generate 2 random Tensors
+ // handle dimensions, replace some dimensions with '1' to get broadcasting
+ constexpr std::size_t nbDims = 4;
+ std::vector<std::size_t> dims;
+ for (std::size_t i = 0; i < nbDims; ++i) {
+ dims.push_back(dimSizeDist(gen));
+ }
+ std::vector<std::size_t> dims0 = dims;
+ std::vector<std::size_t> dims1 = dims;
+ std::vector<std::size_t> dimsOut = dims;
+ for (std::size_t i = 0; i < nbDims; ++i) {
+ if (boolDist(gen)) {
+ dims0[i] = 1;
+ }
+ if (boolDist(gen)) {
+ dims1[i] = 1;
+ }
+ dimsOut[i] = (dims0[i] == 1) ? dims1[i] : dims0[i];
+ }
+
+ // create arrays and fill them with random values
+ int* array0 = new int[dims0[0]*dims0[1]*dims0[2]*dims0[3]];
+ int* array1 = new int[dims1[0]*dims1[1]*dims1[2]*dims1[3]];
+ int* result = new int[dimsOut[0]*dimsOut[1]*dimsOut[2]*dimsOut[3]];
+
+ for (std::size_t i = 0; i < dims0[0]*dims0[1]*dims0[2]*dims0[3]; ++i) {
+ array0[i] = valueDist(gen);
+ }
+ for (std::size_t i = 0; i < dims1[0]*dims1[1]*dims1[2]*dims1[3]; ++i) {
+ array1[i] = std::abs(valueDist(gen));
+ }
+
+ //True result with broadcast
+ const std::size_t strides0[nbDims] = {dims0[1]*dims0[2]*dims0[3], dims0[2]*dims0[3], dims0[3], 1};
+ const std::size_t strides1[nbDims] = {dims1[1]*dims1[2]*dims1[3], dims1[2]*dims1[3], dims1[3], 1};
+ for (std::size_t a = 0; a < dimsOut[0]; ++a) {
+ for (std::size_t b = 0; b < dimsOut[1]; ++b) {
+ const std::size_t idx0_0 = strides0[0] * ((dims0[0] > 1) ? a : 0)
+ + strides0[1] * ((dims0[1] > 1) ? b : 0);
+ const std::size_t idx1_0 = strides1[0] * ((dims1[0] > 1) ? a : 0)
+ + strides1[1] * ((dims1[1] > 1) ? b : 0);
+ for (std::size_t c = 0; c < dimsOut[2]; ++c) {
+ const std::size_t idx_out = dimsOut[3] * (c + dimsOut[2] * (b + dimsOut[1] * a));
+ for (std::size_t d = 0; d < dimsOut[3]; ++d) {
+ std::size_t idx0 = idx0_0
+ + strides0[2] * ((dims0[2] > 1) ? c : 0)
+ + ((dims0[3] > 1) ? d : 0);
+ std::size_t idx1 = idx1_0
+ + strides1[2] * ((dims1[2] > 1) ? c : 0)
+ + ((dims1[3] > 1) ? d : 0);
+ if(direction == Direction::left)
+ {
+ result[idx_out + d] = array0[idx0] << array1[idx1];
+ }
+ else
+ {
+ result[idx_out + d] = array0[idx0] >> array1[idx1];
+ }
+ }
+ }
+ }
+ }
+
+ // conversion to Aidge::Tensors
+ // input0
+ T0->resize(dims0);
+ T0 -> getImpl() -> setRawPtr(array0, dims0[0]*dims0[1]*dims0[2]*dims0[3]);
+
+ // input1
+ T1->resize(dims1);
+ T1 -> getImpl() -> setRawPtr(array1, dims1[0]*dims1[1]*dims1[2]*dims1[3]);
+
+ // results
+ Tres->resize(dimsOut);
+ Tres -> getImpl() -> setRawPtr(result, dimsOut[0]*dimsOut[1]*dimsOut[2]*dimsOut[3]);
+
+ // compute result
+ op->forwardDims();
+ start = std::chrono::system_clock::now();
+ myBitShift->forward();
+ end = std::chrono::system_clock::now();
+ duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+
+ // comparison between truth and computed result
+ bool equiv = (approxEq<int>(*(op->getOutput(0)), *Tres));
+ if(equiv == false)
+ {
+ std::cout << "Problem\n";
+ }
+ REQUIRE(equiv);
+
+ delete[] array0;
+ delete[] array1;
+ delete[] result;
+
+ const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>());
+ number_of_operation += nb_elements;
+ }
+ std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl;
+ std::cout << "total time: " << duration.count() << "μs" << std::endl;
+ }
+
+}
+} // namespace Aidge
+}
\ No newline at end of file