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

Update with default operator impl

parent b4c8c60e
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 65 additions and 699 deletions
include/aidge/backend/cpu/operator/AddImpl.hpp
+ 8
− 109
View file @ 50d21397
...@@ -53,152 +53,51 @@ class AddImplBackward_cpu<3> ...@@ -53,152 +53,51 @@ class AddImplBackward_cpu<3>
template <DimIdx_t NUM> template <DimIdx_t NUM>
class AddImpl_cpu : public OperatorImpl { class AddImpl_cpu : public OperatorImpl {
private: public:
const Add_Op<NUM>& mOp; AddImpl_cpu(const Add_Op<NUM>& op) : OperatorImpl(op) {}
std::array<NbElts_t, NUM> mNbConsumedData = {};
std::array<NbElts_t, 1> mNbProducedData = {};
public:
AddImpl_cpu(const Add_Op<NUM>& op) : mOp(op) {}
static std::unique_ptr<AddImpl_cpu<NUM>> create(const Add_Op<NUM>& op) { static std::unique_ptr<AddImpl_cpu<NUM>> create(const Add_Op<NUM>& op) {
return std::make_unique<AddImpl_cpu<NUM>>(op); return std::make_unique<AddImpl_cpu<NUM>>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final {
// for the direct convolution algorithm, convolutions can be in-place, if there is no padding!
return 0;
}
NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t>& /*inputsSize*/) const override final {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final {
assert(inputIdx < mNbConsumedData.size());
return mNbConsumedData[inputIdx];
}
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final {
assert(outputIdx < mNbProducedData.size());
return mNbProducedData[outputIdx];
}
void updateConsummerProducer() override final;
void forward() override {
// nothing
}
void backward() override { printf("Not implemented yet.\n"); }
}; };
template <> template <>
class AddImpl_cpu<1> : public OperatorImpl { class AddImpl_cpu<1> : public OperatorImpl {
private: public:
const Add_Op<1>& mOp; AddImpl_cpu(const Add_Op<1>& op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
AddImpl_cpu(const Add_Op<1>& op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<AddImpl_cpu<1>> create(const Add_Op<1>& op) { static std::unique_ptr<AddImpl_cpu<1>> create(const Add_Op<1>& op) {
return std::make_unique<AddImpl_cpu<1>>(op); return std::make_unique<AddImpl_cpu<1>>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/,
const std::vector<DimSize_t> &/*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getNbProducedData(const IOIndex_t /*outputIdx*/) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
template <> template <>
class AddImpl_cpu<2> : public OperatorImpl { class AddImpl_cpu<2> : public OperatorImpl {
private: public:
const Add_Op<2>& mOp; AddImpl_cpu(const Add_Op<2>& op) : OperatorImpl(op) {}
std::array<NbElts_t, 2> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
AddImpl_cpu(const Add_Op<2>& op) : mOp(op), mNbConsumedData({0, 0}), mNbProducedData({0}) {}
static std::unique_ptr<AddImpl_cpu<2>> create(const Add_Op<2>& op) { static std::unique_ptr<AddImpl_cpu<2>> create(const Add_Op<2>& op) {
return std::make_unique<AddImpl_cpu<2>>(op); return std::make_unique<AddImpl_cpu<2>>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/,
const std::vector<DimSize_t>& /*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t /*outputIdx*/) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
template <> template <>
class AddImpl_cpu<3> : public OperatorImpl { class AddImpl_cpu<3> : public OperatorImpl {
private: public:
const Add_Op<3>& mOp; AddImpl_cpu(const Add_Op<3>& op) : OperatorImpl(op) {}
std::array<NbElts_t, 3> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
AddImpl_cpu(const Add_Op<3>& op) : mOp(op), mNbConsumedData({0, 0, 0}), mNbProducedData({0}) {}
static std::unique_ptr<AddImpl_cpu<3>> create(const Add_Op<3>& op) { static std::unique_ptr<AddImpl_cpu<3>> create(const Add_Op<3>& op) {
return std::make_unique<AddImpl_cpu<3>>(op); return std::make_unique<AddImpl_cpu<3>>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/AvgPoolingImpl.hpp
+ 2
− 16
View file @ 50d21397
...@@ -36,29 +36,15 @@ class AvgPoolingImpl2DBackward_cpu ...@@ -36,29 +36,15 @@ class AvgPoolingImpl2DBackward_cpu
void(const AvgPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {}; void(const AvgPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {};
class AvgPoolingImpl2D_cpu : public OperatorImpl { class AvgPoolingImpl2D_cpu : public OperatorImpl {
private: public:
const AvgPooling_Op<2> &mOp; AvgPoolingImpl2D_cpu(const AvgPooling_Op<2> &op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
AvgPoolingImpl2D_cpu(const AvgPooling_Op<2> &op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<AvgPoolingImpl2D_cpu> create(const AvgPooling_Op<2> &op) { static std::unique_ptr<AvgPoolingImpl2D_cpu> create(const AvgPooling_Op<2> &op) {
return std::make_unique<AvgPoolingImpl2D_cpu>(op); return std::make_unique<AvgPoolingImpl2D_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &inputsSize) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/BatchNormImpl.hpp
+ 2
− 16
View file @ 50d21397
...@@ -51,29 +51,15 @@ class BatchNormImpl2DBackward_cpu ...@@ -51,29 +51,15 @@ class BatchNormImpl2DBackward_cpu
void *)> {}; void *)> {};
class BatchNormImpl2D_cpu : public OperatorImpl { class BatchNormImpl2D_cpu : public OperatorImpl {
private: public:
const BatchNorm_Op<2> &mOp; BatchNormImpl2D_cpu(const BatchNorm_Op<2> &op) : OperatorImpl(op) {}
std::array<NbElts_t, 5> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
BatchNormImpl2D_cpu(const BatchNorm_Op<2> &op) : mOp(op), mNbConsumedData({0, 0, 0, 0, 0}), mNbProducedData({0}) {}
static std::unique_ptr<BatchNormImpl2D_cpu> create(const BatchNorm_Op<2> &op) { static std::unique_ptr<BatchNormImpl2D_cpu> create(const BatchNorm_Op<2> &op) {
return std::make_unique<BatchNormImpl2D_cpu>(op); return std::make_unique<BatchNormImpl2D_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &inputsSize) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp
+ 2
− 16
View file @ 50d21397
...@@ -38,29 +38,15 @@ class ConvDepthWiseImpl2DBackward_cpu ...@@ -38,29 +38,15 @@ class ConvDepthWiseImpl2DBackward_cpu
const void *, const void *, void *)> {}; const void *, const void *, void *)> {};
class ConvDepthWiseImpl2D_cpu : public OperatorImpl { class ConvDepthWiseImpl2D_cpu : public OperatorImpl {
private: public:
const ConvDepthWise_Op<2> &mOp; ConvDepthWiseImpl2D_cpu(const ConvDepthWise_Op<2> &op) : OperatorImpl(op) {}
std::array<NbElts_t, 3> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
ConvDepthWiseImpl2D_cpu(const ConvDepthWise_Op<2> &op) : mOp(op), mNbConsumedData({0, 0, 0}), mNbProducedData({0}) {}
static std::unique_ptr<ConvDepthWiseImpl2D_cpu> create(const ConvDepthWise_Op<2> &op) { static std::unique_ptr<ConvDepthWiseImpl2D_cpu> create(const ConvDepthWise_Op<2> &op) {
return std::make_unique<ConvDepthWiseImpl2D_cpu>(op); return std::make_unique<ConvDepthWiseImpl2D_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/ConvImpl.hpp
+ 1
− 14
View file @ 50d21397
...@@ -38,29 +38,16 @@ class ConvImpl2DBackward_cpu ...@@ -38,29 +38,16 @@ class ConvImpl2DBackward_cpu
const void *, const void *, void *)> {}; const void *, const void *, void *)> {};
class ConvImpl2D_cpu : public OperatorImpl { class ConvImpl2D_cpu : public OperatorImpl {
private:
const Conv_Op<2> &mOp;
std::array<NbElts_t, 3> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public: public:
ConvImpl2D_cpu(const Conv_Op<2> &op) : mOp(op), mNbConsumedData({0, 0, 0}), mNbProducedData({0}) {} ConvImpl2D_cpu(const Conv_Op<2>& op) : OperatorImpl(op) {}
static std::unique_ptr<ConvImpl2D_cpu> create(const Conv_Op<2> &op) { static std::unique_ptr<ConvImpl2D_cpu> create(const Conv_Op<2> &op) {
return std::make_unique<ConvImpl2D_cpu>(op); return std::make_unique<ConvImpl2D_cpu>(op);
} }
public: public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/FCImpl.hpp
+ 5
− 17
View file @ 50d21397
...@@ -34,26 +34,14 @@ class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu, ...@@ -34,26 +34,14 @@ class FCImplBackward_cpu : public Registrable<FCImplBackward_cpu,
const void *, const void *, const void *, void *)> {}; const void *, const void *, const void *, void *)> {};
class FCImpl_cpu : public OperatorImpl { class FCImpl_cpu : public OperatorImpl {
private: public:
const FC_Op &mOp; FCImpl_cpu(const FC_Op &op) : OperatorImpl(op) {}
std::array<NbElts_t, 3> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public: static std::unique_ptr<FCImpl_cpu> create(const FC_Op &op) {
FCImpl_cpu(const FC_Op &op) : mOp(op), mNbConsumedData({0, 0, 0}), mNbProducedData({0}) {} return std::make_unique<FCImpl_cpu>(op);
}
static std::unique_ptr<FCImpl_cpu> create(const FC_Op &op) { return std::make_unique<FCImpl_cpu>(op); }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/LeakyReLUImpl.hpp
+ 2
− 15
View file @ 50d21397
...@@ -31,28 +31,15 @@ class LeakyReLUImplBackward_cpu ...@@ -31,28 +31,15 @@ class LeakyReLUImplBackward_cpu
}; };
class LeakyReLUImpl_cpu : public OperatorImpl { class LeakyReLUImpl_cpu : public OperatorImpl {
private: public:
const LeakyReLU_Op& mOp; LeakyReLUImpl_cpu(const LeakyReLU_Op& op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
LeakyReLUImpl_cpu(const LeakyReLU_Op& op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<LeakyReLUImpl_cpu> create(const LeakyReLU_Op& op) { static std::unique_ptr<LeakyReLUImpl_cpu> create(const LeakyReLU_Op& op) {
return std::make_unique<LeakyReLUImpl_cpu>(op); return std::make_unique<LeakyReLUImpl_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/MatMulImpl.hpp
+ 2
− 25
View file @ 50d21397
...@@ -35,37 +35,14 @@ class MatMulImplBackward_cpu ...@@ -35,37 +35,14 @@ class MatMulImplBackward_cpu
const void *, const void *, void *)> {}; const void *, const void *, void *)> {};
class MatMulImpl_cpu : public OperatorImpl { class MatMulImpl_cpu : public OperatorImpl {
private:
const MatMul_Op &mOp;
std::array<NbElts_t, 2> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public: public:
MatMulImpl_cpu(const MatMul_Op &op) MatMulImpl_cpu(const MatMul_Op &op): OperatorImpl(op) {}
: mOp(op),
mNbConsumedData({0, 0}),
mNbProducedData({0})
{
// ctor
}
static std::unique_ptr<MatMulImpl_cpu> create(const MatMul_Op &op) static std::unique_ptr<MatMulImpl_cpu> create(const MatMul_Op &op) {
{
return std::make_unique<MatMulImpl_cpu>(op); return std::make_unique<MatMulImpl_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/,
const std::vector<DimSize_t> & /*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/MaxPoolingImpl.hpp
+ 2
− 16
View file @ 50d21397
...@@ -36,29 +36,15 @@ class MaxPoolingImpl2DBackward_cpu ...@@ -36,29 +36,15 @@ class MaxPoolingImpl2DBackward_cpu
void(const MaxPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {}; void(const MaxPooling_Op<2>::Attrs &, const std::array<DimSize_t, 4> &, const void *, void *)> {};
class MaxPoolingImpl2D_cpu : public OperatorImpl { class MaxPoolingImpl2D_cpu : public OperatorImpl {
private: public:
const MaxPooling_Op<2> &mOp; MaxPoolingImpl2D_cpu(const MaxPooling_Op<2> &op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
MaxPoolingImpl2D_cpu(const MaxPooling_Op<2> &op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<MaxPoolingImpl2D_cpu> create(const MaxPooling_Op<2> &op) { static std::unique_ptr<MaxPoolingImpl2D_cpu> create(const MaxPooling_Op<2> &op) {
return std::make_unique<MaxPoolingImpl2D_cpu>(op); return std::make_unique<MaxPoolingImpl2D_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &inputsSize) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/PadImpl.hpp
+ 2
− 16
View file @ 50d21397
...@@ -38,29 +38,15 @@ class PadImpl2DBackward_cpu ...@@ -38,29 +38,15 @@ class PadImpl2DBackward_cpu
void *)> {}; void *)> {};
class PadImpl2D_cpu : public OperatorImpl { class PadImpl2D_cpu : public OperatorImpl {
private: public:
const Pad_Op<2> &mOp; PadImpl2D_cpu(const Pad_Op<2> &op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData = {0};
std::array<NbElts_t, 1> mNbProducedData = {0};
public:
PadImpl2D_cpu(const Pad_Op<2> &op) : mOp(op) {}
static std::unique_ptr<PadImpl2D_cpu> create(const Pad_Op<2> &op) { static std::unique_ptr<PadImpl2D_cpu> create(const Pad_Op<2> &op) {
return std::make_unique<PadImpl2D_cpu>(op); return std::make_unique<PadImpl2D_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/ProducerImpl.hpp
+ 4
− 17
View file @ 50d21397
...@@ -21,31 +21,18 @@ ...@@ -21,31 +21,18 @@
namespace Aidge { namespace Aidge {
class ProducerImpl_cpu : public OperatorImpl { class ProducerImpl_cpu : public OperatorImpl {
private: public:
const Producer_Op &mOp; ProducerImpl_cpu(const Producer_Op &op) : OperatorImpl(op) {}
public:
ProducerImpl_cpu(const Producer_Op &op) : mOp(op) {}
static std::unique_ptr<ProducerImpl_cpu> create(const Producer_Op &op) { static std::unique_ptr<ProducerImpl_cpu> create(const Producer_Op &op) {
return std::make_unique<ProducerImpl_cpu>(op); return std::make_unique<ProducerImpl_cpu>(op);
} }
public: void forward() override {};
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t> &/*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override;
void backward() override;
}; };
namespace { namespace {
static Registrar<Producer_Op> registrarProducer1DImpl_cpu("cpu", Aidge::ProducerImpl_cpu::create); static Registrar<Producer_Op> registrarProducerImpl_cpu("cpu", Aidge::ProducerImpl_cpu::create);
} // namespace } // namespace
} // namespace Aidge } // namespace Aidge
......
include/aidge/backend/cpu/operator/ReLUImpl.hpp
+ 2
− 15
View file @ 50d21397
...@@ -31,28 +31,15 @@ class ReLUImplBackward_cpu ...@@ -31,28 +31,15 @@ class ReLUImplBackward_cpu
}; };
class ReLUImpl_cpu : public OperatorImpl { class ReLUImpl_cpu : public OperatorImpl {
protected: public:
const ReLU_Op& mOp; ReLUImpl_cpu(const ReLU_Op& op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
ReLUImpl_cpu(const ReLU_Op& op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<ReLUImpl_cpu> create(const ReLU_Op& op) { static std::unique_ptr<ReLUImpl_cpu> create(const ReLU_Op& op) {
return std::make_unique<ReLUImpl_cpu>(op); return std::make_unique<ReLUImpl_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/ScalingImpl.hpp
+ 2
− 18
View file @ 50d21397
...@@ -32,31 +32,15 @@ class ScalingImplBackward_cpu ...@@ -32,31 +32,15 @@ class ScalingImplBackward_cpu
}; };
class ScalingImpl_cpu : public OperatorImpl { class ScalingImpl_cpu : public OperatorImpl {
private: public:
const Scaling_Op& mOp; ScalingImpl_cpu(const Scaling_Op& op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
ScalingImpl_cpu(const Scaling_Op& op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<ScalingImpl_cpu> create(const Scaling_Op& op) { static std::unique_ptr<ScalingImpl_cpu> create(const Scaling_Op& op) {
//std::cout << "ScalingImpl_cpu create" << std::endl;
return std::make_unique<ScalingImpl_cpu>(op); return std::make_unique<ScalingImpl_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t>& inputsSize) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
include/aidge/backend/cpu/operator/SoftmaxImpl.hpp
+ 2
− 15
View file @ 50d21397
...@@ -31,28 +31,15 @@ class SoftmaxImplBackward_cpu ...@@ -31,28 +31,15 @@ class SoftmaxImplBackward_cpu
}; };
class SoftmaxImpl_cpu : public OperatorImpl { class SoftmaxImpl_cpu : public OperatorImpl {
private: public:
const Softmax_Op& mOp; SoftmaxImpl_cpu(const Softmax_Op& op) : OperatorImpl(op) {}
std::array<NbElts_t, 1> mNbConsumedData;
std::array<NbElts_t, 1> mNbProducedData;
public:
SoftmaxImpl_cpu(const Softmax_Op& op) : mOp(op), mNbConsumedData({0}), mNbProducedData({0}) {}
static std::unique_ptr<SoftmaxImpl_cpu> create(const Softmax_Op& op) { static std::unique_ptr<SoftmaxImpl_cpu> create(const Softmax_Op& op) {
return std::make_unique<SoftmaxImpl_cpu>(op); return std::make_unique<SoftmaxImpl_cpu>(op);
} }
public:
NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final; NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
NbElts_t getRequiredMemory(const IOIndex_t /*outputIdx*/, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override; void forward() override;
void backward() override;
}; };
namespace { namespace {
......
src/operator/AddImpl.cpp
+ 12
− 128
View file @ 50d21397
...@@ -25,38 +25,12 @@ ...@@ -25,38 +25,12 @@
// AddImpl_cpu<1> // AddImpl_cpu<1>
////////////////////////////////// //////////////////////////////////
Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbRequiredData(Aidge::IOIndex_t /*inputIdx*/) const {
assert(mOp.getInput(0) && "requires valid input");
// Requires the whole tensors
return static_cast<int>(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size());
}
Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if there is no padding! // this implementation can be in-place
return 0; return 0;
} }
Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getRequiredMemory(const Aidge::IOIndex_t /*outputIdx*/, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
return std::static_pointer_cast<Tensor>(mOp.getOutput(0))->size();
}
Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbConsumedData(Aidge::IOIndex_t /*inputIdx*/) const {
return mNbConsumedData[0];
}
Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbProducedData(Aidge::IOIndex_t /*outputIdx*/) const {
return mNbProducedData[0];
}
void Aidge::AddImpl_cpu<1>::updateConsummerProducer(){
// Update producer-consumer data
for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass
mNbProducedData[0]+= getRequiredMemory(0, {});
}
void Aidge::AddImpl_cpu<1>::forward() { void Aidge::AddImpl_cpu<1>::forward() {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
// Find the correct kernel type // Find the correct kernel type
...@@ -68,11 +42,6 @@ void Aidge::AddImpl_cpu<1>::forward() { ...@@ -68,11 +42,6 @@ void Aidge::AddImpl_cpu<1>::forward() {
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(), kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(),
mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getOutput(0)->getImpl()->rawPtr());
}
void Aidge::AddImpl_cpu<1>::backward() {
printf("Not implemented yet.\n");
} }
...@@ -80,68 +49,26 @@ void Aidge::AddImpl_cpu<1>::backward() { ...@@ -80,68 +49,26 @@ void Aidge::AddImpl_cpu<1>::backward() {
// AddImpl_cpu<2> // AddImpl_cpu<2>
////////////////////////////////// //////////////////////////////////
Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(),
NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if there is no padding! // this implementation of add can be in-place
return 0; return 0;
} }
Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getRequiredMemory(const Aidge::IOIndex_t outputIdx, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx; // avoid unused warning
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(),
NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}
Aidge::NbElts_t Aidge::AddImpl_cpu<2>::getNbProducedData(Aidge::IOIndex_t /*outputIdx*/) const {
return mNbProducedData[0];
}
void Aidge::AddImpl_cpu<2>::updateConsummerProducer(){
// Update producer-consumer data
for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass
mNbProducedData[0]+= getRequiredMemory(0, {});
}
void Aidge::AddImpl_cpu<2>::forward() { void Aidge::AddImpl_cpu<2>::forward() {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
assert(mOp.mInputs[1] && "missing input #1"); assert(mOp.getInput(1) && "missing input #1");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<AddImplForward_cpu<2>>::create({ auto kernelFunc = Registrar<AddImplForward_cpu<2>>::create({
mOp.getInput(0)->dataType(), mOp.getInput(0)->dataType(),
mOp.mInputs[1]->dataType(), mOp.getInput(1)->dataType(),
mOp.getOutput(0)->dataType()}); mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(), kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(),
mOp.mInputs[1]->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getOutput(0)->getImpl()->rawPtr());
}
void Aidge::AddImpl_cpu<2>::backward() {
printf("Not implemented yet.\n");
} }
...@@ -149,70 +76,27 @@ void Aidge::AddImpl_cpu<2>::backward() { ...@@ -149,70 +76,27 @@ void Aidge::AddImpl_cpu<2>::backward() {
// AddImpl_cpu<3> // AddImpl_cpu<3>
////////////////////////////////// //////////////////////////////////
Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(),
Aidge::NbElts_t(1), std::multiplies<Aidge::NbElts_t>());
}
Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if there is no padding! // this implementation of add can be in-place
return 0; return 0;
} }
Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getRequiredMemory(const Aidge::IOIndex_t outputIdx, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx; // avoid unused warning
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(),
NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
return mNbConsumedData[inputIdx];
}
Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
assert(static_cast<std::size_t>(outputIdx) < mNbProducedData.size());
return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}
void Aidge::AddImpl_cpu<3>::updateConsummerProducer(){
// Update producer-consumer data
for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass
mNbProducedData[0]+= getRequiredMemory(0, {});
}
void Aidge::AddImpl_cpu<3>::forward() { void Aidge::AddImpl_cpu<3>::forward() {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
assert(mOp.mInputs[1] && "missing input #1"); assert(mOp.getInput(1) && "missing input #1");
assert(mOp.mInputs[2] && "missing input #2"); assert(mOp.getInput(2) && "missing input #2");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<AddImplForward_cpu<3>>::create({ auto kernelFunc = Registrar<AddImplForward_cpu<3>>::create({
mOp.getInput(0)->dataType(), mOp.getInput(0)->dataType(),
mOp.mInputs[1]->dataType(), mOp.getInput(1)->dataType(),
mOp.mInputs[2]->dataType(), mOp.getInput(2)->dataType(),
mOp.getOutput(0)->dataType()}); mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(), kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(),
mOp.mInputs[1]->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
mOp.mInputs[2]->getImpl()->rawPtr(), mOp.getInput(2)->getImpl()->rawPtr(),
mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getOutput(0)->getImpl()->rawPtr());
}
void Aidge::AddImpl_cpu<3>::backward() {
printf("Not implemented yet.\n");
} }
src/operator/AvgPoolingImpl.cpp
+ 2
− 42
View file @ 50d21397
...@@ -20,49 +20,12 @@ ...@@ -20,49 +20,12 @@
#include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp" #include "aidge/backend/cpu/operator/AvgPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/AvgPoolingImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if // this implementation can be in-place
// there is no padding!
return 0; return 0;
} }
Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
const std::vector<Aidge::DimSize_t> & /*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}
Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
assert((outputIdx == 0) && (static_cast<std::size_t>(outputIdx) < mNbProducedData.size()));
return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}
void Aidge::AvgPoolingImpl2D_cpu::updateConsummerProducer(){
// Update producer-consumer data
for (std::size_t inputIdx = 0; inputIdx < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx] += getNbRequiredData(static_cast<IOIndex_t>(inputIdx)); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
}
void Aidge::AvgPoolingImpl2D_cpu::forward() { void Aidge::AvgPoolingImpl2D_cpu::forward() {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
// Find the correct kernel type // Find the correct kernel type
...@@ -70,11 +33,8 @@ void Aidge::AvgPoolingImpl2D_cpu::forward() { ...@@ -70,11 +33,8 @@ void Aidge::AvgPoolingImpl2D_cpu::forward() {
Registrar<AvgPoolingImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()}); Registrar<AvgPoolingImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
kernelFunc(mOp.getStaticAttributes(), kernelFunc(dynamic_cast<const AvgPooling_Op<2>&>(mOp).getStaticAttributes(),
mOp.getInput(0)->dims<4>(), mOp.getInput(0)->dims<4>(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(),
mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getOutput(0)->getImpl()->rawPtr());
} }
void Aidge::AvgPoolingImpl2D_cpu::backward() { printf("Not implemented yet.\n"); }
src/operator/BatchNormImpl.cpp
+ 2
− 44
View file @ 50d21397
...@@ -19,50 +19,12 @@ ...@@ -19,50 +19,12 @@
#include "aidge/backend/cpu/operator/BatchNormImpl.hpp" #include "aidge/backend/cpu/operator/BatchNormImpl.hpp"
#include "aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/BatchNormImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if // this implementation can be in-place
// there is no padding!
return 0; return 0;
} }
Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}
Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
assert((outputIdx == 0) && (static_cast<std::size_t>(outputIdx) < mNbProducedData.size()));
return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}
void Aidge::BatchNormImpl2D_cpu::updateConsummerProducer(){
// Update producer-consumer data
for (std::size_t inputIdx = 0; inputIdx < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx] += getNbRequiredData(static_cast<IOIndex_t>(inputIdx)); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
}
void Aidge::BatchNormImpl2D_cpu::forward() { void Aidge::BatchNormImpl2D_cpu::forward() {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
assert(mOp.getInput(1) && "missing input #1"); assert(mOp.getInput(1) && "missing input #1");
assert(mOp.getInput(2) && "missing input #2"); assert(mOp.getInput(2) && "missing input #2");
...@@ -76,7 +38,7 @@ void Aidge::BatchNormImpl2D_cpu::forward() { ...@@ -76,7 +38,7 @@ void Aidge::BatchNormImpl2D_cpu::forward() {
mOp.getOutput(0)->dataType()}); mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
kernelFunc(mOp.getStaticAttributes(), kernelFunc(dynamic_cast<const BatchNorm_Op<2>&>(mOp).getStaticAttributes(),
mOp.getInput(0)->dims<4>(), mOp.getInput(0)->dims<4>(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(),
mOp.getInput(1)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
...@@ -85,8 +47,4 @@ void Aidge::BatchNormImpl2D_cpu::forward() { ...@@ -85,8 +47,4 @@ void Aidge::BatchNormImpl2D_cpu::forward() {
mOp.getInput(4)->getImpl()->rawPtr(), mOp.getInput(4)->getImpl()->rawPtr(),
mOp.getOutput(0)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr(),
true); true);
} }
void Aidge::BatchNormImpl2D_cpu::backward() { printf("Not implemented yet.\n"); }
src/operator/ConvDepthWiseImpl.cpp
+ 2
− 42
View file @ 50d21397
...@@ -21,50 +21,12 @@ ...@@ -21,50 +21,12 @@
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp" #include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if // this implementation can be in-place
// there is no padding!
return 0; return 0;
} }
Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}
Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
assert((outputIdx == 0) && (static_cast<std::size_t>(outputIdx) < mNbProducedData.size()));
return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}
void Aidge::ConvDepthWiseImpl2D_cpu::updateConsummerProducer(){
// Update producer-consumer data
for (std::size_t inputIdx = 0; inputIdx < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx] += getNbRequiredData(static_cast<IOIndex_t>(inputIdx)); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
}
void Aidge::ConvDepthWiseImpl2D_cpu::forward() { void Aidge::ConvDepthWiseImpl2D_cpu::forward() {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
assert(mOp.getInput(1) && "missing input #1"); assert(mOp.getInput(1) && "missing input #1");
assert(mOp.getInput(2) && "missing input #2"); assert(mOp.getInput(2) && "missing input #2");
...@@ -77,9 +39,7 @@ void Aidge::ConvDepthWiseImpl2D_cpu::forward() { ...@@ -77,9 +39,7 @@ void Aidge::ConvDepthWiseImpl2D_cpu::forward() {
mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()}); mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
kernelFunc(mOp.getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(), kernelFunc(dynamic_cast<const ConvDepthWise_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
mOp.getInput(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getInput(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
} }
void Aidge::ConvDepthWiseImpl2D_cpu::backward() { printf("Not implemented yet.\n"); }
src/operator/ConvImpl.cpp
+ 2
− 43
View file @ 50d21397
...@@ -21,48 +21,11 @@ ...@@ -21,48 +21,11 @@
#include "aidge/backend/cpu/operator/ConvImpl.hpp" #include "aidge/backend/cpu/operator/ConvImpl.hpp"
#include "aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/ConvImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto &inputDims = std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), Aidge::NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
// for the direct convolution algorithm, convolutions can be in-place, if // this implementation can be in-place
// there is no padding!
return 0; return 0;
} }
Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
const std::vector<Aidge::DimSize_t> &/*inputsSize*/) const {
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const {
assert(static_cast<std::size_t>(inputIdx) < mNbConsumedData.size());
return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}
Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const {
assert((outputIdx == 0) && (static_cast<std::size_t>(outputIdx) < mNbProducedData.size()));
return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}
void Aidge::ConvImpl2D_cpu::updateConsummerProducer(){
// Update producer-consumer data
for (std::size_t inputIdx = 0; inputIdx < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx] += getNbRequiredData(static_cast<IOIndex_t>(inputIdx)); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
}
void Aidge::ConvImpl2D_cpu::forward() { void Aidge::ConvImpl2D_cpu::forward() {
// FIXME: uncomment the following code once memory handling will work // FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
...@@ -75,11 +38,7 @@ void Aidge::ConvImpl2D_cpu::forward() { ...@@ -75,11 +38,7 @@ void Aidge::ConvImpl2D_cpu::forward() {
mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()}); mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
kernelFunc(mOp.getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(), kernelFunc(dynamic_cast<const Conv_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
mOp.getInput(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getInput(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
} }
void Aidge::ConvImpl2D_cpu::backward() { printf("Not implemented yet.\n"); }
src/operator/FCImpl.cpp
+ 7
− 75
View file @ 50d21397
...@@ -21,78 +21,17 @@ ...@@ -21,78 +21,17 @@
#include "aidge/backend/cpu/operator/FCImpl.hpp" #include "aidge/backend/cpu/operator/FCImpl.hpp"
#include "aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/FCImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::FCImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const
{
assert(mOp.getInput(inputIdx) && "requires valid input");
// Requires the whole tensors
const auto &inputDims
= std::static_pointer_cast<Tensor>(mOp.getInput(inputIdx))->dims();
return std::accumulate(
inputDims.begin(),
inputDims.end(),
Aidge::NbElts_t(1),
std::multiplies<Aidge::NbElts_t>());
}
Aidge::NbElts_t
Aidge::FCImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const
{
// for the direct convolution algorithm, convolutions can be in-place, if
// there is no padding!
return 0;
}
Aidge::NbElts_t Aidge::FCImpl_cpu::getRequiredMemory(
const IOIndex_t outputIdx, const std::vector<DimSize_t> &/*inputsSize*/) const
{
// Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
const auto &outputDims = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->dims();
return std::accumulate(
outputDims.begin(),
outputDims.end(),
static_cast<NbElts_t>(1),
std::multiplies<NbElts_t>());
}
Aidge::NbElts_t Aidge::FCImpl_cpu::getNbConsumedData(Aidge::IOIndex_t inputIdx) const
{
assert((inputIdx != gk_IODefaultIndex) && (inputIdx < mNbConsumedData.size()));
return mNbConsumedData[static_cast<std::size_t>(inputIdx)];
}
Aidge::NbElts_t Aidge::FCImpl_cpu::getNbProducedData(Aidge::IOIndex_t outputIdx) const
{
assert(static_cast<std::size_t>(outputIdx) < mNbProducedData.size());
return mNbProducedData[static_cast<std::size_t>(outputIdx)];
}
void Aidge::FCImpl_cpu::updateConsummerProducer(){
// Update producer-consumer data
for (IOIndex_t inputIdx = 0; static_cast<std::size_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx]
+= getNbRequiredData(static_cast<std::size_t>(inputIdx)); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
}
void Aidge::FCImpl_cpu::forward() void Aidge::FCImpl_cpu::forward()
{ {
// FIXME: uncomment the following code once memory handling will work
assert(mOp.getInput(0) && "missing input #0"); assert(mOp.getInput(0) && "missing input #0");
assert(mOp.mInputs[1] && "missing input #1"); assert(mOp.getInput(1) && "missing input #1");
assert(mOp.mInputs[2] && "missing input #2"); assert(mOp.getInput(2) && "missing input #2");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<FCImplForward_cpu>::create( auto kernelFunc = Registrar<FCImplForward_cpu>::create(
{mOp.getInput(0)->dataType(), {mOp.getInput(0)->dataType(),
mOp.mInputs[1]->dataType(), mOp.getInput(1)->dataType(),
mOp.mInputs[2]->dataType(), mOp.getInput(2)->dataType(),
mOp.getOutput(0)->dataType()}); mOp.getOutput(0)->dataType()});
// Call kernel // Call kernel
...@@ -107,18 +46,11 @@ void Aidge::FCImpl_cpu::forward() ...@@ -107,18 +46,11 @@ void Aidge::FCImpl_cpu::forward()
// } // }
// else // else
kernelFunc( kernelFunc(
mOp.getStaticAttributes(), dynamic_cast<const FC_Op&>(mOp).getStaticAttributes(),
mOp.getInput(0)->dims()[0], mOp.getInput(0)->dims()[0],
mOp.getInput(0)->sizeM1(), mOp.getInput(0)->sizeM1(),
mOp.getInput(0)->getImpl()->rawPtr(), mOp.getInput(0)->getImpl()->rawPtr(),
mOp.mInputs[1]->getImpl()->rawPtr(), mOp.getInput(1)->getImpl()->rawPtr(),
mOp.mInputs[2]->getImpl()->rawPtr(), mOp.getInput(2)->getImpl()->rawPtr(),
mOp.getOutput(0)->getImpl()->rawPtr()); mOp.getOutput(0)->getImpl()->rawPtr());
}
void Aidge::FCImpl_cpu::backward()
{
printf("Not implemented yet.\n");
} }
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