Skip to content
Snippets Groups Projects
Commit 7702f776 authored by laurent soulier's avatar laurent soulier
Browse files

[MIN][DSGN] encapsulating raw pointer access into an helper function in order...

[MIN][DSGN] encapsulating raw pointer access into an helper function in order to make it easier to change implementation
related to aidge_core/#21
parent fafa52d8
No related branches found
No related tags found
No related merge requests found
Pipeline #35025 failed
Showing
with 861 additions and 702 deletions
/********************************************************************************
* Copyright (c) 2023 CEA-List
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*
********************************************************************************/
#ifndef AIDGE_CPU_DATA_GETCPUPTR_H_
#define AIDGE_CPU_DATA_GETCPUPTR_H_
#include "aidge/data/Tensor.hpp"
namespace Aidge {
inline void *getCPUPtr(std::shared_ptr<Aidge::Data> const &data) {
return std::static_pointer_cast<Tensor>(data)->getImpl()->rawPtr();
}
} // namespace Aidge
#endif // AIDGE_CPU_DATA_GETCPUPTR_H_
\ No newline at end of file
...@@ -7,73 +7,77 @@ ...@@ -7,73 +7,77 @@
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
namespace Aidge { namespace Aidge {
template <class T> template <class T> class TensorImpl_cpu : public TensorImpl {
class TensorImpl_cpu : public TensorImpl { private:
private: const Tensor &mTensor; // Impl needs to access Tensor information, but is not
const Tensor &mTensor; // Impl needs to access Tensor information, but is not // supposed to change it!
// supposed to change it! std::vector<T> mData;
std::vector<T> mData;
public:
public: static constexpr const char *Backend = "cpu";
static constexpr const char *Backend = "cpu";
TensorImpl_cpu(const Tensor &tensor) : TensorImpl(Backend), mTensor(tensor) {}
TensorImpl_cpu(const Tensor &tensor) : TensorImpl(Backend), mTensor(tensor) {}
bool operator==(const TensorImpl &otherImpl) const override final {
bool operator==(const TensorImpl &otherImpl) const override final { std::size_t i = 0;
std::size_t i = 0; for (; i < mTensor.size() &&
for (; i < mTensor.size() && mData[i] ==
mData[i] == reinterpret_cast<const TensorImpl_cpu<T> &>(otherImpl).data()[i]; reinterpret_cast<const TensorImpl_cpu<T> &>(otherImpl).data()[i];
++i) { ++i) {
}
return i == mTensor.size();
} }
return i == mTensor.size();
}
static std::unique_ptr<TensorImpl_cpu> create(const Tensor &tensor) { static std::unique_ptr<TensorImpl_cpu> create(const Tensor &tensor) {
return std::make_unique<TensorImpl_cpu<T>>(tensor); return std::make_unique<TensorImpl_cpu<T>>(tensor);
} }
// native interface // native interface
const std::vector<T> &data() const { return mData; } const std::vector<T> &data() const { return mData; }
std::size_t scalarSize() const override { return sizeof(T); } std::size_t scalarSize() const override { return sizeof(T); }
void copy(const void *src, NbElts_t length) override { void copy(const void *src, NbElts_t length) override {
std::copy(static_cast<const T *>(src), static_cast<const T *>(src) + length, std::copy(static_cast<const T *>(src), static_cast<const T *>(src) + length,
static_cast<T *>(rawPtr())); static_cast<T *>(rawPtr()));
} }
void *rawPtr() override { void *rawPtr() override {
lazyInit(mData); lazyInit(mData);
return mData.data(); return mData.data();
}; };
void* getRaw(std::size_t idx){ void *getRaw(std::size_t idx) {
return static_cast<void*>(static_cast<T *>(rawPtr()) + idx); return static_cast<void *>(static_cast<T *>(rawPtr()) + idx);
}; };
virtual ~TensorImpl_cpu() = default; virtual ~TensorImpl_cpu() = default;
void setRawPtr(void *ptr) override final { void setRawPtr(void *ptr) override final {
T *newPtr = static_cast<T *>(ptr); T *newPtr = static_cast<T *>(ptr);
mData = std::vector<T>(newPtr, newPtr + mTensor.size()); mData = std::vector<T>(newPtr, newPtr + mTensor.size());
}; };
private: private:
void lazyInit(std::vector<T> &data) { void lazyInit(std::vector<T> &data) {
assert(mTensor.dataType() == NativeType<T>::type); assert(mTensor.dataType() == NativeType<T>::type);
if (data.size() != mTensor.size()) data.resize(mTensor.size()); if (data.size() != mTensor.size())
} data.resize(mTensor.size());
}
}; };
namespace { namespace {
static Registrar<Tensor> registrarTensorImpl_cpu_Float64( static Registrar<Tensor>
{"cpu", DataType::Float64}, Aidge::TensorImpl_cpu<double>::create); registrarTensorImpl_cpu_Float64({"cpu", DataType::Float64},
static Registrar<Tensor> registrarTensorImpl_cpu_Float32( Aidge::TensorImpl_cpu<double>::create);
{"cpu", DataType::Float32}, Aidge::TensorImpl_cpu<float>::create); static Registrar<Tensor>
static Registrar<Tensor> registrarTensorImpl_cpu_Int32( registrarTensorImpl_cpu_Float32({"cpu", DataType::Float32},
{"cpu", DataType::Int32}, Aidge::TensorImpl_cpu<int>::create); Aidge::TensorImpl_cpu<float>::create);
} // namespace static Registrar<Tensor>
} // namespace Aidge registrarTensorImpl_cpu_Int32({"cpu", DataType::Int32},
Aidge::TensorImpl_cpu<int>::create);
} // namespace
} // namespace Aidge
#endif /* AIDGE_CPU_DATA_TENSORIMPL_H_ */ #endif /* AIDGE_CPU_DATA_TENSORIMPL_H_ */
...@@ -29,187 +29,203 @@ namespace Aidge { ...@@ -29,187 +29,203 @@ namespace Aidge {
template <DimIdx_t DIM> template <DimIdx_t DIM>
class SliceImplForward_cpu class SliceImplForward_cpu
: public Registrable<SliceImplForward_cpu<DIM>, std::tuple<DataType>, : public Registrable<SliceImplForward_cpu<DIM>, std::tuple<DataType>,
void(const typename Slice_Op<DIM>::Attrs&, void(const typename Slice_Op<DIM>::Attrs &,
const std::array<std::size_t, DIM>, const std::array<std::size_t, DIM>, const void *,
const void*, void *)> {};
void*)> {};
template <DimIdx_t DIM> template <DimIdx_t DIM>
class SliceImplBackward_cpu class SliceImplBackward_cpu
: public Registrable<SliceImplBackward_cpu<DIM>, std::tuple<DataType>, : public Registrable<SliceImplBackward_cpu<DIM>, std::tuple<DataType>,
void(const typename Slice_Op<DIM>::Attrs&, void(const typename Slice_Op<DIM>::Attrs &,
const std::array<std::size_t, DIM>, const std::array<std::size_t, DIM>, const void *,
const void*, void *)> {};
void*)> {};
template <DimIdx_t DIM> template <DimIdx_t DIM> class SliceImpl_cpu : public OperatorImpl {
class SliceImpl_cpu : public OperatorImpl { public:
public: SliceImpl_cpu(const Slice_Op<DIM> &op) : OperatorImpl(op) {}
SliceImpl_cpu(const Slice_Op<DIM>& op) : OperatorImpl(op) {}
static std::unique_ptr<SliceImpl_cpu<DIM>> create(const Slice_Op<DIM> &op) {
static std::unique_ptr<SliceImpl_cpu<DIM>> create(const Slice_Op<DIM>& op) { return std::make_unique<SliceImpl_cpu<DIM>>(op);
return std::make_unique<SliceImpl_cpu<DIM>>(op); }
}
public:
public: NbElts_t
NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final { getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"requires valid input");
// Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(); // Requires the whole tensors
const auto &inputDims =
return std::accumulate(inputDims.begin(), inputDims.end(), static_cast<NbElts_t>(1), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims();
std::multiplies<NbElts_t>());
} return std::accumulate(inputDims.begin(), inputDims.end(),
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final { return 0; } static_cast<NbElts_t>(1),
NbElts_t getRequiredMemory(const IOIndex_t outputIdx, std::multiplies<NbElts_t>());
const std::vector<DimSize_t>& inputsSize) const override final { }
(void)outputIdx; NbElts_t
(void)inputsSize; getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final {
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(); return 0;
return std::accumulate(outputDims.begin(), outputDims.end(), static_cast<NbElts_t>(1), }
std::multiplies<NbElts_t>()); NbElts_t getRequiredMemory(
} const IOIndex_t outputIdx,
NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final { const std::vector<DimSize_t> &inputsSize) const override final {
return mNbConsumedData[0]; (void)outputIdx;
} (void)inputsSize;
NbElts_t getNbProducedData(const IOIndex_t /*outputIdx*/) const override final { const auto &outputDims =
return mNbProducedData[0]; std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims();
} return std::accumulate(outputDims.begin(), outputDims.end(),
void updateConsummerProducer() override final { static_cast<NbElts_t>(1),
// each input is consumed by the minimum amount for a forward pass std::multiplies<NbElts_t>());
mNbConsumedData[0] += getNbRequiredData(0); }
NbElts_t
mNbProducedData[0] += getRequiredMemory(0, {}); getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final {
} return mNbConsumedData[0];
}
void forward() override { NbElts_t
// FIXME: uncomment the following code once memory handling will work getNbProducedData(const IOIndex_t /*outputIdx*/) const override final {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); return mNbProducedData[0];
}
// Find the correct kernel type void updateConsummerProducer() override final {
auto kernelFunc = Registrar<SliceImplForward_cpu<DIM>>::create( // each input is consumed by the minimum amount for a forward pass
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()}); mNbConsumedData[0] += getNbRequiredData(0);
// Call kernel mNbProducedData[0] += getRequiredMemory(0, {});
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<DIM>(), }
std::get<1>(std::static_pointer_cast<const Slice_Op<DIM>&>(mOp).getStaticAttributes()),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), void forward() override {
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr() // FIXME: uncomment the following code once memory handling will work
); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); // Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu<DIM>>::create(
mNbProducedData[0] += getRequiredMemory(0, {}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
}
// Call kernel
void backward() override { printf("Not implemented yet.\n"); } kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))
->template dims<DIM>(),
std::get<1>(std::static_pointer_cast<const Slice_Op<DIM> &>(mOp)
.getStaticAttributes()),
getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
// each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {});
}
void backward() override { printf("Not implemented yet.\n"); }
}; };
/******************************************************************************/ /******************************************************************************/
template <> template <> class SliceImpl_cpu<1> : public OperatorImpl {
class SliceImpl_cpu<1> : public OperatorImpl {
public: public:
SliceImpl_cpu(const Slice_Op<1>& op) : OperatorImpl(op) {} SliceImpl_cpu(const Slice_Op<1> &op) : OperatorImpl(op) {}
static std::unique_ptr<SliceImpl_cpu<1>> create(const Slice_Op<1>& op) { static std::unique_ptr<SliceImpl_cpu<1>> create(const Slice_Op<1> &op) {
return std::make_unique<SliceImpl_cpu<1>>(op); return std::make_unique<SliceImpl_cpu<1>>(op);
} }
public: public:
NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final; NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final; NbElts_t
NbElts_t getRequiredMemory(const IOIndex_t outputIdx, getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
const std::vector<DimSize_t>& inputsSize) const override final; NbElts_t getRequiredMemory(
NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final; const IOIndex_t outputIdx,
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final; const std::vector<DimSize_t> &inputsSize) const override final;
void updateConsummerProducer() override final; NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void forward() override; void updateConsummerProducer() override final;
void backward() override;
void forward() override;
void backward() override;
}; };
/******************************************************************************/ /******************************************************************************/
template <> template <> class SliceImpl_cpu<2> : public OperatorImpl {
class SliceImpl_cpu<2> : public OperatorImpl { public:
public: SliceImpl_cpu(const Slice_Op<2> &op) : OperatorImpl(op) {}
SliceImpl_cpu(const Slice_Op<2>& op) : OperatorImpl(op) {}
static std::unique_ptr<SliceImpl_cpu<2>> create(const Slice_Op<2> &op) {
static std::unique_ptr<SliceImpl_cpu<2>> create(const Slice_Op<2>& op) { return std::make_unique<SliceImpl_cpu<2>>(op);
return std::make_unique<SliceImpl_cpu<2>>(op); }
}
public:
public: NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final; NbElts_t
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final; getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getRequiredMemory(const IOIndex_t outputIdx, NbElts_t getRequiredMemory(
const std::vector<DimSize_t>& inputsSize) const override final; const IOIndex_t outputIdx,
NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final; const std::vector<DimSize_t> &inputsSize) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final; NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
void updateConsummerProducer() override final; NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override;
void backward() override; void forward() override;
void backward() override;
}; };
/******************************************************************************/ /******************************************************************************/
template <> template <> class SliceImpl_cpu<3> : public OperatorImpl {
class SliceImpl_cpu<3> : public OperatorImpl { public:
public: SliceImpl_cpu(const Slice_Op<3> &op) : OperatorImpl(op) {}
SliceImpl_cpu(const Slice_Op<3>& op) : OperatorImpl(op) {}
static std::unique_ptr<SliceImpl_cpu<3>> create(const Slice_Op<3> &op) {
static std::unique_ptr<SliceImpl_cpu<3>> create(const Slice_Op<3>& op) { return std::make_unique<SliceImpl_cpu<3>>(op);
return std::make_unique<SliceImpl_cpu<3>>(op); }
}
public:
public: NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getNbRequiredData(const IOIndex_t /*inputIdx*/) const override final; NbElts_t
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final; getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
NbElts_t getRequiredMemory(const IOIndex_t outputIdx, NbElts_t getRequiredMemory(
const std::vector<DimSize_t>& inputsSize) const override final; const IOIndex_t outputIdx,
NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final; const std::vector<DimSize_t> &inputsSize) const override final;
NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final; NbElts_t getNbConsumedData(const IOIndex_t /*inputIdx*/) const override final;
void updateConsummerProducer() override final; NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
void updateConsummerProducer() override final;
void forward() override;
void backward() override; void forward() override;
void backward() override;
}; };
/******************************************************************************/ /******************************************************************************/
template <> template <> class SliceImpl_cpu<4> : public OperatorImpl {
class SliceImpl_cpu<4> : public OperatorImpl { public:
public: SliceImpl_cpu(const Slice_Op<4> &op) : OperatorImpl(op) {}
SliceImpl_cpu(const Slice_Op<4>& op) : OperatorImpl(op) {}
static std::unique_ptr<SliceImpl_cpu<4>> create(const Slice_Op<4>& op) {
return std::make_unique<SliceImpl_cpu<4>>(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 backward() override;
};
static std::unique_ptr<SliceImpl_cpu<4>> create(const Slice_Op<4> &op) {
return std::make_unique<SliceImpl_cpu<4>>(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 backward() override;
};
namespace { namespace {
static Registrar<Slice_Op<1>> registrarSliceImpl_1D_cpu("cpu", Aidge::SliceImpl_cpu<1>::create); static Registrar<Slice_Op<1>>
static Registrar<Slice_Op<2>> registrarSliceImpl_2D_cpu("cpu", Aidge::SliceImpl_cpu<2>::create); registrarSliceImpl_1D_cpu("cpu", Aidge::SliceImpl_cpu<1>::create);
static Registrar<Slice_Op<3>> registrarSliceImpl_3D_cpu("cpu", Aidge::SliceImpl_cpu<3>::create); static Registrar<Slice_Op<2>>
static Registrar<Slice_Op<4>> registrarSliceImpl_4D_cpu("cpu", Aidge::SliceImpl_cpu<4>::create); registrarSliceImpl_2D_cpu("cpu", Aidge::SliceImpl_cpu<2>::create);
} // namespace static Registrar<Slice_Op<3>>
} // namespace Aidge registrarSliceImpl_3D_cpu("cpu", Aidge::SliceImpl_cpu<3>::create);
static Registrar<Slice_Op<4>>
registrarSliceImpl_4D_cpu("cpu", Aidge::SliceImpl_cpu<4>::create);
} // namespace
} // namespace Aidge
#endif /* AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_H_ */ #endif /* AIDGE_CPU_OPERATOR_LEAKYRELUIMPL_H_ */
...@@ -13,71 +13,87 @@ ...@@ -13,71 +13,87 @@
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/data/Data.hpp" #include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/AddImpl.hpp" #include "aidge/backend/cpu/operator/AddImpl.hpp"
#include "aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::AddImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const { Aidge::NbElts_t
assert(mOp.getRawInput(inputIdx) && "requires valid input"); Aidge::AddImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getRawInput(inputIdx) && "requires valid input");
// Requires the whole tensors // Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims(); const auto &inputDims =
return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>()); std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1),
std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::AddImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::AddImpl_cpu::getNbRequiredProtected(
// for the direct convolution algorithm, convolutions can be in-place, if there is no padding! const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // for the direct convolution algorithm, convolutions can be in-place, if
// there is no padding!
return 0;
} }
Aidge::NbElts_t Aidge::AddImpl_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const { Aidge::NbElts_t Aidge::AddImpl_cpu::getRequiredMemory(
// Requires the whole tensors, regardless of available data on inputs const Aidge::IOIndex_t outputIdx,
assert(outputIdx == 0 && "operator has only one output"); const std::vector<Aidge::DimSize_t> & /*inputsSize*/) const {
(void) outputIdx; // Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(); (void)outputIdx;
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
const auto &outputDims =
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1),
std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::AddImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t inputIdx) const { Aidge::NbElts_t
assert(inputIdx < mNbConsumedData.size()); Aidge::AddImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t inputIdx) const {
return mNbConsumedData[inputIdx]; assert(inputIdx < mNbConsumedData.size());
return mNbConsumedData[inputIdx];
} }
Aidge::NbElts_t Aidge::AddImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const { Aidge::NbElts_t
assert(outputIdx < mNbProducedData.size()); Aidge::AddImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const {
return mNbProducedData[outputIdx]; assert(outputIdx < mNbProducedData.size());
return mNbProducedData[outputIdx];
} }
void Aidge::AddImpl_cpu::updateConsummerProducer() { void Aidge::AddImpl_cpu::updateConsummerProducer() {
for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx) for (IOIndex_t inputIdx = 0;
mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx] +=
mNbProducedData[0]+= getRequiredMemory(0, {}); getNbRequiredData(inputIdx); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::AddImpl_cpu::forward() { void Aidge::AddImpl_cpu::forward() {
assert(mOp.getRawInput(0) && "missing input in Add operator"); assert(mOp.getRawInput(0) && "missing input in Add operator");
DataType datatypeFirstInput = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(); DataType datatypeFirstInput =
for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) { std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType();
assert(mOp.getRawInput(i) && "missing input in Add operator"); for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() == datatypeFirstInput); assert(mOp.getRawInput(i) && "missing input in Add operator");
} assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() ==
datatypeFirstInput);
auto kernelFunc = Registrar<AddImplForward_cpu>::create({ }
datatypeFirstInput,
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); auto kernelFunc = Registrar<AddImplForward_cpu>::create(
{datatypeFirstInput,
std::vector<const void*> opInputs; std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
opInputs.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->getImpl()->rawPtr()); std::vector<const void *> opInputs;
} for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
opInputs.push_back(getCPUPtr(mOp.getRawInput(i)));
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(), }
opInputs,
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
opInputs, getCPUPtr(mOp.getRawOutput(0)));
} }
\ No newline at end of file
...@@ -14,27 +14,30 @@ ...@@ -14,27 +14,30 @@
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "aidge/utils/Types.h"
#include "aidge/operator/AvgPooling.hpp" #include "aidge/operator/AvgPooling.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#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::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(
// this implementation can be in-place IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::AvgPoolingImpl2D_cpu::forward() { void Aidge::AvgPoolingImpl2D_cpu::forward() {
assert(mOp.getRawInput(0) && "missing input #0"); assert(mOp.getRawInput(0) && "missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = auto kernelFunc = Registrar<AvgPoolingImpl2DForward_cpu>::create(
Registrar<AvgPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const AvgPooling_Op<2>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), dynamic_cast<const AvgPooling_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -13,39 +13,38 @@ ...@@ -13,39 +13,38 @@
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/BatchNorm.hpp" #include "aidge/operator/BatchNorm.hpp"
#include "aidge/utils/Types.h"
#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::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(
// this implementation can be in-place IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::BatchNormImpl2D_cpu::forward() { void Aidge::BatchNormImpl2D_cpu::forward() {
assert(mOp.getRawInput(0) && "missing input #0"); assert(mOp.getRawInput(0) && "missing input #0");
assert(mOp.getRawInput(1) && "missing input #1"); assert(mOp.getRawInput(1) && "missing input #1");
assert(mOp.getRawInput(2) && "missing input #2"); assert(mOp.getRawInput(2) && "missing input #2");
assert(mOp.getRawInput(3) && "missing input #3"); assert(mOp.getRawInput(3) && "missing input #3");
assert(mOp.getRawInput(4) && "missing input #4"); assert(mOp.getRawInput(4) && "missing input #4");
assert(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->nbDims() == 4); assert(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->nbDims() == 4);
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = auto kernelFunc = Registrar<BatchNormImpl2DForward_cpu>::create(
Registrar<BatchNormImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const BatchNorm_Op<2>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), dynamic_cast<const BatchNorm_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(2)), getCPUPtr(mOp.getRawInput(3)),
std::static_pointer_cast<Tensor>(mOp.getRawInput(3))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(4)), getCPUPtr(mOp.getRawOutput(0)), true);
std::static_pointer_cast<Tensor>(mOp.getRawInput(4))->getImpl()->rawPtr(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr(),
true);
} }
...@@ -13,77 +13,96 @@ ...@@ -13,77 +13,96 @@
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/data/Data.hpp" #include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/ConcatImpl.hpp" #include "aidge/backend/cpu/operator/ConcatImpl.hpp"
#include "aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const { Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredData(
assert(mOp.getRawInput(inputIdx) && "requires valid input"); const Aidge::IOIndex_t inputIdx) const {
assert(mOp.getRawInput(inputIdx) && "requires valid input");
// Requires the whole tensors // Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims(); const auto &inputDims =
return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>()); std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims();
return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1),
std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredProtected(
// for the direct convolution algorithm, convolutions can be in-place, if there is no padding! const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // for the direct convolution algorithm, convolutions can be in-place, if
// there is no padding!
return 0;
} }
Aidge::NbElts_t Aidge::ConcatImpl_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx, const std::vector<Aidge::DimSize_t>& /*inputsSize*/) const { Aidge::NbElts_t Aidge::ConcatImpl_cpu::getRequiredMemory(
// Requires the whole tensors, regardless of available data on inputs const Aidge::IOIndex_t outputIdx,
assert(outputIdx == 0 && "operator has only one output"); const std::vector<Aidge::DimSize_t> & /*inputsSize*/) const {
(void) outputIdx; // Requires the whole tensors, regardless of available data on inputs
assert(outputIdx == 0 && "operator has only one output");
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(); (void)outputIdx;
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
const auto &outputDims =
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims();
return std::accumulate(outputDims.begin(), outputDims.end(), NbElts_t(1),
std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t inputIdx) const { Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbConsumedData(
assert(inputIdx < mNbConsumedData.size()); const Aidge::IOIndex_t inputIdx) const {
return mNbConsumedData[inputIdx]; assert(inputIdx < mNbConsumedData.size());
return mNbConsumedData[inputIdx];
} }
Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const { Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbProducedData(
assert(outputIdx < mNbProducedData.size()); const Aidge::IOIndex_t outputIdx) const {
return mNbProducedData[outputIdx]; assert(outputIdx < mNbProducedData.size());
return mNbProducedData[outputIdx];
} }
void Aidge::ConcatImpl_cpu::updateConsummerProducer() { void Aidge::ConcatImpl_cpu::updateConsummerProducer() {
for (IOIndex_t inputIdx = 0; static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx) for (IOIndex_t inputIdx = 0;
mNbConsumedData[inputIdx]+= getNbRequiredData(inputIdx); // each input is consumed by the minimum amount for a forward pass static_cast<NbElts_t>(inputIdx) < mNbConsumedData.size(); ++inputIdx)
mNbConsumedData[inputIdx] +=
mNbProducedData[0]+= getRequiredMemory(0, {}); getNbRequiredData(inputIdx); // each input is consumed by the minimum
// amount for a forward pass
mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::ConcatImpl_cpu::forward() { void Aidge::ConcatImpl_cpu::forward() {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input in Concat operator"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
DataType datatypeFirstInput = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(); "missing input in Concat operator");
for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) { DataType datatypeFirstInput =
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i)) && "missing input in Concat operator"); std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType();
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() == datatypeFirstInput); for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) {
} assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i)) &&
"missing input in Concat operator");
auto kernelFunc = Registrar<ConcatImplForward_cpu>::create({ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() ==
datatypeFirstInput, datatypeFirstInput);
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); }
std::vector<const void*> opInputs; auto kernelFunc = Registrar<ConcatImplForward_cpu>::create(
std::vector<DimSize_t> opInputAxis; {datatypeFirstInput,
for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) { std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
opInputs.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->getImpl()->rawPtr());
opInputAxis.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dims()[dynamic_cast<const Concat_Op&>(mOp).template getAttr<DimSize_t>("Axis")]); std::vector<const void *> opInputs;
} std::vector<DimSize_t> opInputAxis;
for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
kernelFunc(dynamic_cast<const Concat_Op&>(mOp).getStaticAttributes(), opInputs.push_back(getCPUPtr(mOp.getRawInput(i)));
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(), opInputAxis.push_back(
opInputAxis, std::static_pointer_cast<Tensor>(mOp.getRawInput(i))
opInputs, ->dims()[dynamic_cast<const Concat_Op &>(mOp)
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); .template getAttr<DimSize_t>("Axis")]);
}
kernelFunc(dynamic_cast<const Concat_Op &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
opInputAxis, opInputs, getCPUPtr(mOp.getRawOutput(0)));
} }
void Aidge::ConcatImpl_cpu::backward() { printf("Not implemented yet.\n"); } void Aidge::ConcatImpl_cpu::backward() { printf("Not implemented yet.\n"); }
\ No newline at end of file \ No newline at end of file
...@@ -15,35 +15,39 @@ ...@@ -15,35 +15,39 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/ConvDepthWise.hpp" #include "aidge/operator/ConvDepthWise.hpp"
#include "aidge/utils/Types.h"
#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::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(
// this implementation can be in-place IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::ConvDepthWiseImpl2D_cpu::forward() { void Aidge::ConvDepthWiseImpl2D_cpu::forward() {
assert(mOp.getRawInput(0) && "missing input #0"); assert(mOp.getRawInput(0) && "missing input #0");
assert(mOp.getRawInput(1) && "missing input #1"); assert(mOp.getRawInput(1) && "missing input #1");
assert(mOp.getRawInput(2) && "missing input #2"); assert(mOp.getRawInput(2) && "missing input #2");
assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims() == 4) && "support for 4-dimensions tensors only"); assert(
(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims() == 4) &&
// Find the correct kernel type "support for 4-dimensions tensors only");
auto kernelFunc =
Registrar<ConvDepthWiseImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), // Find the correct kernel type
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), auto kernelFunc = Registrar<ConvDepthWiseImpl2DForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(),
// Call kernel std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
kernelFunc(dynamic_cast<const ConvDepthWise_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), // Call kernel
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(), dynamic_cast<const ConvDepthWise_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
getCPUPtr(mOp.getRawInput(2)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -15,32 +15,36 @@ ...@@ -15,32 +15,36 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/Conv.hpp" #include "aidge/operator/Conv.hpp"
#include "aidge/utils/Types.h"
#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::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t
// this implementation can be in-place Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 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.getRawInput(0) && "missing input #0"); assert(mOp.getRawInput(0) && "missing input #0");
assert(mOp.getRawInput(1) && "missing input #1"); assert(mOp.getRawInput(1) && "missing input #1");
assert(mOp.getRawInput(2) && "missing input #2"); assert(mOp.getRawInput(2) && "missing input #2");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = auto kernelFunc = Registrar<ConvImpl2DForward_cpu>::create(
Registrar<ConvImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const Conv_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), dynamic_cast<const Conv_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
getCPUPtr(mOp.getRawInput(2)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -15,28 +15,34 @@ ...@@ -15,28 +15,34 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/Div.hpp" #include "aidge/operator/Div.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/DivImpl.hpp" #include "aidge/backend/cpu/operator/DivImpl.hpp"
#include "aidge/backend/cpu/operator/DivImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/DivImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::DivImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::DivImpl_cpu::getNbRequiredProtected(
// this implementation can be in-place const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::DivImpl_cpu::forward() { void Aidge::DivImpl_cpu::forward() {
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<DivImplForward_cpu>::create({ auto kernelFunc = Registrar<DivImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)))->size(), kernelFunc(std::static_pointer_cast<Tensor>(
std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)))->size(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0)))
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), ->size(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); std::static_pointer_cast<Tensor>(mOp.getRawInput(1)))
->size(),
getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -15,42 +15,43 @@ ...@@ -15,42 +15,43 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/FC.hpp" #include "aidge/operator/FC.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#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"
void Aidge::FCImpl_cpu::forward() void Aidge::FCImpl_cpu::forward() {
{ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); "missing input #0");
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) &&
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(2)) && "missing input #2"); "missing input #1");
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(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(
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
// if (std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->nbDims() == 4) { // if (std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->nbDims() == 4) {
// kernelFunc( // kernelFunc(
// mOp.getStaticAttributes(), // mOp.getStaticAttributes(),
// std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), // std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template
// std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->getImpl()->rawPtr(), // dims<4>(), getCPUPtr(mOp.getRawInput(0),
// mOp.mInputs[1]->getImpl()->rawPtr(), // mOp.mInputs[1]->getImpl()->rawPtr(),
// mOp.mInputs[2]->getImpl()->rawPtr(), // mOp.mInputs[2]->getImpl()->rawPtr(),
// mOp.getOutput(0)->getImpl()->rawPtr()); // mOp.getOutput(0)->getImpl()->rawPtr());
// } // }
// else // else
kernelFunc( kernelFunc(dynamic_cast<const FC_Op &>(mOp).getStaticAttributes(),
dynamic_cast<const FC_Op&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0],
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0], std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1(), getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(2)), getCPUPtr(mOp.getRawOutput(0)));
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->getImpl()->rawPtr(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
} }
...@@ -15,28 +15,31 @@ ...@@ -15,28 +15,31 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/LeakyReLU.hpp" #include "aidge/operator/LeakyReLU.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp" #include "aidge/backend/cpu/operator/LeakyReLUImpl.hpp"
#include "aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/LeakyReLUImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::LeakyReLUImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::LeakyReLUImpl_cpu::getNbRequiredProtected(
// this implementation can be in-place const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::LeakyReLUImpl_cpu::forward() { void Aidge::LeakyReLUImpl_cpu::forward() {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<LeakyReLUImplForward_cpu>::create({ // Find the correct kernel type
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), auto kernelFunc = Registrar<LeakyReLUImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const LeakyReLU_Op&>(mOp).getStaticAttributes(), // Call kernel
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(), kernelFunc(dynamic_cast<const LeakyReLU_Op &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -15,41 +15,40 @@ ...@@ -15,41 +15,40 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/MatMul.hpp" #include "aidge/operator/MatMul.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/MatMulImpl.hpp" #include "aidge/backend/cpu/operator/MatMulImpl.hpp"
#include "aidge/backend/cpu/operator/MatMulImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/MatMulImpl_forward_kernels.hpp"
void Aidge::MatMulImpl_cpu::forward() void Aidge::MatMulImpl_cpu::forward() {
{ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); "missing input #0");
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) &&
"missing input #1");
// Find the correct kernel type
auto kernelFunc = Registrar<MatMulImplForward_cpu>::create( // Find the correct kernel type
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), auto kernelFunc = Registrar<MatMulImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
// if (mOp.getInput(0)->nbDims() == 4) { // Call kernel
// kernelFunc( // if (mOp.getInput(0)->nbDims() == 4) {
// mOp.getStaticAttributes(), // kernelFunc(
// std::static_pointer_cast<Tensor>(mOp.getInput(0))->template dims<4>(), // mOp.getStaticAttributes(),
// mOp.getInput(0))->getImpl()->rawPtr(), // std::static_pointer_cast<Tensor>(mOp.getInput(0))->template
// mOp.mInputs[1]->getImpl()->rawPtr(), // dims<4>(), mOp.getInput(0))->getImpl()->rawPtr(),
// mOp.mInputs[2]->getImpl()->rawPtr(), // mOp.mInputs[1]->getImpl()->rawPtr(),
// std::static_pointer_cast<Tensor>(mOp.getRawOutput(0)->getImpl()->rawPtr()); // mOp.mInputs[2]->getImpl()->rawPtr(),
// } // getCPUPtr(mOp.getRawOutput(0));
// else // }
kernelFunc( // else
dynamic_cast<const MatMul_Op&>(mOp).getStaticAttributes(), kernelFunc(dynamic_cast<const MatMul_Op &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0], std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0],
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->sizeM1(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawOutput(0)));
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
} }
...@@ -14,27 +14,31 @@ ...@@ -14,27 +14,31 @@
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/MaxPooling.hpp" #include "aidge/operator/MaxPooling.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp" #include "aidge/backend/cpu/operator/MaxPoolingImpl.hpp"
#include "aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/MaxPoolingImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::MaxPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::MaxPoolingImpl2D_cpu::getNbRequiredProtected(
// this implementation can be in-place IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::MaxPoolingImpl2D_cpu::forward() { void Aidge::MaxPoolingImpl2D_cpu::forward() {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = auto kernelFunc = Registrar<MaxPoolingImpl2DForward_cpu>::create(
Registrar<MaxPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const MaxPooling_Op<2>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), dynamic_cast<const MaxPooling_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -15,28 +15,30 @@ ...@@ -15,28 +15,30 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/Mul.hpp" #include "aidge/operator/Mul.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/MulImpl.hpp" #include "aidge/backend/cpu/operator/MulImpl.hpp"
#include "aidge/backend/cpu/operator/MulImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/MulImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::MulImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::MulImpl_cpu::getNbRequiredProtected(
// this implementation can be in-place const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::MulImpl_cpu::forward() { void Aidge::MulImpl_cpu::forward() {
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<MulImplForward_cpu>::create({ auto kernelFunc = Registrar<MulImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(), kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawOutput(0)));
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
} }
...@@ -15,33 +15,40 @@ ...@@ -15,33 +15,40 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/utils/Types.h" #include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/Conv.hpp" #include "aidge/operator/Conv.hpp"
#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/PadImpl.hpp" #include "aidge/backend/cpu/operator/PadImpl.hpp"
#include "aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/PadImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) const { Aidge::NbElts_t
assert(inputIdx == 0 && "operator has only one input"); Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx) const {
(void) inputIdx; assert(inputIdx == 0 && "operator has only one input");
(void)inputIdx;
// Padding cannot be in-place!
// We must ensure that we do not override data that has not been consummed yet. // Padding cannot be in-place!
const auto inputSize = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(); // We must ensure that we do not override data that has not been consummed
const auto outputSize = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->size(); // yet.
return (outputSize - inputSize); const auto inputSize =
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size();
const auto outputSize =
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->size();
return (outputSize - inputSize);
} }
void Aidge::PadImpl2D_cpu::forward() { void Aidge::PadImpl2D_cpu::forward() {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type
auto kernelFunc = // Find the correct kernel type
Registrar<PadImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); auto kernelFunc = Registrar<PadImpl2DForward_cpu>::create(
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
// Call kernel std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
kernelFunc(dynamic_cast<const Pad_Op<2>&>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), // Call kernel
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); dynamic_cast<const Pad_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -15,28 +15,30 @@ ...@@ -15,28 +15,30 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/Pow.hpp" #include "aidge/operator/Pow.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/PowImpl.hpp" #include "aidge/backend/cpu/operator/PowImpl.hpp"
#include "aidge/backend/cpu/operator/PowImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/PowImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::PowImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::PowImpl_cpu::getNbRequiredProtected(
// this implementation can be in-place const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::PowImpl_cpu::forward() { void Aidge::PowImpl_cpu::forward() {
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<PowImplForward_cpu>::create({ auto kernelFunc = Registrar<PowImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(), kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(), std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawInput(1)),
std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawOutput(0)));
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
} }
...@@ -15,27 +15,30 @@ ...@@ -15,27 +15,30 @@
#include <thread> // std::this_thread::sleep_for #include <thread> // std::this_thread::sleep_for
#include <vector> #include <vector>
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/ReLU.hpp" #include "aidge/operator/ReLU.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/ReLUImpl.hpp" #include "aidge/backend/cpu/operator/ReLUImpl.hpp"
#include "aidge/backend/cpu/operator/ReLUImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/ReLUImpl_forward_kernels.hpp"
Aidge::NbElts_t Aidge::ReLUImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::ReLUImpl_cpu::getNbRequiredProtected(
// this implementation can be in-place const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::ReLUImpl_cpu::forward() { void Aidge::ReLUImpl_cpu::forward() {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<ReLUImplForward_cpu>::create({ auto kernelFunc = Registrar<ReLUImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(), kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
} }
...@@ -10,32 +10,35 @@ ...@@ -10,32 +10,35 @@
********************************************************************************/ ********************************************************************************/
#include <cassert> #include <cassert>
#include <numeric> // std::accumulate
#include <functional> // std::multiplies #include <functional> // std::multiplies
#include <numeric> // std::accumulate
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/operator/Scaling.hpp" #include "aidge/operator/Scaling.hpp"
#include "aidge/backend/cpu/operator/ScalingImpl.hpp" #include "aidge/backend/cpu/operator/ScalingImpl.hpp"
#include "aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include <vector> #include <vector>
Aidge::NbElts_t Aidge::ScalingImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::ScalingImpl_cpu::getNbRequiredProtected(
// this implementation can be in-place const Aidge::IOIndex_t /*inputIdx*/) const {
return 0; // this implementation can be in-place
return 0;
} }
void Aidge::ScalingImpl_cpu::forward() { void Aidge::ScalingImpl_cpu::forward() {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<ScalingImplForward_cpu>::create({ // Find the correct kernel type
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), auto kernelFunc = Registrar<ScalingImplForward_cpu>::create(
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const Scaling_Op&>(mOp).getStaticAttributes(), // Call kernel
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(), kernelFunc(dynamic_cast<const Scaling_Op &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr()); getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
} }
...@@ -10,249 +10,290 @@ ...@@ -10,249 +10,290 @@
********************************************************************************/ ********************************************************************************/
#include <cassert> #include <cassert>
#include <numeric> // std::accumulate
#include <functional> // std::multiplies #include <functional> // std::multiplies
#include <numeric> // std::accumulate
#include "aidge/operator/Slice.hpp" #include "aidge/operator/Slice.hpp"
#include "aidge/backend/cpu/data/GetCPUPtr.h"
#include "aidge/backend/cpu/operator/SliceImpl.hpp" #include "aidge/backend/cpu/operator/SliceImpl.hpp"
#include "aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp" #include "aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp"
#include "aidge/utils/Types.h" #include "aidge/utils/Types.h"
#include <vector>
#include <cassert> #include <cassert>
#include <tuple> #include <tuple>
#include <vector>
Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbRequiredData(
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input"); const Aidge::IOIndex_t /*inputIdx*/) const {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"requires valid input");
// Requires the whole tensors // Requires the whole tensors
return std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<1>()[0]; return std::static_pointer_cast<Tensor>(mOp.getRawInput(0))
->template dims<1>()[0];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; } Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbRequiredProtected(
const Aidge::IOIndex_t /*inputIdx*/) const {
return 0;
}
Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getRequiredMemory(const Aidge::IOIndex_t outputIdx, Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getRequiredMemory(
const std::vector<Aidge::DimSize_t>& inputsSize) const { const Aidge::IOIndex_t outputIdx,
(void)outputIdx; const std::vector<Aidge::DimSize_t> &inputsSize) const {
(void)inputsSize; (void)outputIdx;
return std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<1>()[0]; (void)inputsSize;
return std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))
->template dims<1>()[0];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbConsumedData(
return mNbConsumedData[0]; const Aidge::IOIndex_t /*inputIdx*/) const {
return mNbConsumedData[0];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<1>::getNbProducedData(
return mNbProducedData[0]; const Aidge::IOIndex_t /*outputIdx*/) const {
return mNbProducedData[0];
} }
void Aidge::SliceImpl_cpu<1>::updateConsummerProducer() { void Aidge::SliceImpl_cpu<1>::updateConsummerProducer() {
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<1>::forward() { void Aidge::SliceImpl_cpu<1>::forward() {
// FIXME: uncomment the following code once memory handling will work // FIXME: uncomment the following code once memory handling will work
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu<1>>::create( auto kernelFunc = Registrar<SliceImplForward_cpu<1>>::create(
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const Slice_Op<1>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<1>(), dynamic_cast<const Slice_Op<1> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<1>(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr() getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
);
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<1>::backward() { printf("Not implemented yet.\n"); } void Aidge::SliceImpl_cpu<1>::backward() { printf("Not implemented yet.\n"); }
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbRequiredData(
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input"); const Aidge::IOIndex_t /*inputIdx*/) const {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"requires valid input");
// Requires the whole tensors // Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<2>(); const auto &inputDims =
return inputDims[0]*inputDims[1]; std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<2>();
return inputDims[0] * inputDims[1];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; } Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbRequiredProtected(
const Aidge::IOIndex_t /*inputIdx*/) const {
return 0;
}
Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getRequiredMemory(const Aidge::IOIndex_t outputIdx, Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getRequiredMemory(
const std::vector<Aidge::DimSize_t>& inputsSize) const { const Aidge::IOIndex_t outputIdx,
(void)outputIdx; const std::vector<Aidge::DimSize_t> &inputsSize) const {
(void)inputsSize; (void)outputIdx;
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<2>(); (void)inputsSize;
return outputDims[0]*outputDims[1]; const auto &outputDims =
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<2>();
return outputDims[0] * outputDims[1];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbConsumedData(
return mNbConsumedData[0]; const Aidge::IOIndex_t /*inputIdx*/) const {
return mNbConsumedData[0];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<2>::getNbProducedData(
return mNbProducedData[0]; const Aidge::IOIndex_t /*outputIdx*/) const {
return mNbProducedData[0];
} }
void Aidge::SliceImpl_cpu<2>::updateConsummerProducer() { void Aidge::SliceImpl_cpu<2>::updateConsummerProducer() {
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<2>::forward() { void Aidge::SliceImpl_cpu<2>::forward() {
// FIXME: uncomment the following code once memory handling will work // FIXME: uncomment the following code once memory handling will work
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu<2>>::create( auto kernelFunc = Registrar<SliceImplForward_cpu<2>>::create(
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const Slice_Op<2>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<2>(), dynamic_cast<const Slice_Op<2> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<2>(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr() getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
);
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<2>::backward() { printf("Not implemented yet.\n"); } void Aidge::SliceImpl_cpu<2>::backward() { printf("Not implemented yet.\n"); }
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbRequiredData(
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input"); const Aidge::IOIndex_t /*inputIdx*/) const {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"requires valid input");
// Requires the whole tensors // Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>(); const auto &inputDims =
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>();
return std::accumulate(inputDims.begin(), inputDims.end(), static_cast<NbElts_t>(1), return std::accumulate(inputDims.begin(), inputDims.end(),
std::multiplies<NbElts_t>()); static_cast<NbElts_t>(1), std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; } Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbRequiredProtected(
const Aidge::IOIndex_t /*inputIdx*/) const {
return 0;
}
Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getRequiredMemory(const Aidge::IOIndex_t outputIdx, Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getRequiredMemory(
const std::vector<Aidge::DimSize_t>& inputsSize) const { const Aidge::IOIndex_t outputIdx,
(void)outputIdx; const std::vector<Aidge::DimSize_t> &inputsSize) const {
(void)inputsSize; (void)outputIdx;
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<3>(); (void)inputsSize;
return std::accumulate(outputDims.begin(), outputDims.end(), static_cast<NbElts_t>(1), const auto &outputDims =
std::multiplies<NbElts_t>()); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<3>();
return std::accumulate(outputDims.begin(), outputDims.end(),
static_cast<NbElts_t>(1), std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbConsumedData(
return mNbConsumedData[0]; const Aidge::IOIndex_t /*inputIdx*/) const {
return mNbConsumedData[0];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<3>::getNbProducedData(
return mNbProducedData[0]; const Aidge::IOIndex_t /*outputIdx*/) const {
return mNbProducedData[0];
} }
void Aidge::SliceImpl_cpu<3>::updateConsummerProducer() { void Aidge::SliceImpl_cpu<3>::updateConsummerProducer() {
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<3>::forward() { void Aidge::SliceImpl_cpu<3>::forward() {
// FIXME: uncomment the following code once memory handling will work // FIXME: uncomment the following code once memory handling will work
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu<3>>::create( auto kernelFunc = Registrar<SliceImplForward_cpu<3>>::create(
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const Slice_Op<3>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>(), dynamic_cast<const Slice_Op<3> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<3>(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr() getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
);
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<3>::backward() { printf("Not implemented yet.\n"); } void Aidge::SliceImpl_cpu<3>::backward() { printf("Not implemented yet.\n"); }
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbRequiredData(
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input"); const Aidge::IOIndex_t /*inputIdx*/) const {
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"requires valid input");
// Requires the whole tensors // Requires the whole tensors
const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(); const auto &inputDims =
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>();
return std::accumulate(inputDims.begin(), inputDims.end(), static_cast<NbElts_t>(1), return std::accumulate(inputDims.begin(), inputDims.end(),
std::multiplies<NbElts_t>()); static_cast<NbElts_t>(1), std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; } Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbRequiredProtected(
const Aidge::IOIndex_t /*inputIdx*/) const {
return 0;
}
Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getRequiredMemory(const Aidge::IOIndex_t outputIdx, Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getRequiredMemory(
const std::vector<Aidge::DimSize_t>& inputsSize) const { const Aidge::IOIndex_t outputIdx,
(void)outputIdx; const std::vector<Aidge::DimSize_t> &inputsSize) const {
(void)inputsSize; (void)outputIdx;
const auto& outputDims = std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<4>(); (void)inputsSize;
return std::accumulate(outputDims.begin(), outputDims.end(), static_cast<NbElts_t>(1), const auto &outputDims =
std::multiplies<NbElts_t>()); std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->template dims<4>();
return std::accumulate(outputDims.begin(), outputDims.end(),
static_cast<NbElts_t>(1), std::multiplies<NbElts_t>());
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbConsumedData(
return mNbConsumedData[0]; const Aidge::IOIndex_t /*inputIdx*/) const {
return mNbConsumedData[0];
} }
Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const { Aidge::NbElts_t Aidge::SliceImpl_cpu<4>::getNbProducedData(
return mNbProducedData[0]; const Aidge::IOIndex_t /*outputIdx*/) const {
return mNbProducedData[0];
} }
void Aidge::SliceImpl_cpu<4>::updateConsummerProducer() { void Aidge::SliceImpl_cpu<4>::updateConsummerProducer() {
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<4>::forward() { void Aidge::SliceImpl_cpu<4>::forward() {
// FIXME: uncomment the following code once memory handling will work // FIXME: uncomment the following code once memory handling will work
assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0"); assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) &&
"missing input #0");
// Find the correct kernel type // Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu<4>>::create( auto kernelFunc = Registrar<SliceImplForward_cpu<4>>::create(
{std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()}); {std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType()});
// Call kernel // Call kernel
kernelFunc(dynamic_cast<const Slice_Op<4>&>(mOp).getStaticAttributes(), kernelFunc(
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(), dynamic_cast<const Slice_Op<4> &>(mOp).getStaticAttributes(),
std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(), std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr() getCPUPtr(mOp.getRawInput(0)), getCPUPtr(mOp.getRawOutput(0)));
);
// each input is consumed by the minimum amount for a forward pass // each input is consumed by the minimum amount for a forward pass
mNbConsumedData[0] += getNbRequiredData(0); mNbConsumedData[0] += getNbRequiredData(0);
mNbProducedData[0] += getRequiredMemory(0, {}); mNbProducedData[0] += getRequiredMemory(0, {});
} }
void Aidge::SliceImpl_cpu<4>::backward() { printf("Not implemented yet.\n"); } void Aidge::SliceImpl_cpu<4>::backward() { printf("Not implemented yet.\n"); }
\ No newline at end of file
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