Skip to content
Snippets Groups Projects
Commit 329ddc3c authored by Noam Zerah's avatar Noam Zerah
Browse files

Merge branch 'dev' of...

Merge branch 'dev' of https://gitlab.eclipse.org/eclipse/aidge/aidge_backend_cpu into feat_operator_bitshift
merge dev -> cpu
parents 1eb1cec3 da37fdb4
No related branches found
No related tags found
1 merge request!88Added Bitshift Operator
Showing
with 346 additions and 587 deletions
...@@ -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>, void(const std::size_t, const void*, void*)> {
};
class AbsImplBackward_cpu
: public Registrable<AbsImplBackward_cpu, std::tuple<DataType, DataType>, 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);
}
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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_ */
...@@ -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_ */
...@@ -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>, 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>, 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);
}
Elts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
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_ */
...@@ -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>); {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{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( {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{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>); {ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{DataType::Int32}},
} // namespace {ProdConso::inPlaceModel, Aidge::AddImpl_cpu_forward_kernel<std::int32_t, std::int32_t>, nullptr});
REGISTRAR(AddImpl_cpu,
{ImplSpec::IOSpec{DataType::Any}, ImplSpec::IOSpec{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
...@@ -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>, 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>, 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);
}
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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_ */
...@@ -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_ */
...@@ -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,
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>,
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_ */
...@@ -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_ */
...@@ -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>&,
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>,
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);
}
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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_ */
...@@ -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_ */
...@@ -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> &,
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>,
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);
}
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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_ */
...@@ -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_ */
...@@ -16,36 +16,18 @@ ...@@ -16,36 +16,18 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
#include "aidge/operator/ConstantOfShape.hpp" #include "aidge/operator/ConstantOfShape.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 ConstantOfShape_op; // Operator implementation entry point for the backend
using ConstantOfShapeImpl_cpu = OperatorImpl_cpu<ConstantOfShape_Op,
void(const std::vector<DimSize_t>, const Tensor&, void *)>;
class ConstantOfShapeImplForward_cpu // Implementation entry point registration to Operator
: public Registrable< REGISTRAR(ConstantOfShape_Op, "cpu", Aidge::ConstantOfShapeImpl_cpu::create);
ConstantOfShapeImplForward_cpu, std::tuple<DataType>,
void(const std::vector<DimSize_t>, const Tensor&, void *)> {};
class ConstantOfShapeImpl_cpu : public OperatorImpl {
public:
ConstantOfShapeImpl_cpu(const ConstantOfShape_Op &op)
: OperatorImpl(op, "cpu") {}
static std::unique_ptr<ConstantOfShapeImpl_cpu>
create(const ConstantOfShapeImpl_cpu &op) {
return std::make_unique<ConstantOfShapeImpl_cpu>(op);
}
void forward() override;
};
namespace {
static Registrar<ConstantOfShape_Op> registrarConstantOfShapeImpl_cpu(
"cpu", Aidge::ConstantOfShapeImpl_cpu::create);
}
} // namespace Aidge } // namespace Aidge
#endif /* _AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_H_ */ #endif /* _AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_H_ */
......
...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
* *
********************************************************************************/ ********************************************************************************/
#ifndef AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_KERNELS_H_
#define AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_KERNELS_H_
#include <aidge/data/Tensor.hpp> #include <aidge/data/Tensor.hpp>
#include <aidge/data/half.hpp> #include <aidge/data/half.hpp>
...@@ -46,33 +46,26 @@ void ConstantOfShapeimpl_cpu_forward_kernel( ...@@ -46,33 +46,26 @@ void ConstantOfShapeimpl_cpu_forward_kernel(
} }
} }
// Then we add the Registrar declaration for different input/output types // Kernels registration to implementation entry point
namespace { REGISTRAR(ConstantOfShapeImpl_cpu,
static Registrar<ConstantOfShapeImplForward_cpu> {ImplSpec::IOSpec{DataType::Int64}, ImplSpec::IOSpec{DataType::Float16}},
registrarConstantOfShapeImplForward_cpu_Float16( {ProdConso::defaultModel, Aidge::ConstantOfShapeimpl_cpu_forward_kernel<half_float::half>, nullptr});
{DataType::Float16}, REGISTRAR(ConstantOfShapeImpl_cpu,
Aidge::ConstantOfShapeimpl_cpu_forward_kernel<half_float::half>); {ImplSpec::IOSpec{DataType::Int64}, ImplSpec::IOSpec{DataType::Float32}},
static Registrar<ConstantOfShapeImplForward_cpu> {ProdConso::defaultModel, Aidge::ConstantOfShapeimpl_cpu_forward_kernel<float>, nullptr});
registrarConstantOfShapeImplForward_cpu_Float32( REGISTRAR(ConstantOfShapeImpl_cpu,
{DataType::Float32}, {ImplSpec::IOSpec{DataType::Int64}, ImplSpec::IOSpec{DataType::Float64}},
Aidge::ConstantOfShapeimpl_cpu_forward_kernel<float>); {ProdConso::defaultModel, Aidge::ConstantOfShapeimpl_cpu_forward_kernel<double>, nullptr});
static Registrar<ConstantOfShapeImplForward_cpu> REGISTRAR(ConstantOfShapeImpl_cpu,
registrarConstantOfShapeImplForward_cpu_Float64( {ImplSpec::IOSpec{DataType::Int64}, ImplSpec::IOSpec{DataType::Int16}},
{DataType::Float64}, {ProdConso::defaultModel, Aidge::ConstantOfShapeimpl_cpu_forward_kernel<std::int16_t>, nullptr});
Aidge::ConstantOfShapeimpl_cpu_forward_kernel<double>); REGISTRAR(ConstantOfShapeImpl_cpu,
static Registrar<ConstantOfShapeImplForward_cpu> {ImplSpec::IOSpec{DataType::Int64}, ImplSpec::IOSpec{DataType::Int32}},
registrarConstantOfShapeImplForward_cpu_Int16( {ProdConso::defaultModel, Aidge::ConstantOfShapeimpl_cpu_forward_kernel<std::int32_t>, nullptr});
{DataType::Int16}, REGISTRAR(ConstantOfShapeImpl_cpu,
Aidge::ConstantOfShapeimpl_cpu_forward_kernel<std::int16_t>); {ImplSpec::IOSpec{DataType::Int64}, ImplSpec::IOSpec{DataType::Int64}},
static Registrar<ConstantOfShapeImplForward_cpu> {ProdConso::defaultModel, Aidge::ConstantOfShapeimpl_cpu_forward_kernel<std::int64_t>, nullptr});
registrarConstantOfShapeImplForward_cpu_Int32(
{DataType::Int32},
Aidge::ConstantOfShapeimpl_cpu_forward_kernel<std::int32_t>);
static Registrar<ConstantOfShapeImplForward_cpu>
registrarConstantOfShapeImplForward_cpu_Int64(
{DataType::Int64}, Aidge::ConstantOfShapeimpl_cpu_forward_kernel <std::int64_t>);
} // namespace
} // namespace Aidge } // namespace Aidge
#endif /* AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_CONSTANTOFSHAPEIMPL_KERNELS_H_ */
...@@ -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>&,
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 *)>;
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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>,
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>,
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);
}
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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_ */
...@@ -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_ */
...@@ -17,91 +17,41 @@ ...@@ -17,91 +17,41 @@
#include <tuple> #include <tuple>
#include <vector> #include <vector>
#include "aidge/backend/OperatorImpl.hpp" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
#include "aidge/operator/Conv.hpp" #include "aidge/operator/Conv.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 Conv_Op; // Operator implementation entry point for the backend
using Conv1D_Op = Conv_Op<1>;
// compute kernel registry for forward and backward using ConvImpl1D_cpu = OperatorImpl_cpu<Conv_Op<1>,
// Conv 1D void(const std::array<DimSize_t, 1>&,
class ConvImpl1DForward_cpu const std::array<DimSize_t, 1>&,
: public Registrable<ConvImpl1DForward_cpu, const std::array<DimSize_t, 1>&,
std::tuple<DataType, DataType, DataType, DataType>, const std::array<DimSize_t, 3> &,
void(const std::array<DimSize_t, 1>&, DimSize_t,
const std::array<DimSize_t, 1>&, const void *,
const std::array<DimSize_t, 1>&, const void *,
const std::array<DimSize_t, 3> &, const void *,
DimSize_t, void *)>;
const void *,
const void *, using Conv2D_Op = Conv_Op<2>;
const void *, using ConvImpl2D_cpu = OperatorImpl_cpu<Conv_Op<2>,
void *)> {}; void(const std::array<DimSize_t, 2>&,
const std::array<DimSize_t, 2>&,
class ConvImpl1D_cpu : public OperatorImpl { const std::array<DimSize_t, 2>&,
public: const std::array<DimSize_t, 4> &,
ConvImpl1D_cpu(const Conv_Op<1>& op) : OperatorImpl(op, "cpu") {} DimSize_t,
const void *,
static std::unique_ptr<ConvImpl1D_cpu> create(const Conv_Op<1> &op) { const void *,
return std::make_unique<ConvImpl1D_cpu>(op); const void *,
} void *)>;
public: // Implementation entry point registration to Operator
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; REGISTRAR(Conv1D_Op, "cpu", Aidge::ConvImpl1D_cpu::create);
void forward() override; REGISTRAR(Conv2D_Op, "cpu", Aidge::ConvImpl2D_cpu::create);
};
namespace {
// add cpu backend to Conv_Op<1> implementation registry
static Registrar<Conv_Op<1>> registrarConvImpl1D_cpu("cpu", Aidge::ConvImpl1D_cpu::create);
} // namespace
// Conv 2D
class ConvImpl2DForward_cpu
: public Registrable<ConvImpl2DForward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
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> &,
DimSize_t,
const void *,
const void *,
const void *,
void *)> {};
class ConvImpl2DBackward_cpu
: public Registrable<ConvImpl2DBackward_cpu,
std::tuple<DataType, DataType, DataType, DataType>,
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 ConvImpl2D_cpu : public OperatorImpl {
public:
ConvImpl2D_cpu(const Conv_Op<2>& op) : OperatorImpl(op, "cpu") {}
static std::unique_ptr<ConvImpl2D_cpu> create(const Conv_Op<2> &op) {
return std::make_unique<ConvImpl2D_cpu>(op);
}
public:
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
void forward() override;
};
namespace {
// add cpu backend to Conv_Op<2> implementation registry
static Registrar<Conv_Op<2>> registrarConvImpl2D_cpu("cpu", Aidge::ConvImpl2D_cpu::create);
} // namespace
} // namespace Aidge } // namespace Aidge
#endif /* AIDGE_CPU_OPERATOR_CONVIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_CONVIMPL_H_ */
...@@ -9,18 +9,20 @@ ...@@ -9,18 +9,20 @@
* *
********************************************************************************/ ********************************************************************************/
#ifndef AIDGE_CPU_OPERATOR_CONVIMPL_FORWARD_KERNEL_H_ #ifndef AIDGE_CPU_OPERATOR_CONVIMPL_KERNELS_H_
#define AIDGE_CPU_OPERATOR_CONVIMPL_FORWARD_KERNEL_H_ #define AIDGE_CPU_OPERATOR_CONVIMPL_KERNELS_H_
#include <algorithm>
#include <array> #include <array>
#include <cmath> #include <memory>
#include <tuple>
#include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h" #include "aidge/backend/cpu/operator/OperatorImpl.hpp"
#include "aidge/backend/cpu/operator/ConvImpl.hpp" #include "aidge/backend/cpu/operator/ConvImpl.hpp"
#include "aidge/data/half.hpp" #include "aidge/operator/Conv.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"
namespace Aidge { namespace Aidge {
/** /**
...@@ -90,20 +92,19 @@ void ConvImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& strideDims, ...@@ -90,20 +92,19 @@ void ConvImpl1D_cpu_forward_kernel(const std::array<DimSize_t, 1>& strideDims,
} }
} }
namespace { // Kernels registration to implementation entry point
static Registrar<ConvImpl1DForward_cpu> registrarConvImpl1DForward_cpu_Float32( REGISTRAR(ConvImpl1D_cpu,
{DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
Aidge::ConvImpl1D_cpu_forward_kernel<float, float, float, float>); {ProdConso::inPlaceModel, Aidge::ConvImpl1D_cpu_forward_kernel<float, float, float, float>, nullptr});
static Registrar<ConvImpl1DForward_cpu> registrarConvImpl1DForward_cpu_Float16( REGISTRAR(ConvImpl1D_cpu,
{DataType::Float16, DataType::Float16, DataType::Float16, DataType::Float16}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float16, DataFormat::NCHW}},
Aidge::ConvImpl1D_cpu_forward_kernel<half_float::half, half_float::half, half_float::half, half_float::half>); {ProdConso::inPlaceModel, Aidge::ConvImpl1D_cpu_forward_kernel<half_float::half, half_float::half, half_float::half, half_float::half>, nullptr});
static Registrar<ConvImpl1DForward_cpu> registrarConvImpl1DForward_cpu_Int32( REGISTRAR(ConvImpl1D_cpu,
{DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Int32, DataFormat::NCHW}},
Aidge::ConvImpl1D_cpu_forward_kernel<int, int, int, int>); {ProdConso::inPlaceModel, Aidge::ConvImpl1D_cpu_forward_kernel<int32_t, int32_t, int32_t, int32_t>, nullptr});
static Registrar<ConvImpl1DForward_cpu> registrarConvImpl1DForward_cpu_Float64( REGISTRAR(ConvImpl1D_cpu,
{DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
Aidge::ConvImpl1D_cpu_forward_kernel<double, double, double, double>); {ProdConso::inPlaceModel, Aidge::ConvImpl1D_cpu_forward_kernel<double, double, double, double>, nullptr});
} // namespace
/** /**
...@@ -135,49 +136,6 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims, ...@@ -135,49 +136,6 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
const W *weights = static_cast<const W *>(weights_); const W *weights = static_cast<const W *>(weights_);
const B *biases = static_cast<const B *>(biases_); const B *biases = static_cast<const B *>(biases_);
O *output = static_cast<O *>(output_); O *output = static_cast<O *>(output_);
/*
// output H size
const std::size_t oxSize =
static_cast<std::size_t>(static_cast<float>(inputDims[0] - kernelDims[0] + strideDims[0]) /
static_cast<float>(strideDims[0]));
// output W size
const std::size_t oySize =
static_cast<std::size_t>(static_cast<float>(inputDims[1] - kernelDims[1] + strideDims[1]) /
static_cast<float>(strideDims[1]));
// TODO: kernel computation
// output (Xout, Yout, outCh, batch)
// input (Xin, Yin, inCh, batch)
// weight (kernelX, kernelY, inCh, outCh)
// does not take Dilation attribute into account
for (std::size_t ox = 0; ox < oxSize; ++ox) {
for (std::size_t oy = 0; oy < oySize; ++oy) {
const std::size_t ix = ox * strideDims[0];
const std::size_t iy = oy * strideDims[1];
for (std::size_t outCh = 0; outCh < outChannels; ++outCh) {
const std::size_t oIndex = inputDims[3] * (outCh + outChannels * (oy + oySize * ox));
B biasVal = (biases != nullptr) ? biases[outCh] : B(0);
for (std::size_t batch = 0; batch < inputDims[3]; ++batch) {
output[oIndex + batch] = biasVal;
}
for (std::size_t inCh = 0; inCh < inputDims[2]; ++inCh) {
for (std::size_t sx = 0; sx < kernelDims[0]; ++sx) {
for (std::size_t sy = 0; sy < kernelDims[1]; ++sy) {
const std::size_t wIndex =
outCh + outChannels * (inCh + inputDims[2] * (sy + kernelDims[1] * sx));
std::size_t iIndex = inputDims[3] * (inCh + inputDims[2] * ((iy + sy) + inputDims[1] * (ix + sx)));
for (std::size_t batch = 0; batch < inputDims[3]; ++batch) {
output[oIndex + batch] += weights[wIndex] * input[iIndex + batch];
}
}
}
}
}
}
}
*/
// output H size // output H size
const std::size_t oxSize = const std::size_t oxSize =
...@@ -240,20 +198,19 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims, ...@@ -240,20 +198,19 @@ void ConvImpl2D_cpu_forward_kernel(const std::array<DimSize_t, 2>& strideDims,
} }
} }
namespace { // Kernels registration to implementation entry point
static Registrar<ConvImpl2DForward_cpu> registrarConvImpl2DForward_cpu_Float32( REGISTRAR(ConvImpl2D_cpu,
{DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float32, DataFormat::NCHW}},
Aidge::ConvImpl2D_cpu_forward_kernel<float, float, float, float>); {ProdConso::inPlaceModel, Aidge::ConvImpl2D_cpu_forward_kernel<float, float, float, float>, nullptr});
static Registrar<ConvImpl2DForward_cpu> registrarConvImpl2DForward_cpu_Float16( REGISTRAR(ConvImpl2D_cpu,
{DataType::Float16, DataType::Float16, DataType::Float16, DataType::Float16}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float16, DataFormat::NCHW}},
Aidge::ConvImpl2D_cpu_forward_kernel<half_float::half, half_float::half, half_float::half, half_float::half>); {ProdConso::inPlaceModel, Aidge::ConvImpl2D_cpu_forward_kernel<half_float::half, half_float::half, half_float::half, half_float::half>, nullptr});
static Registrar<ConvImpl2DForward_cpu> registrarConvImpl2DForward_cpu_Int32( REGISTRAR(ConvImpl2D_cpu,
{DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32}, {{DataType::Any, DataFormat::NCHW}, {DataType::Int32, DataFormat::NCHW}},
Aidge::ConvImpl2D_cpu_forward_kernel<int, int, int, int>); {ProdConso::inPlaceModel, Aidge::ConvImpl2D_cpu_forward_kernel<int32_t, int32_t, int32_t, int32_t>, nullptr});
static Registrar<ConvImpl2DForward_cpu> registrarConvImpl2DForward_cpu_Float64( REGISTRAR(ConvImpl2D_cpu,
{DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64}, {{DataType::Any, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
Aidge::ConvImpl2D_cpu_forward_kernel<double, double, double, double>); {ProdConso::inPlaceModel, Aidge::ConvImpl2D_cpu_forward_kernel<double, double, double, double>, nullptr});
} // namespace
} // namespace Aidge } // namespace Aidge
#endif /* AIDGE_CPU_OPERATOR_CONVIMPL_FORWARD_KERNEL_H_ */ #endif /* AIDGE_CPU_OPERATOR_CONVIMPL_KERNELS_H_ */
...@@ -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>, 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>, 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>, 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);
}
Elts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
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_ */
...@@ -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_ */
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment