Skip to content
Snippets Groups Projects
Commit f203e3ac authored by Olivier BICHLER's avatar Olivier BICHLER
Browse files

Finished operators adaptation

parent 2fe30cc0
No related branches found
No related tags found
2 merge requests!93Release v0.3.0,!79Refactor OperatorImpl for backend/export
Pipeline #54307 failed
Stage: static_analysis
    Stage: build
      Stage: test
        Stage: coverage
          Stage: release
            Hide whitespace changes
            Inline Side-by-side
            Showing
            with 242 additions and 458 deletions
            include/aidge/backend/cpu/operator/AbsImpl.hpp
            + 6
            − 25
            View file @ f203e3ac
            ...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
            #ifndef AIDGE_CPU_OPERATOR_ABSIMPL_H_ #ifndef AIDGE_CPU_OPERATOR_ABSIMPL_H_
            #define AIDGE_CPU_OPERATOR_ABSIMPL_H_ #define AIDGE_CPU_OPERATOR_ABSIMPL_H_
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/Abs.hpp" #include "aidge/operator/Abs.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            ...@@ -20,31 +20,12 @@ ...@@ -20,31 +20,12 @@
            #include <vector> #include <vector>
            namespace Aidge { namespace Aidge {
            // class Abs_Op; // Operator implementation entry point for the backend
            using AbsImpl_cpu = OperatorImpl_cpu<Abs_Op,
            void(const std::size_t, const void*, void*)>;
            // compute kernel registry for forward and backward // Implementation entry point registration to Operator
            class AbsImplForward_cpu REGISTRAR(Abs_Op, "cpu", Aidge::AbsImpl_cpu::create);
            : public Registrable<AbsImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
            };
            class AbsImplBackward_cpu
            : public Registrable<AbsImplBackward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
            };
            class AbsImpl_cpu : public OperatorImpl {
            public:
            AbsImpl_cpu(const Abs_Op& op) : OperatorImpl(op, "cpu") {}
            static std::unique_ptr<AbsImpl_cpu> create(const Abs_Op& op) {
            return std::make_unique<AbsImpl_cpu>(op);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            static Registrar<Abs_Op> registrarAbsImpl_cpu("cpu", Aidge::AbsImpl_cpu::create);
            }
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ABSIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ABSIMPL_H_ */
            include/aidge/backend/cpu/operator/AbsImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/AbsImpl_kernels.hpp
            + 13
            − 11
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_ABSIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_ABSIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_ABSIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_ABSIMPL_KERNELS_H_
            #include <cmath> #include <cmath>
            ...@@ -32,14 +32,16 @@ void AbsImpl_cpu_forward_kernel(std::size_t inputLenght, ...@@ -32,14 +32,16 @@ void AbsImpl_cpu_forward_kernel(std::size_t inputLenght,
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<AbsImplForward_cpu> registrarAbsImplForward_cpu_Float32( REGISTRAR(AbsImpl_cpu,
            {DataType::Float32, DataType::Float32}, Aidge::AbsImpl_cpu_forward_kernel<float, float>); {DataType::Float32},
            static Registrar<AbsImplForward_cpu> registrarAbsImplForward_cpu_Int32( {ProdConso::inPlaceModel, Aidge::AbsImpl_cpu_forward_kernel<float, float>, nullptr});
            {DataType::Int32, DataType::Int32}, Aidge::AbsImpl_cpu_forward_kernel<int, int>); REGISTRAR(AbsImpl_cpu,
            static Registrar<AbsImplForward_cpu> registrarAbsImplForward_cpu_Float64( {DataType::Float64},
            {DataType::Float64, DataType::Float64}, Aidge::AbsImpl_cpu_forward_kernel<double, double>); {ProdConso::inPlaceModel, Aidge::AbsImpl_cpu_forward_kernel<double, double>, nullptr});
            } // namespace REGISTRAR(AbsImpl_cpu,
            {DataType::Int32},
            {ProdConso::inPlaceModel, Aidge::AbsImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ABSIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ABSIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/AddImpl.hpp
            + 6
            − 24
            View file @ f203e3ac
            ...@@ -17,36 +17,18 @@ ...@@ -17,36 +17,18 @@
            #include <string> #include <string>
            #include <vector> #include <vector>
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/Add.hpp" #include "aidge/operator/Add.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            namespace Aidge { namespace Aidge {
            // Operator implementation entry point for the backend
            using AddImpl_cpu = OperatorImpl_cpu<Add_Op,
            void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>;
            // compute kernel registry for forward and backward // Implementation entry point registration to Operator
            class AddImplForward_cpu REGISTRAR(Add_Op, "cpu", Aidge::AddImpl_cpu::create);
            : public Registrable<AddImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>> {};
            class AddImplBackward_cpu
            : public Registrable<AddImplBackward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::vector<const void*>, const std::vector<std::vector<std::size_t>>&, const std::size_t, const std::vector<std::size_t>&, void*)>> {};
            class AddImpl_cpu : public OperatorImpl {
            public:
            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);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            static Registrar<Add_Op> registrarAddImpl_cpu("cpu", Aidge::AddImpl_cpu::create);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_H_ */
            include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/AddImpl_kernels.hpp
            + 16
            − 13
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_ADDIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_ADDIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_ADDIMPL_KERNELS_H_
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            ...@@ -41,16 +41,19 @@ void AddImpl_cpu_forward_kernel(const std::vector<const void*> inputs_, const st ...@@ -41,16 +41,19 @@ void AddImpl_cpu_forward_kernel(const std::vector<const void*> inputs_, const st
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Float32( REGISTRAR(AddImpl_cpu,
            {DataType::Float32, DataType::Float32}, Aidge::AddImpl_cpu_forward_kernel<float, float>); {{DataType::Any}, {DataType::Float32}},
            static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Float64( {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<float, float>, nullptr});
            {DataType::Float64, DataType::Float64}, Aidge::AddImpl_cpu_forward_kernel<double, double>); REGISTRAR(AddImpl_cpu,
            static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Int32( {{DataType::Any}, {DataType::Float64}},
            {DataType::Int32, DataType::Int32}, Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>); {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<double, double>, nullptr});
            static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Int64( REGISTRAR(AddImpl_cpu,
            {DataType::Int64, DataType::Int64}, Aidge::AddImpl_cpu_forward_kernel<std::int64_t, std::int64_t>); {{DataType::Any}, {DataType::Int32}},
            } // namespace {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
            REGISTRAR(AddImpl_cpu,
            {{DataType::Any}, {DataType::Int64}},
            {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int64_t, std::int64_t>, nullptr});
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_KERNELS_H_ */
            \ No newline at end of file \ No newline at end of file
            include/aidge/backend/cpu/operator/AndImpl.hpp
            + 6
            − 23
            View file @ f203e3ac
            ...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
            #ifndef AIDGE_CPU_OPERATOR_ANDIMPL_H_ #ifndef AIDGE_CPU_OPERATOR_ANDIMPL_H_
            #define AIDGE_CPU_OPERATOR_ANDIMPL_H_ #define AIDGE_CPU_OPERATOR_ANDIMPL_H_
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/And.hpp" #include "aidge/operator/And.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            ...@@ -21,29 +21,12 @@ ...@@ -21,29 +21,12 @@
            #include <vector> #include <vector>
            namespace Aidge { namespace Aidge {
            // compute kernel registry for forward and backward // Operator implementation entry point for the backend
            class AndImplForward_cpu using AndImpl_cpu = OperatorImpl_cpu<And_Op,
            : public Registrable<AndImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>> { void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>;
            };
            class AndImplBackward_cpu
            : public Registrable<AndImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)>> {
            };
            class AndImpl_cpu : public OperatorImpl { // Implementation entry point registration to Operator
            public: REGISTRAR(And_Op, "cpu", Aidge::AndImpl_cpu::create);
            AndImpl_cpu(const And_Op& op) : OperatorImpl(op, "cpu") {}
            static std::unique_ptr<AndImpl_cpu> create(const And_Op& op) {
            return std::make_unique<AndImpl_cpu>(op);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            static Registrar<And_Op> registrarAndImpl_cpu("cpu", Aidge::AndImpl_cpu::create);
            }
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ANDIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ANDIMPL_H_ */
            include/aidge/backend/cpu/operator/AndImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/AndImpl_kernels.hpp
            + 16
            − 17
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_ANDIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_ANDIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_ANDIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_ANDIMPL_KERNELS_H_
            #include "aidge/backend/cpu/data/Broadcasting.hpp" #include "aidge/backend/cpu/data/Broadcasting.hpp"
            #include "aidge/backend/cpu/operator/AndImpl.hpp" #include "aidge/backend/cpu/operator/AndImpl.hpp"
            ...@@ -45,20 +45,19 @@ void AndImpl_cpu_forward_kernel(const std::vector<std::size_t>& input1Dims, ...@@ -45,20 +45,19 @@ void AndImpl_cpu_forward_kernel(const std::vector<std::size_t>& input1Dims,
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<AndImplForward_cpu> registrarAndImplForward_cpu_Float32( REGISTRAR(AndImpl_cpu,
            {DataType::Float32, DataType::Float32, DataType::Float32}, {DataType::Float32},
            Aidge::AndImpl_cpu_forward_kernel<float, float, float>); {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<float, float, float>, nullptr});
            static Registrar<AndImplForward_cpu> registrarAndImplForward_cpu_Float64( REGISTRAR(AndImpl_cpu,
            {DataType::Float64, DataType::Float64, DataType::Float64}, {DataType::Float64},
            Aidge::AndImpl_cpu_forward_kernel<double, double, double>); {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<double, double, double>, nullptr});
            static Registrar<AndImplForward_cpu> registrarAndImplForward_cpu_Int32( REGISTRAR(AndImpl_cpu,
            {DataType::Int32, DataType::Int32, DataType::Int32}, {DataType::Int32},
            Aidge::AndImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>); {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>, nullptr});
            static Registrar<AndImplForward_cpu> registrarAndImplForward_cpu_Int64( REGISTRAR(AndImpl_cpu,
            {DataType::Int64, DataType::Int64, DataType::Int64}, {DataType::Int64},
            Aidge::AndImpl_cpu_forward_kernel<std::int64_t, std::int64_t, std::int64_t>); {ProdConso::inPlaceModel, Aidge::AndImpl_cpu_forward_kernel<std::int64_t, std::int64_t, std::int64_t>, nullptr});
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ANDIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ANDIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/ArgMaxImpl.hpp
            + 11
            − 33
            View file @ f203e3ac
            ...@@ -17,44 +17,22 @@ ...@@ -17,44 +17,22 @@
            #include <tuple> #include <tuple>
            #include <vector> #include <vector>
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/ArgMax.hpp" #include "aidge/operator/ArgMax.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            namespace Aidge { namespace Aidge {
            class ArgMaxImplForward_cpu // Operator implementation entry point for the backend
            : public Registrable<ArgMaxImplForward_cpu, using ArgMaxImpl_cpu = OperatorImpl_cpu<ArgMax_Op,
            std::tuple<DataType, DataType>, void(std::int32_t,
            std::function<void(std::int32_t, DimSize_t,
            DimSize_t, const std::vector<DimSize_t>&,
            const std::vector<DimSize_t>&, const void *,
            const void *, void *)>;
            void *)>> {};
            class ArgMaxImplBackward_cpu // Implementation entry point registration to Operator
            : public Registrable<ArgMaxImplBackward_cpu, REGISTRAR(ArgMax_Op, "cpu", Aidge::ArgMaxImpl_cpu::create);
            std::tuple<DataType, DataType>,
            std::function<void(std::int32_t,
            DimSize_t,
            const std::vector<DimSize_t>&,
            const void *,
            void *)>> {};
            class ArgMaxImpl_cpu : public OperatorImpl {
            public:
            ArgMaxImpl_cpu(const ArgMax_Op& op) : OperatorImpl(op, "cpu") {}
            static std::unique_ptr<ArgMaxImpl_cpu> create(const ArgMax_Op &op) {
            return std::make_unique<ArgMaxImpl_cpu>(op);
            }
            public:
            void forward() override;
            };
            namespace {
            static Registrar<ArgMax_Op> registrarArgMaxImpl_cpu("cpu", Aidge::ArgMaxImpl_cpu::create);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ARGMAXIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ARGMAXIMPL_H_ */
            include/aidge/backend/cpu/operator/ArgMaxImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/ArgMaxImpl_kernels.hpp
            + 13
            − 11
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_ARGMAXIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_ARGMAXIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_ARGMAXIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_ARGMAXIMPL_KERNELS_H_
            #include <algorithm> // std::for_each #include <algorithm> // std::for_each
            #include <cstddef> // std::size_t #include <cstddef> // std::size_t
            ...@@ -72,14 +72,16 @@ void ArgMaxImpl_cpu_forward_kernel(std::int32_t axis_, ...@@ -72,14 +72,16 @@ void ArgMaxImpl_cpu_forward_kernel(std::int32_t axis_,
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<ArgMaxImplForward_cpu> registrarArgMaxImplForward_cpu_Float32( REGISTRAR(ArgMaxImpl_cpu,
            {DataType::Float32, DataType::Float32}, Aidge::ArgMaxImpl_cpu_forward_kernel<float, float>); {DataType::Float32},
            static Registrar<ArgMaxImplForward_cpu> registrarArgMaxImplForward_cpu_Int32( {ProdConso::defaultModel, Aidge::ArgMaxImpl_cpu_forward_kernel<float, float>, nullptr});
            {DataType::Int32, DataType::Int32}, Aidge::ArgMaxImpl_cpu_forward_kernel<int, int>); REGISTRAR(ArgMaxImpl_cpu,
            static Registrar<ArgMaxImplForward_cpu> registrarArgMaxImplForward_cpu_Float64( {DataType::Float64},
            {DataType::Float64, DataType::Float64}, Aidge::ArgMaxImpl_cpu_forward_kernel<double, double>); {ProdConso::defaultModel, Aidge::ArgMaxImpl_cpu_forward_kernel<double, double>, nullptr});
            } // namespace REGISTRAR(ArgMaxImpl_cpu,
            {DataType::Int32},
            {ProdConso::defaultModel, Aidge::ArgMaxImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ARGMAXIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ARGMAXIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
            + 12
            − 37
            View file @ f203e3ac
            ...@@ -17,49 +17,24 @@ ...@@ -17,49 +17,24 @@
            #include <tuple> #include <tuple>
            #include <vector> #include <vector>
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/AvgPooling.hpp" #include "aidge/operator/AvgPooling.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            #include "aidge/backend/cpu/data/GetCPUPtr.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
            namespace Aidge { namespace Aidge {
            // class AvgPooling_Op; // Operator implementation entry point for the backend
            using AvgPooling2D_Op = AvgPooling_Op<2>;
            // compute kernel registry for forward and backward using AvgPoolingImpl2D_cpu = OperatorImpl_cpu<AvgPooling_Op<2>,
            class AvgPoolingImpl2DForward_cpu void(const std::array<DimSize_t, 2>&,
            : public Registrable<AvgPoolingImpl2DForward_cpu, const std::array<DimSize_t, 2>&,
            std::tuple<DataType, DataType>, const std::array<DimSize_t, 4>&,
            std::function<void(const std::array<DimSize_t, 2>&, const void *,
            const std::array<DimSize_t, 2>&, void *)>;
            const std::array<DimSize_t, 4>&,
            const void *, // Implementation entry point registration to Operator
            void *)>> {}; REGISTRAR(AvgPooling2D_Op, "cpu", Aidge::AvgPoolingImpl2D_cpu::create);
            class AvgPoolingImpl2DBackward_cpu
            : public Registrable<AvgPoolingImpl2DBackward_cpu,
            std::tuple<DataType, DataType>,
            std::function<void(const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 4>&,
            const void *,
            void *)>> {};
            class AvgPoolingImpl2D_cpu : public OperatorImpl {
            public:
            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);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            // add cpu backend to AvgPooling_Op<2> implementation registry
            static Registrar<AvgPooling_Op<2>> registrarAvgPoolingImpl2D_cpu("cpu", Aidge::AvgPoolingImpl2D_cpu::create);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_H_ */
            include/aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/AvgPoolingImpl_kernels.hpp
            + 13
            − 14
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_KERNELS_H_
            #include <array> #include <array>
            #include <tuple> #include <tuple>
            ...@@ -101,17 +101,16 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideD ...@@ -101,17 +101,16 @@ void AvgPoolingImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideD
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<AvgPoolingImpl2DForward_cpu> registrarAvgPoolingImpl2DForward_cpu_Float32( REGISTRAR(AvgPoolingImpl2D_cpu,
            std::tuple<DataType, DataType>({DataType::Float32, DataType::Float32}), {{DataType::Float32, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
            Aidge::AvgPoolingImpl2D_cpu_forward_kernel<float, float>); {ProdConso::inPlaceModel, Aidge::AvgPoolingImpl2D_cpu_forward_kernel<float, float>, nullptr});
            static Registrar<AvgPoolingImpl2DForward_cpu> registrarAvgPoolingImpl2DForward_cpu_Int32( REGISTRAR(AvgPoolingImpl2D_cpu,
            {DataType::Int32, DataType::Int32}, {{DataType::Int32, DataFormat::NCHW}, {DataType::Int32, DataFormat::NCHW}},
            Aidge::AvgPoolingImpl2D_cpu_forward_kernel<int, int>); {ProdConso::inPlaceModel, Aidge::AvgPoolingImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
            static Registrar<AvgPoolingImpl2DForward_cpu> registrarAvgPoolingImpl2DForward_cpu_Float64( REGISTRAR(AvgPoolingImpl2D_cpu,
            {DataType::Float64, DataType::Float64}, {{DataType::Float64, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
            Aidge::AvgPoolingImpl2D_cpu_forward_kernel<double, double>); {ProdConso::inPlaceModel, Aidge::AvgPoolingImpl2D_cpu_forward_kernel<double, double>, nullptr});
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_AVGPOOLINGIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/BatchNormImpl.hpp
            + 17
            − 46
            View file @ f203e3ac
            ...@@ -17,58 +17,29 @@ ...@@ -17,58 +17,29 @@
            #include <tuple> #include <tuple>
            #include <vector> #include <vector>
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/BatchNorm.hpp" #include "aidge/operator/BatchNorm.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            #include "aidge/backend/cpu/data/GetCPUPtr.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
            namespace Aidge { namespace Aidge {
            // class BatchNorm_Op; // Operator implementation entry point for the backend
            using BatchNorm2D_Op = BatchNorm_Op<2>;
            // compute kernel registry for forward and backward using BatchNormImpl2D_cpu = OperatorImpl_cpu<BatchNorm_Op<2>,
            class BatchNormImpl2DForward_cpu void(float,
            : public Registrable<BatchNormImpl2DForward_cpu, float,
            std::tuple<DataType, DataType, DataType>, const std::array<DimSize_t, 4> &,
            std::function<void(float, const void *,
            float, const void *,
            const std::array<DimSize_t, 4> &, const void *,
            const void *, void *,
            const void *, void *,
            const void *, void *,
            void *, const bool)>;
            void *,
            void *, // Implementation entry point registration to Operator
            const bool)>> {}; REGISTRAR(BatchNorm2D_Op, "cpu", Aidge::BatchNormImpl2D_cpu::create);
            class BatchNormImpl2DBackward_cpu
            : public Registrable<BatchNormImpl2DBackward_cpu,
            std::tuple<DataType, DataType, DataType>,
            std::function<void(float,
            float,
            const std::array<DimSize_t, 4> &,
            const void *,
            const void *,
            const void *,
            void *,
            void *,
            void *)>> {};
            class BatchNormImpl2D_cpu : public OperatorImpl {
            public:
            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);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            // add cpu backend to BatchNorm_Op<2> implementation registry
            static Registrar<BatchNorm_Op<2>> registrarBatchNormImpl2D_cpu("cpu", Aidge::BatchNormImpl2D_cpu::create);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_BATCHNORMIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_BATCHNORMIMPL_H_ */
            include/aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/BatchNormImpl_kernels.hpp
            + 7
            − 12
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_BATCHNORMIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_BATCHNORMIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_BATCHNORMIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_BATCHNORMIMPL_KERNELS_H_
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            ...@@ -96,15 +96,10 @@ void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std ...@@ -96,15 +96,10 @@ void BatchNormImpl2D_cpu_forward_kernel(float epsilon, float momentum, const std
            } }
            } }
            // Kernels registration to implementation entry point
            REGISTRAR(BatchNormImpl2D_cpu,
            {{DataType::Float32, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
            {ProdConso::inPlaceModel, Aidge::BatchNormImpl2D_cpu_forward_kernel<float, float, float>, nullptr});
            namespace {
            static Registrar<BatchNormImpl2DForward_cpu> registrarBatchNormImpl2DForward_cpu_Float32(
            {DataType::Float32, DataType::Float32, DataType::Float32},
            Aidge::BatchNormImpl2D_cpu_forward_kernel<float, float, float>);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_BATCHNORMIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_BATCHNORMIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
            + 27
            − 73
            View file @ f203e3ac
            ...@@ -17,85 +17,39 @@ ...@@ -17,85 +17,39 @@
            #include <tuple> #include <tuple>
            #include <vector> #include <vector>
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/ConvDepthWise.hpp" #include "aidge/operator/ConvDepthWise.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            #include "aidge/backend/cpu/data/GetCPUPtr.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
            namespace Aidge { namespace Aidge {
            // class ConvDepthWise_Op; // Operator implementation entry point for the backend
            // compute kernel registry for forward and backward using ConvDepthWise1D_Op = ConvDepthWise_Op<1>;
            class ConvDepthWiseImpl1DForward_cpu using ConvDepthWiseImpl1D_cpu = OperatorImpl_cpu<ConvDepthWise_Op<1>,
            : public Registrable<ConvDepthWiseImpl1DForward_cpu, void(const std::array<DimSize_t, 1>&,
            std::tuple<DataType, DataType, DataType, DataType>, const std::array<DimSize_t, 1>&,
            std::function<void(const std::array<DimSize_t, 1>&, const std::array<DimSize_t, 1>&,
            const std::array<DimSize_t, 1>&, const std::array<DimSize_t, 3>&,
            const std::array<DimSize_t, 1>&, const void *,
            const std::array<DimSize_t, 3>&, const void *,
            const void *, const void *,
            const void *, void *)>;
            const void *,
            void *)>> {}; using ConvDepthWise2D_Op = ConvDepthWise_Op<2>;
            using ConvDepthWiseImpl2D_cpu = OperatorImpl_cpu<ConvDepthWise_Op<2>,
            class ConvDepthWiseImpl1D_cpu : public OperatorImpl { void(const std::array<DimSize_t, 2>&,
            public: const std::array<DimSize_t, 2>&,
            ConvDepthWiseImpl1D_cpu(const ConvDepthWise_Op<1> &op) : OperatorImpl(op, "cpu") {} const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 4> &,
            static std::unique_ptr<ConvDepthWiseImpl1D_cpu> create(const ConvDepthWise_Op<1> &op) { const void *,
            return std::make_unique<ConvDepthWiseImpl1D_cpu>(op); const void *,
            } const void *,
            void *)>;
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override; // Implementation entry point registration to Operator
            }; REGISTRAR(ConvDepthWise1D_Op, "cpu", Aidge::ConvDepthWiseImpl1D_cpu::create);
            REGISTRAR(ConvDepthWise2D_Op, "cpu", Aidge::ConvDepthWiseImpl2D_cpu::create);
            namespace {
            // add cpu backend to ConvDepthWise_Op<1> implementation registry
            static Registrar<ConvDepthWise_Op<1>> registrarConvDepthWiseImpl1D_cpu("cpu", Aidge::ConvDepthWiseImpl1D_cpu::create);
            } // namespace
            // compute kernel registry for forward and backward
            class ConvDepthWiseImpl2DForward_cpu
            : public Registrable<ConvDepthWiseImpl2DForward_cpu,
            std::tuple<DataType, DataType, DataType, DataType>,
            std::function<void(const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 4> &,
            const void *,
            const void *,
            const void *,
            void *)>> {};
            class ConvDepthWiseImpl2DBackward_cpu
            : public Registrable<ConvDepthWiseImpl2DBackward_cpu,
            std::tuple<DataType, DataType, DataType, DataType>,
            std::function<void(const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&,
            bool,
            const std::array<DimSize_t, 4> &,
            const void *,
            const void *,
            const void *,
            void *)>> {};
            class ConvDepthWiseImpl2D_cpu : public OperatorImpl {
            public:
            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);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            // add cpu backend to ConvDepthWise_Op<2> implementation registry
            static Registrar<ConvDepthWise_Op<2>> registrarConvDepthWiseImpl2D_cpu("cpu", Aidge::ConvDepthWiseImpl2D_cpu::create);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_H_ */
            include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/ConvDepthWiseImpl_kernels.hpp
            + 23
            − 25
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_KERNELS_H_
            #include <algorithm> #include <algorithm>
            #include <array> #include <array>
            ...@@ -86,17 +86,16 @@ void ConvDepthWiseImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& stri ...@@ -86,17 +86,16 @@ void ConvDepthWiseImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& stri
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DForward_cpu_Float32( REGISTRAR(ConvDepthWiseImpl1D_cpu,
            {DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
            Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<float, float, float, float>); {ProdConso::inPlaceModel, Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<float, float, float, float>, nullptr});
            static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DForward_cpu_Int32( REGISTRAR(ConvDepthWiseImpl1D_cpu,
            {DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Int32, DataFormat::NCHW}},
            Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t, std::int32_t>); {ProdConso::inPlaceModel, Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t, std::int32_t>, nullptr});
            static Registrar<ConvDepthWiseImpl1DForward_cpu> registrarConvDepthWiseImpl1DForward_cpu_Float64( REGISTRAR(ConvDepthWiseImpl1D_cpu,
            {DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
            Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<double, double, double, double>); {ProdConso::inPlaceModel, Aidge::ConvDepthWiseImpl1D_cpu_forward_kernel<double, double, double, double>, nullptr});
            } // namespace
            /** /**
            ...@@ -187,17 +186,16 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& stri ...@@ -187,17 +186,16 @@ void ConvDepthWiseImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& stri
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<ConvDepthWiseImpl2DForward_cpu> registrarConvDepthWiseImpl2DForward_cpu_Float32( REGISTRAR(ConvDepthWiseImpl2D_cpu,
            {DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
            Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<float, float, float, float>); {ProdConso::inPlaceModel, Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<float, float, float, float>, nullptr});
            static Registrar<ConvDepthWiseImpl2DForward_cpu> registrarConvDepthWiseImpl2DForward_cpu_Int32( REGISTRAR(ConvDepthWiseImpl2D_cpu,
            {DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Int32, DataFormat::NCHW}},
            Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t, std::int32_t>); {ProdConso::inPlaceModel, Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t, std::int32_t>, nullptr});
            static Registrar<ConvDepthWiseImpl2DForward_cpu> registrarConvDepthWiseImpl2DForward_cpu_Float64( REGISTRAR(ConvDepthWiseImpl2D_cpu,
            {DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
            Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<double, double, double, double>); {ProdConso::inPlaceModel, Aidge::ConvDepthWiseImpl2D_cpu_forward_kernel<double, double, double, double>, nullptr});
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_CONVDEPTHWISEIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/ConvImpl.hpp
            + 16
            − 16
            View file @ f203e3ac
            ...@@ -28,26 +28,26 @@ namespace Aidge { ...@@ -28,26 +28,26 @@ namespace Aidge {
            using Conv1D_Op = Conv_Op<1>; using Conv1D_Op = Conv_Op<1>;
            using ConvImpl1D_cpu = OperatorImpl_cpu<Conv_Op<1>, using ConvImpl1D_cpu = OperatorImpl_cpu<Conv_Op<1>,
            void(const std::array<DimSize_t, 1>&, void(const std::array<DimSize_t, 1>&,
            const std::array<DimSize_t, 1>&, const std::array<DimSize_t, 1>&,
            const std::array<DimSize_t, 1>&, const std::array<DimSize_t, 1>&,
            const std::array<DimSize_t, 3> &, const std::array<DimSize_t, 3> &,
            DimSize_t, DimSize_t,
            const void *, const void *,
            const void *, const void *,
            const void *, const void *,
            void *)>; void *)>;
            using Conv2D_Op = Conv_Op<2>; using Conv2D_Op = Conv_Op<2>;
            using ConvImpl2D_cpu = OperatorImpl_cpu<Conv_Op<2>, using ConvImpl2D_cpu = OperatorImpl_cpu<Conv_Op<2>,
            void(const std::array<DimSize_t, 2>&, void(const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&, const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 2>&, const std::array<DimSize_t, 2>&,
            const std::array<DimSize_t, 4> &, const std::array<DimSize_t, 4> &,
            DimSize_t, DimSize_t,
            const void *, const void *,
            const void *, const void *,
            const void *, const void *,
            void *)>; void *)>;
            // Implementation entry point registration to Operator // Implementation entry point registration to Operator
            REGISTRAR(Conv1D_Op, "cpu", Aidge::ConvImpl1D_cpu::create); REGISTRAR(Conv1D_Op, "cpu", Aidge::ConvImpl1D_cpu::create);
            ......
            include/aidge/backend/cpu/operator/ConvImpl_kernels.hpp
            + 2
            − 0
            View file @ f203e3ac
            ...@@ -92,6 +92,7 @@ void ConvImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& strideDims, ...@@ -92,6 +92,7 @@ void ConvImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& strideDims,
            } }
            } }
            // Kernels registration to implementation entry point
            REGISTRAR(ConvImpl1D_cpu, REGISTRAR(ConvImpl1D_cpu,
            {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
            {ProdConso::inPlaceModel, Aidge::ConvImpl1D_cpu_forward_kernel<float, float, float, float>, nullptr}); {ProdConso::inPlaceModel, Aidge::ConvImpl1D_cpu_forward_kernel<float, float, float, float>, nullptr});
            ...@@ -197,6 +198,7 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims, ...@@ -197,6 +198,7 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
            } }
            } }
            // Kernels registration to implementation entry point
            REGISTRAR(ConvImpl2D_cpu, REGISTRAR(ConvImpl2D_cpu,
            {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
            {ProdConso::inPlaceModel, Aidge::ConvImpl2D_cpu_forward_kernel<float, float, float, float>, nullptr}); {ProdConso::inPlaceModel, Aidge::ConvImpl2D_cpu_forward_kernel<float, float, float, float>, nullptr});
            ......
            include/aidge/backend/cpu/operator/DivImpl.hpp
            + 6
            − 26
            View file @ f203e3ac
            ...@@ -16,38 +16,18 @@ ...@@ -16,38 +16,18 @@
            #include <tuple> #include <tuple>
            #include <vector> #include <vector>
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/Div.hpp" #include "aidge/operator/Div.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            namespace Aidge { namespace Aidge {
            // Operator implementation entry point for the backend
            using DivImpl_cpu = OperatorImpl_cpu<Div_Op,
            void(const std::size_t, const std::size_t, const std::size_t, const void*, const void*,void*)>;
            // compute kernel registry for forward and backward // Implementation entry point registration to Operator
            class DivImplForward_cpu REGISTRAR(Div_Op, "cpu", Aidge::DivImpl_cpu::create);
            // : public Registrable<DivImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*,void*)>> {
            : public Registrable<DivImplForward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::size_t, const std::size_t, const std::size_t, const void*, const void*,void*)>> {
            };
            class DivImplBackward_cpu
            : public Registrable<DivImplBackward_cpu, std::tuple<DataType, DataType, DataType>, std::function<void(const std::vector<std::size_t>&, const std::vector<std::size_t>&, const std::vector<std::size_t>&, const void*, const void*, void*)>> {
            };
            class DivImpl_cpu : public OperatorImpl {
            public:
            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);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override final;
            };
            namespace {
            static Registrar<Div_Op> registrarDivImpl_cpu("cpu", Aidge::DivImpl_cpu::create);
            }
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_DIVIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_DIVIMPL_H_ */
            include/aidge/backend/cpu/operator/DivImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/DivImpl_kernels.hpp
            + 13
            − 16
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_DIVIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_DIVIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_DIVIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_DIVIMPL_KERNELS_H_
            #include <numeric> // std::accumulate #include <numeric> // std::accumulate
            #include <cstddef> // std::size_t #include <cstddef> // std::size_t
            ...@@ -69,19 +69,16 @@ constexpr void DivImpl_cpu_forward_kernel(const std::size_t input1size_, ...@@ -69,19 +69,16 @@ constexpr void DivImpl_cpu_forward_kernel(const std::size_t input1size_,
            } }
            } }
            // Kernels registration to implementation entry point
            REGISTRAR(DivImpl_cpu,
            namespace { {DataType::Float32},
            static Registrar<DivImplForward_cpu> registrarDivImplForward_cpu_Float32( {ProdConso::inPlaceModel, Aidge::DivImpl_cpu_forward_kernel<float, float, float>, nullptr});
            {DataType::Float32, DataType::Float32, DataType::Float32}, REGISTRAR(DivImpl_cpu,
            Aidge::DivImpl_cpu_forward_kernel<float, float, float>); {DataType::Float64},
            static Registrar<DivImplForward_cpu> registrarDivImplForward_cpu_Int32( {ProdConso::inPlaceModel, Aidge::DivImpl_cpu_forward_kernel<double, double, double>, nullptr});
            {DataType::Int32, DataType::Int32, DataType::Int32}, REGISTRAR(DivImpl_cpu,
            Aidge::DivImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>); {DataType::Int32},
            static Registrar<DivImplForward_cpu> registrarDivImplForward_cpu_Float64( {ProdConso::inPlaceModel, Aidge::DivImpl_cpu_forward_kernel<std::int32_t, std::int32_t, std::int32_t>, nullptr});
            {DataType::Float64, DataType::Float64, DataType::Float64},
            Aidge::DivImpl_cpu_forward_kernel<double, double, double>);
            } // namespace
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_DIVIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_DIVIMPL_KERNELS_H_ */
            include/aidge/backend/cpu/operator/ErfImpl.hpp
            + 6
            − 25
            View file @ f203e3ac
            ...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
            #ifndef AIDGE_CPU_OPERATOR_ERFIMPL_H_ #ifndef AIDGE_CPU_OPERATOR_ERFIMPL_H_
            #define AIDGE_CPU_OPERATOR_ERFIMPL_H_ #define AIDGE_CPU_OPERATOR_ERFIMPL_H_
            #include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
            #include "aidge/operator/Erf.hpp" #include "aidge/operator/Erf.hpp"
            #include "aidge/utils/Registrar.hpp" #include "aidge/utils/Registrar.hpp"
            #include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
            ...@@ -20,31 +20,12 @@ ...@@ -20,31 +20,12 @@
            #include <vector> #include <vector>
            namespace Aidge { namespace Aidge {
            // class Erf_Op; // Operator implementation entry point for the backend
            using ErfImpl_cpu = OperatorImpl_cpu<Erf_Op,
            void(const std::size_t, const void*, void*)>;
            // compute kernel registry for forward and backward // Implementation entry point registration to Operator
            class ErfImplForward_cpu REGISTRAR(Erf_Op, "cpu", Aidge::ErfImpl_cpu::create);
            : public Registrable<ErfImplForward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
            };
            class ErfImplBackward_cpu
            : public Registrable<ErfImplBackward_cpu, std::tuple<DataType, DataType>, std::function<void(const std::size_t, const void*, void*)>> {
            };
            class ErfImpl_cpu : public OperatorImpl {
            public:
            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);
            }
            std::shared_ptr<ProdConso> getProdConso() const override { return std::make_unique<ProdConso>(mOp, true); };
            void forward() override;
            };
            namespace {
            static Registrar<Erf_Op> registrarErfImpl_cpu("cpu", Aidge::ErfImpl_cpu::create);
            }
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ERFIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ERFIMPL_H_ */
            include/aidge/backend/cpu/operator/ErfImpl_forward_kernels.hpp → include/aidge/backend/cpu/operator/ErfImpl_kernels.hpp
            + 13
            − 11
            View file @ f203e3ac
            ...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
            * *
            ********************************************************************************/ ********************************************************************************/
            #ifndef AIDGE_CPU_OPERATOR_ERFIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_ERFIMPL_KERNELS_H_
            #define AIDGE_CPU_OPERATOR_ERFIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_ERFIMPL_KERNELS_H_
            #include <cmath> #include <cmath>
            ...@@ -32,14 +32,16 @@ void ErfImpl_cpu_forward_kernel(std::size_t inputLenght, ...@@ -32,14 +32,16 @@ void ErfImpl_cpu_forward_kernel(std::size_t inputLenght,
            } }
            } }
            namespace { // Kernels registration to implementation entry point
            static Registrar<ErfImplForward_cpu> registrarErfImplForward_cpu_Float32( REGISTRAR(ErfImpl_cpu,
            {DataType::Float32, DataType::Float32}, Aidge::ErfImpl_cpu_forward_kernel<float, float>); {DataType::Float32},
            static Registrar<ErfImplForward_cpu> registrarErfImplForward_cpu_Int32( {ProdConso::inPlaceModel, Aidge::ErfImpl_cpu_forward_kernel<float, float>, nullptr});
            {DataType::Int32, DataType::Int32}, Aidge::ErfImpl_cpu_forward_kernel<int, int>); REGISTRAR(ErfImpl_cpu,
            static Registrar<ErfImplForward_cpu> registrarErfImplForward_cpu_Float64( {DataType::Float64},
            {DataType::Float64, DataType::Float64}, Aidge::ErfImpl_cpu_forward_kernel<double, double>); {ProdConso::inPlaceModel, Aidge::ErfImpl_cpu_forward_kernel<double, double>, nullptr});
            } // namespace REGISTRAR(ErfImpl_cpu,
            {DataType::Int32},
            {ProdConso::inPlaceModel, Aidge::ErfImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
            } // namespace Aidge } // namespace Aidge
            #endif /* AIDGE_CPU_OPERATOR_ERFIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_ERFIMPL_KERNELS_H_ */
            0% or .
            You are about to add 0 people to the discussion. Proceed with caution.
            Finish editing this message first!
            Please register or to comment

            Copyright © Eclipse Foundation, Inc. All Rights Reserved.     Privacy Policy | Terms of Use | Copyright Agent