Merge branch 'dev' into 'main'

0.2.2

Closes #12

See merge request eclipse/aidge/aidge_backend_cpu!61

CHANGELOG

+# Version 0.2.2 (May 14, 2024)
+
+* Remove implmentation for Operators soly handling memory and format
+ - Concat
+ - Gather
+ - Memorize
+ - Pop
+ - Reshape
+ - Slice
+ - Transpose
+* Fix ReLU backward kernel
+* Add `showCpuVersion()` function to show which compiler was used
+
 # Version 0.2.1 (April 11, 2024)
 
 Fix: explicit linkage with fmt

CMakeLists.txt

 cmake_minimum_required(VERSION 3.15)
 
 
-file(READ "${CMAKE_SOURCE_DIR}/version.txt" version)
-file(READ "${CMAKE_SOURCE_DIR}/project_name.txt" project)
+file(STRINGS "${CMAKE_SOURCE_DIR}/version.txt" version)
+add_definitions(-DPROJECT_VERSION="${version}")
+file(STRINGS "${CMAKE_SOURCE_DIR}/project_name.txt" project)
 
 message(STATUS "Project name: ${project}")
 message(STATUS "Project version: ${version}")
 
+execute_process(
+    COMMAND git rev-parse --short HEAD
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_COMMIT_HASH
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+message(STATUS "Latest git commit: ${GIT_COMMIT_HASH}")
+
+# Define a preprocessor macro with the Git commit version
+add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
+
 # Note : project name is {project} and python module name is also {project}
 set(module_name _${project}) # target name
 

aidge_backend_cpu/unit_tests/test_recipes.py

@@ -40,7 +40,7 @@ class test_recipes(unittest.TestCase):
         graph_view.set_backend("cpu")
 
         np_weights = np.arange(9).reshape([1, 1, 3, 3]).astype(np.float32)
-        np_bias = np.arange(1).reshape([1, 1]).astype(np.float32)
+        np_bias = np.arange(1).reshape([1]).astype(np.float32)
 
         np_scale = np.array([0.05]).astype(np.float32)
         np_shift = np.array([0.05]).astype(np.float32)

include/aidge/backend/cpu.hpp

@@ -16,32 +16,25 @@
 #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/ConcatImpl.hpp"
 #include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
 #include "aidge/backend/cpu/operator/ConvImpl.hpp"
 #include "aidge/backend/cpu/operator/DivImpl.hpp"
 #include "aidge/backend/cpu/operator/ErfImpl.hpp"
 #include "aidge/backend/cpu/operator/FCImpl.hpp"
-#include "aidge/backend/cpu/operator/GatherImpl.hpp"
 #include "aidge/backend/cpu/operator/GlobalAveragePoolingImpl.hpp"
 #include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
 #include "aidge/backend/cpu/operator/MatMulImpl.hpp"
-#include "aidge/backend/cpu/operator/MemorizeImpl.hpp"
 #include "aidge/backend/cpu/operator/MulImpl.hpp"
 #include "aidge/backend/cpu/operator/PadImpl.hpp"
-#include "aidge/backend/cpu/operator/PopImpl.hpp"
 #include "aidge/backend/cpu/operator/PowImpl.hpp"
 #include "aidge/backend/cpu/operator/ReduceMeanImpl.hpp"
 #include "aidge/backend/cpu/operator/ReLUImpl.hpp"
-#include "aidge/backend/cpu/operator/ReshapeImpl.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"
 #include "aidge/backend/cpu/operator/TanhImpl.hpp"
-#include "aidge/backend/cpu/operator/TransposeImpl.hpp"
 
 #include "aidge/backend/cpu/data/TensorImpl.hpp"
 

include/aidge/backend/cpu/operator/ConcatImpl.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_CONCATIMPL_H_
-#define AIDGE_CPU_OPERATOR_CONCATIMPL_H_
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Concat.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 Concat_Op<2>;
-
-// compute kernel registry for forward and backward
-class ConcatImplForward_cpu
-    : public Registrable<ConcatImplForward_cpu, std::tuple<DataType, DataType>, void(const Concat_Op::Attrs&,
-                                                                                     const std::vector<DimSize_t>,
-                                                                                     const std::vector<DimSize_t>&,
-                                                                                     const std::vector<const void*>,
-                                                                                     void*)> {};
-
-class ConcatImplBackward_cpu
-    : public Registrable<ConcatImplBackward_cpu, std::tuple<DataType, DataType>, void(const Concat_Op::Attrs&,
-                                                                                     const std::vector<DimSize_t>,
-                                                                                     const std::vector<DimSize_t>&,
-                                                                                     const std::vector<const void*>,
-                                                                                     void*)> {};
-
-
-class ConcatImpl_cpu : public OperatorImpl {
-public:
-    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);
-    }
-
-public:
-    void forward() override;
-
-    void backward() override;
-};
-
-namespace {
-static Registrar<Concat_Op> registrarConcatImpl_cpu("cpu", Aidge::ConcatImpl_cpu::create);
-}  // namespace
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_H_ */

include/aidge/backend/cpu/operator/ConcatImpl_forward_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_CONCATIMPL_FORWARD_KERNEL_H_
-#define AIDGE_CPU_OPERATOR_CONCATIMPL_FORWARD_KERNEL_H_
-
-#include <algorithm>
-#include <numeric>
-#include <cstddef>
-#include <vector>
-
-#include "aidge/backend/cpu/operator/ConcatImpl.hpp"
-#include "aidge/data/Data.hpp"
-#include "aidge/operator/Concat.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-#include "aidge/backend/cpu/data/GetCPUPtr.h"
-
-namespace Aidge {
-
-template <class I, class O>
-void ConcatImpl_cpu_forward_kernel(const Concat_Op::Attrs& attrs,
-                                   const std::vector<DimSize_t>& dimsFirstInput,
-                                   const std::vector<DimSize_t>& concatAxisValues,
-                                   const std::vector<const void*>& inputs_,
-                                   void* output_)
-{
-    // FIXME: missing Concat attributes as arguments
-    std::vector<const I*> inputs;
-    for (const auto& input_ : inputs_) {
-        inputs.push_back(static_cast<const I*>(input_));
-    }
-    O* output = static_cast<O*>(output_);
-
-    DimSize_t outputAxisValue = std::accumulate(concatAxisValues.begin(), concatAxisValues.end(), 0);
-
-    DimSize_t prodDimLower = 1;
-    for (DimIdx_t i = 0; i < std::get<0>(attrs); ++i) {
-        prodDimLower *= dimsFirstInput[i];
-    }
-    DimSize_t prodDimHigher = 1;
-    for (DimIdx_t i = std::get<0>(attrs) + 1; static_cast<std::size_t>(i) < dimsFirstInput.size();
-         ++i) {
-        prodDimHigher *= dimsFirstInput[i];
-    }
-
-    std::size_t oIndexStart = 0;
-    std::size_t oIndex = 0;
-    for (std::size_t inputId = 0; inputId < inputs.size(); ++inputId) {
-        oIndex = oIndexStart;
-        const DimSize_t iOffset = prodDimHigher*concatAxisValues[inputId];
-        for (std::size_t iIndex = 0; iIndex < prodDimLower; ++iIndex) {
-            std::copy(inputs[inputId] + iIndex*iOffset, inputs[inputId] + (iIndex+1)*iOffset, output + oIndex);
-            oIndex += prodDimHigher*outputAxisValue;
-        }
-        oIndexStart += concatAxisValues[inputId]*prodDimHigher;
-    }
-}
-
-namespace {
-static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::ConcatImpl_cpu_forward_kernel<float, float>);
-static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::ConcatImpl_cpu_forward_kernel<int, int>);
-static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64},
-        Aidge::ConcatImpl_cpu_forward_kernel<double, double>);
-}  // namespace
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_CPU_FORWARD_KERNEL_H_ */

include/aidge/backend/cpu/operator/GatherImpl.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_GATHERIMPL_H_
-#define AIDGE_CPU_OPERATOR_GATHERIMPL_H_
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Gather.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-#include <memory>
-#include <vector>
-
-namespace Aidge {
-// class Gather_Op;
-
-// compute kernel registry for forward and backward
-class GatherImplForward_cpu
-    : public Registrable<GatherImplForward_cpu, std::tuple<DataType, DataType>, void(const typename Gather_Op::Attrs&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class GatherImplBackward_cpu
-    : public Registrable<GatherImplBackward_cpu, std::tuple<DataType, DataType>, void(const typename Gather_Op::Attrs&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-
-class GatherImpl_cpu : public OperatorImpl {
-public:
-    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);
-    }
-
-    void forward() override;
-};
-
-namespace {
-static Registrar<Gather_Op> registrarGatherImpl_cpu("cpu", Aidge::GatherImpl_cpu::create);
-}
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_GATHERIMPL_H_ */

include/aidge/backend/cpu/operator/GatherImpl_forward_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_GATHERIMPL_FORWARD_KERNEL_H_
-#define AIDGE_CPU_OPERATOR_GATHERIMPL_FORWARD_KERNEL_H_
-
-#include "aidge/utils/Registrar.hpp"
-#include <cstddef>
-#include <cmath>
-#include "aidge/data/Data.hpp"
-#include "aidge/utils/Types.h"
-
-#include "aidge/backend/cpu/operator/GatherImpl.hpp"
-
-namespace Aidge {
-template <class I, class O>
-void GatherImpl_cpu_forward_kernel(const typename Gather_Op::Attrs& attrs, const std::vector<DimSize_t>& inputDims, const void* input_, void* output_)
-{
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
-
-    const std::size_t axisIdx = std::get<2>(attrs)>=0 ?
-                                std::get<2>(attrs) :
-                                static_cast<std::size_t>(std::get<2>(attrs)) + inputDims.size();
-
-    std::size_t postAxisElems = 1;
-    for (std::size_t i = axisIdx + 1; i < inputDims.size(); ++i) {
-        postAxisElems *= inputDims[i];
-    }
-    std::size_t preAxisElems = 1;
-    for (std::size_t i = 0; i < axisIdx; ++i) {
-        preAxisElems *= inputDims[i];
-    }
-
-    const std::vector<std::int64_t> indices = std::get<0>(attrs);
-    for (std::size_t i=0; i<preAxisElems; ++i)
-    {
-        for(std::size_t j=0; j<indices.size(); ++j)
-        {
-            const std::size_t idx = indices[j] >= 0 ? indices[j] : static_cast<std::size_t>(indices[j]) + inputDims[axisIdx];
-            const I* startPtr = std::next(input, i * postAxisElems * inputDims[axisIdx] + idx * postAxisElems);
-            std::copy_n(startPtr, postAxisElems, output);
-            output += postAxisElems;
-        }
-    }
-}
-
-namespace {
-static Registrar<GatherImplForward_cpu> registrarGatherImplForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::GatherImpl_cpu_forward_kernel<float, float>);
-static Registrar<GatherImplForward_cpu> registrarGatherImplForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::GatherImpl_cpu_forward_kernel<int, int>);
-static Registrar<GatherImplForward_cpu> registrarGatherImplForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64}, Aidge::GatherImpl_cpu_forward_kernel<double, double>);
-}  // namespace
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_GATHERIMPL_FORWARD_KERNEL_H_ */

include/aidge/backend/cpu/operator/MemorizeImpl.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_MEMORIZEIMPL_H_
-#define AIDGE_CPU_OPERATOR_MEMORIZEIMPL_H_
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Memorize.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 MemorizeImpl_cpu : public OperatorImpl {
-public:
-    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);
-    }
-
-    Elts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
-    Elts_t getRequiredMemory(const Aidge::IOIndex_t outputIdx,
-                               const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const override final;
-    void updateConsummerProducer() override final;
-    void forward() override;
-};
-
-namespace {
-static Registrar<Memorize_Op> registrarMemorizeImpl_cpu("cpu", Aidge::MemorizeImpl_cpu::create);
-}
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_MEMORIZEIMPL_H_ */

include/aidge/backend/cpu/operator/PopImpl.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_POPIMPL_H_
-#define AIDGE_CPU_OPERATOR_POPIMPL_H_
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Pop.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 Pop_Op;
-
-// compute kernel registry for forward and backward
-class PopImplForward_cpu
-    : public Registrable<PopImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
-};
-class PopImplBackward_cpu
-    : public Registrable<PopImplBackward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {
-};
-
-class PopImpl_cpu : public OperatorImpl {
-public:
-    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);
-    }
-
-    Elts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
-    void forward() override;
-};
-
-namespace {
-static Registrar<Pop_Op> registrarPopImpl_cpu("cpu", Aidge::PopImpl_cpu::create);
-}
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_POPIMPL_H_ */

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

@@ -30,7 +30,7 @@ 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>, void(const std::size_t, const void*, void*)> {
+    : public Registrable<ReLUImplBackward_cpu, std::tuple<DataType, DataType, DataType>, void(const std::size_t, const void*, const void*, void*)> {
 };
 
 class ReLUImpl_cpu : public OperatorImpl {

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

@@ -14,31 +14,32 @@
 
 #include <cstddef>  // std::size_t
 
-#include "aidge/utils/Registrar.hpp"
-
 #include "aidge/backend/cpu/operator/ReLUImpl.hpp"
+#include "aidge/utils/Registrar.hpp"
 
 namespace Aidge {
-template <class I, class O>
+template <class O, class GI, class GO>
 void ReLUImpl_cpu_backward_kernel(const std::size_t inputLenght,
-                                     const void* input_,
-                                     void* output_) {
-
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
-
+                                  const void* output_, const void* grad_output_,
+                                  void* grad_input_) {
+    const O* output = static_cast<const O*>(output_);
+    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) {
-        output[i] = (input[i] > I(0)) ? static_cast<O>(input[i]) : O(0);
+        grad_input[i] = (output[i] > GO(0)) ? GI(grad_output[i]) : GI(0);
     }
 }
 
 namespace {
 static Registrar<ReLUImplBackward_cpu> registrarReLUImplBackward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::ReLUImpl_cpu_backward_kernel<float, float>);
+    {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}, Aidge::ReLUImpl_cpu_backward_kernel<int, int>);
+    {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}, Aidge::ReLUImpl_cpu_backward_kernel<double, double>);
+    {DataType::Float64, DataType::Float64, DataType::Float64},
+    Aidge::ReLUImpl_cpu_backward_kernel<double, double, double>);
 }  // namespace
 }  // namespace Aidge
 

include/aidge/backend/cpu/operator/ReshapeImpl.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_RESHAPEIMPL_H_
-#define AIDGE_CPU_OPERATOR_RESHAPEIMPL_H_
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Reshape.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-#include <memory>
-#include <vector>
-
-namespace Aidge {
-// class Reshape_Op;
-
-// compute kernel registry for forward and backward
-class ReshapeImplForward_cpu
-    : public Registrable<ReshapeImplForward_cpu, std::tuple<DataType, DataType>, void(std::size_t, const void*, void*)> {
-};
-class ReshapeImplBackward_cpu
-    : public Registrable<ReshapeImplBackward_cpu, std::tuple<DataType, DataType>, void(std::size_t, const void*, void*)> {
-};
-
-class ReshapeImpl_cpu : public OperatorImpl {
-public:
-    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);
-    }
-
-    Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
-    void forward() override;
-};
-
-namespace {
-static Registrar<Reshape_Op> registrarReshapeImpl_cpu("cpu", Aidge::ReshapeImpl_cpu::create);
-}
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_RESHAPEIMPL_H_ */

include/aidge/backend/cpu/operator/ReshapeImpl_forward_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_RESHAPEIMPL_FORWARD_KERNEL_H_
-#define AIDGE_CPU_OPERATOR_RESHAPEIMPL_FORWARD_KERNEL_H_
-
-#include "aidge/utils/Registrar.hpp"
-#include <cmath>
-
-#include "aidge/backend/cpu/operator/ReshapeImpl.hpp"
-
-namespace Aidge {
-template <class I, class O>
-void ReshapeImpl_cpu_forward_kernel(std::size_t inputLength,
-                                    const void* input_,
-                                    void* output_) {
-
-    const I* input = static_cast<const I*>(input_);
-    O* output = static_cast<O*>(output_);
-
-    std::copy_n(input, inputLength, output);
-}
-
-namespace {
-static Registrar<ReshapeImplForward_cpu> registrarReshapeImplForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32},
-        Aidge::ReshapeImpl_cpu_forward_kernel<float, float>);
-static Registrar<ReshapeImplForward_cpu> registrarReshapeImplForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32},
-        Aidge::ReshapeImpl_cpu_forward_kernel<int, int>);
-static Registrar<ReshapeImplForward_cpu> registrarReshapeImplForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64},
-        Aidge::ReshapeImpl_cpu_forward_kernel<double, double>);
-}  // namespace
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_RESHAPEIMPL_FORWARD_KERNEL_H_ */

include/aidge/backend/cpu/operator/SliceImpl.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_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_ */

include/aidge/backend/cpu/operator/SliceImpl_forward_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_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_ */

include/aidge/backend/cpu/operator/TransposeImpl.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_TransposeIMPL_H_
-#define AIDGE_CPU_OPERATOR_TransposeIMPL_H_
-
-#include "aidge/backend/OperatorImpl.hpp"
-#include "aidge/operator/Transpose.hpp"
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/utils/Types.h"
-#include <memory>
-#include <vector>
-
-namespace Aidge {
-// class Transpose_Op;
-
-// compute kernel registry for forward and backward
-class TransposeImpl2DForward_cpu
-    : public Registrable<TransposeImpl2DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<2>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl3DForward_cpu
-    : public Registrable<TransposeImpl3DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<3>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl4DForward_cpu
-    : public Registrable<TransposeImpl4DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<4>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl5DForward_cpu
-    : public Registrable<TransposeImpl5DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<5>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl6DForward_cpu
-    : public Registrable<TransposeImpl6DForward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<6>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl2DBackward_cpu
-    : public Registrable<TransposeImpl2DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<2>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl3DBackward_cpu
-    : public Registrable<TransposeImpl3DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<3>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl4DBackward_cpu
-    : public Registrable<TransposeImpl4DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<4>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl5DBackward_cpu
-    : public Registrable<TransposeImpl5DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<5>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-class TransposeImpl6DBackward_cpu
-    : public Registrable<TransposeImpl6DBackward_cpu, std::tuple<DataType, DataType>, void( const typename Transpose_Op<6>::Attrs& attrs, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const void*, void*)> {
-};
-
-
-class TransposeImpl2D_cpu : public OperatorImpl {
-public:
-    TransposeImpl2D_cpu(const Transpose_Op<2>& op) : OperatorImpl(op, "cpu") {}
-
-    static std::unique_ptr<TransposeImpl2D_cpu> create(const Transpose_Op<2>& op) {
-        return std::make_unique<TransposeImpl2D_cpu>(op);
-    }
-
-    void forward() override;
-};
-class TransposeImpl3D_cpu : public OperatorImpl {
-public:
-    TransposeImpl3D_cpu(const Transpose_Op<3>& op) : OperatorImpl(op, "cpu") {}
-
-    static std::unique_ptr<TransposeImpl3D_cpu> create(const Transpose_Op<3>& op) {
-        return std::make_unique<TransposeImpl3D_cpu>(op);
-    }
-
-    void forward() override;
-};
-class TransposeImpl4D_cpu : public OperatorImpl {
-public:
-    TransposeImpl4D_cpu(const Transpose_Op<4>& op) : OperatorImpl(op, "cpu") {}
-
-    static std::unique_ptr<TransposeImpl4D_cpu> create(const Transpose_Op<4>& op) {
-        return std::make_unique<TransposeImpl4D_cpu>(op);
-    }
-
-    void forward() override;
-};
-class TransposeImpl5D_cpu : public OperatorImpl {
-public:
-    TransposeImpl5D_cpu(const Transpose_Op<5>& op) : OperatorImpl(op, "cpu") {}
-
-    static std::unique_ptr<TransposeImpl5D_cpu> create(const Transpose_Op<5>& op) {
-        return std::make_unique<TransposeImpl5D_cpu>(op);
-    }
-
-    void forward() override;
-};
-class TransposeImpl6D_cpu : public OperatorImpl {
-public:
-    TransposeImpl6D_cpu(const Transpose_Op<6>& op) : OperatorImpl(op, "cpu") {}
-
-    static std::unique_ptr<TransposeImpl6D_cpu> create(const Transpose_Op<6>& op) {
-        return std::make_unique<TransposeImpl6D_cpu>(op);
-    }
-
-    void forward() override;
-};
-
-namespace {
-static Registrar<Transpose_Op<2>> registrarTransposeImpl2D_cpu("cpu", Aidge::TransposeImpl2D_cpu::create);
-static Registrar<Transpose_Op<3>> registrarTransposeImpl3D_cpu("cpu", Aidge::TransposeImpl3D_cpu::create);
-static Registrar<Transpose_Op<4>> registrarTransposeImpl4D_cpu("cpu", Aidge::TransposeImpl4D_cpu::create);
-static Registrar<Transpose_Op<5>> registrarTransposeImpl5D_cpu("cpu", Aidge::TransposeImpl5D_cpu::create);
-static Registrar<Transpose_Op<6>> registrarTransposeImpl6D_cpu("cpu", Aidge::TransposeImpl6D_cpu::create);
-}
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_TransposeIMPL_H_ */

include/aidge/backend/cpu/operator/TransposeImpl_forward_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_TRANSPOSEIMPL_FORWARD_KERNEL_H_
-#define AIDGE_CPU_OPERATOR_TRANSPOSEIMPL_FORWARD_KERNEL_H_
-
-#include "aidge/utils/Registrar.hpp"
-#include <cstddef>
-#include <cmath>
-#include "aidge/data/Data.hpp"
-#include "aidge/utils/Types.h"
-
-#include "aidge/backend/cpu/operator/TransposeImpl.hpp"
-
-namespace Aidge {
-template <class I, class O, DimSize_t DIM>
-void TransposeImpl_cpu_forward_kernel( const typename Transpose_Op<DIM>::Attrs& attrs, const std::vector<DimSize_t>& inputDims, const std::vector<DimSize_t>& outputDims, const void* input_, void* output_)
-{
-    O* output = static_cast<O*>(output_);
-    const I* input = static_cast<const I*>(input_);
-    
-    // Compute total number of elements in the input array
-    size_t totalElements = 1;
-    for (size_t dimSize : inputDims) {
-        totalElements *= dimSize;
-    }
-
-	std::vector<std::size_t> outStrides(DIM, 1);
-	for (size_t i = 0; i < DIM; ++i) {
-			for (size_t j = i+1; j < DIM; ++j)
-			{
-					outStrides[i] *= outputDims[j];
-			}
-	}
-
-    std::vector<size_t> indices(outputDims.size(), 0);
-    for (size_t i = 0; i < totalElements; ++i) {
-        size_t idx = 0;
-        // Permute indices based on OutputDimsOrder attr
-        std::vector<size_t> permutedIndices(DIM);
-        for (size_t j = 0; j < DIM; ++j) {
-            permutedIndices[j] = indices[std::get<0>(attrs)[j]];
-        }
-
-        for (int j = DIM -1; j >=0; --j) {
-            idx += permutedIndices[j] * outStrides[j];
-        }
-        // Copy the value in output
-        output[idx] = input[i];
-
-        // Update indices for the next iteration
-        for (int j = DIM - 1; j >= 0; --j) {
-            if (indices[j] < inputDims[j] - 1) {
-                indices[j]++;
-                break;
-            } else {
-                indices[j] = 0;
-            }
-        }
-    }
-
-}
-namespace {
-// DIM = 2
-static Registrar<TransposeImpl2DForward_cpu> registrarTransposeImpl2DForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 2>);
-static Registrar<TransposeImpl2DForward_cpu> registrarTransposeImpl2DForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 2>);
-static Registrar<TransposeImpl2DForward_cpu> registrarTransposeImpl2DForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 2>);
-// DIM = 3
-static Registrar<TransposeImpl3DForward_cpu> registrarTransposeImpl3DForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 3>);
-static Registrar<TransposeImpl3DForward_cpu> registrarTransposeImpl3DForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 3>);
-static Registrar<TransposeImpl3DForward_cpu> registrarTransposeImpl3DForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 3>);
-// DIM = 4
-static Registrar<TransposeImpl4DForward_cpu> registrarTransposeImpl4DForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 4>);
-static Registrar<TransposeImpl4DForward_cpu> registrarTransposeImpl4DForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 4>);
-static Registrar<TransposeImpl4DForward_cpu> registrarTransposeImpl4DForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 4>);
-// DIM = 5
-static Registrar<TransposeImpl5DForward_cpu> registrarTransposeImpl5DForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 5>);
-static Registrar<TransposeImpl5DForward_cpu> registrarTransposeImpl5DForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 5>);
-static Registrar<TransposeImpl5DForward_cpu> registrarTransposeImpl5DForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 5>);
-// DIM = 6
-static Registrar<TransposeImpl6DForward_cpu> registrarTransposeImpl6DForward_cpu_Float32(
-        {DataType::Float32, DataType::Float32}, Aidge::TransposeImpl_cpu_forward_kernel<float, float, 6>);
-static Registrar<TransposeImpl6DForward_cpu> registrarTransposeImpl6DForward_cpu_Int32(
-        {DataType::Int32, DataType::Int32}, Aidge::TransposeImpl_cpu_forward_kernel<int, int, 6>);
-static Registrar<TransposeImpl6DForward_cpu> registrarTransposeImpl6DForward_cpu_Float64(
-        {DataType::Float64, DataType::Float64}, Aidge::TransposeImpl_cpu_forward_kernel<double, double, 6>);
-}  // namespace
-}  // namespace Aidge
-
-#endif /* AIDGE_CPU_OPERATOR_TRANSPOSEIMPL_FORWARD_KERNEL_H_ */

include/aidge/utils/sys_info/CpuVersionInfo.hpp

+#ifndef AIDGE_UTILS_SYS_INFO_CPU_VERSION_INFO_H
+#define AIDGE_UTILS_SYS_INFO_CPU_VERSION_INFO_H
+
+#include "aidge/utils/Log.hpp"
+
+namespace Aidge {
+
+#ifndef PROJECT_VERSION // Normally defined in CMakeLists.txt
+#define PROJECT_VERSION "Unknown version"
+#endif
+#ifndef GIT_COMMIT_HASH
+#define GIT_COMMIT_HASH ""
+#endif
+void showCpuVersion() {
+    Log::info("Aidge backend CPU: {} ({}), {} {}", PROJECT_VERSION, GIT_COMMIT_HASH, __DATE__, __TIME__);
+        // Compiler version
+    #if defined(__clang__)
+    /* Clang/LLVM. ---------------------------------------------- */
+        Log::info("Clang/LLVM compiler version: {}.{}.{}\n", __clang_major__ , __clang_minor__, __clang_patchlevel__);
+    #elif defined(__ICC) || defined(__INTEL_COMPILER)
+    /* Intel ICC/ICPC. ------------------------------------------ */
+        Log::info("Intel ICC/ICPC compiler version: {}\n", __INTEL_COMPILER);
+    #elif defined(__GNUC__) || defined(__GNUG__)
+    /* GNU GCC/G++. --------------------------------------------- */
+        Log::info("GNU GCC/G++ compiler version: {}.{}.{}", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
+    #elif defined(_MSC_VER)
+    /* Microsoft Visual Studio. --------------------------------- */
+        Log::info("Microsoft Visual Studio compiler version: {}\n", _MSC_VER);
+    #else
+        Log::info("Unknown compiler\n");
+    #endif
+
+}
+}  // namespace Aidge
+#endif  // AIDGE_UTILS_SYS_INFO_CPU_VERSION_INFO_H

python_binding/pybind_cpu.cpp

@@ -6,10 +6,13 @@ namespace py = pybind11;
 
 namespace Aidge {
 
-void init_Aidge(py::module& /*m*/){
+void init_cpu_sys_info(py::module& m);
 
+void init_Aidge(py::module& m){
+    init_cpu_sys_info(m);
 }
 
+
 PYBIND11_MODULE(aidge_backend_cpu, m) {
     init_Aidge(m);
 }