diff --git a/aidge_backend_cpu/unit_tests/test_recipies.py b/aidge_backend_cpu/unit_tests/test_recipies.py
index 60949adf245f4f4a7ed316879fb307131f70739a..841c15590e9dac7596958b8392c99948978723c5 100644
--- a/aidge_backend_cpu/unit_tests/test_recipies.py
+++ b/aidge_backend_cpu/unit_tests/test_recipies.py
@@ -49,24 +49,24 @@ class test_recipies(unittest.TestCase):
np_shift = np.array([0.05]).astype(np.float32)
np_mean = np.array([0.05]).astype(np.float32)
np_var = np.array([0.05]).astype(np.float32)
- conv.input(1)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_weights))
- conv.input(2)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_bias))
- bn.input(1)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_scale))
- bn.input(2)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_shift))
- bn.input(3)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_mean))
- bn.input(4)[0].get_operator().set_output_tensor(aidge_core.Tensor(np_var))
+ conv.input(1)[0].get_operator().set_output(0, aidge_core.Tensor(np_weights))
+ conv.input(2)[0].get_operator().set_output(0, aidge_core.Tensor(np_bias))
+ bn.input(1)[0].get_operator().set_output(0, aidge_core.Tensor(np_scale))
+ bn.input(2)[0].get_operator().set_output(0, aidge_core.Tensor(np_shift))
+ bn.input(3)[0].get_operator().set_output(0, aidge_core.Tensor(np_mean))
+ bn.input(4)[0].get_operator().set_output(0, aidge_core.Tensor(np_var))
scheduler0 = aidge_core.SequentialScheduler(graph_view)
scheduler0.forward()
for outNode in graph_view.get_output_nodes():
- output_aidge0 = outNode.get_operator().output(0)
+ output_aidge0 = outNode.get_operator().get_output(0)
aidge_core.fuse_batchnorm(graph_view)
scheduler1 = aidge_core.SequentialScheduler(graph_view)
scheduler1.forward()
for outNode in graph_view.get_output_nodes():
- output_aidge1 = outNode.get_operator().output(0)
+ output_aidge1 = outNode.get_operator().get_output(0)
self.assertTrue(aidge_core.approx_eq(output_aidge0, output_aidge1, 0.000001, 0.0001))
diff --git a/aidge_backend_cpu/unit_tests/test_scheduler.py b/aidge_backend_cpu/unit_tests/test_scheduler.py
index 3449ff513ef618e24788419c835b7277a1e751f1..2f174efed32fc814010ff61cd42c1bae1105674e 100644
--- a/aidge_backend_cpu/unit_tests/test_scheduler.py
+++ b/aidge_backend_cpu/unit_tests/test_scheduler.py
@@ -22,30 +22,30 @@ class test_scheduler(unittest.TestCase):
gv.add(relu)
gv.add(input_node)
+ input_node.add_child(relu)
+
gv.set_datatype(aidge_core.DataType.Int32)
gv.set_backend("cpu")
- input_node.add_child(relu)
-
scheduler = aidge_core.SequentialScheduler(gv)
scheduler.forward()
- out_tensor = relu.get_operator().output(0)
+ out_tensor = relu.get_operator().get_output(0)
expected_out = [0,0,0,0,1,2]
for i in range(len(expected_out)):
self.assertEqual(expected_out[i], out_tensor[i])
def test_sequential_scheduling(self):
- input_data = np.array([]).astype(np.float32)
+ input_data = np.array([0]).astype(np.float32)
input_tensor = aidge_core.Tensor(input_data)
input_node = aidge_core.Producer(input_tensor, "X")
graph_view = aidge_core.sequential([
- aidge_core.FC(50, name='0'),
- aidge_core.FC(50, name='1'),
- aidge_core.FC(10, name='2'),
+ aidge_core.FC(1, 50, name='0'),
+ aidge_core.FC(50, 50, name='1'),
+ aidge_core.FC(50, 10, name='2'),
])
EXPECTED_SCHEDULE = ['0', '1', '2']
@@ -64,14 +64,14 @@ class test_scheduler(unittest.TestCase):
def test_parallel_scheduling(self):
- input_data = np.array([]).astype(np.float32)
+ input_data = np.array([0]).astype(np.float32)
input_tensor = aidge_core.Tensor(input_data)
input_node = aidge_core.Producer(input_tensor, "X")
graph_view = aidge_core.sequential([
- aidge_core.FC(50, name='0'),
- aidge_core.parallel([aidge_core.FC(50, name='1'), aidge_core.FC(50, name='3')]),
- aidge_core.Add(name='2'),
+ aidge_core.FC(1, 50, name='0'),
+ aidge_core.parallel([aidge_core.FC(50, 50, name='1'), aidge_core.FC(50, 50, name='3')]),
+ aidge_core.Add(2, name='2'),
])
EXPECTED_SCHEDULE = [['0', '1', '3', '2'], ['0', '3', '1', '2']] # Both scheduling are valid !
diff --git a/include/aidge/backend/cpu/operator/AddImpl.hpp b/include/aidge/backend/cpu/operator/AddImpl.hpp
index 9dbd21501462c010384248544b81bb9f26346604..806bbb02d760dbdec58df137641d4c211443039e 100644
--- a/include/aidge/backend/cpu/operator/AddImpl.hpp
+++ b/include/aidge/backend/cpu/operator/AddImpl.hpp
@@ -23,87 +23,39 @@ namespace Aidge {
// class Add_Op<2>;
// compute kernel registry for forward and backward
-template <DimIdx_t NUM>
-class AddImplForward_cpu;
-template <DimIdx_t NUM>
-class AddImplBackward_cpu;
-
-template <>
-class AddImplForward_cpu<1>
- : public Registrable<AddImplForward_cpu<1>, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {};
-template <>
-class AddImplBackward_cpu<1>
- : public Registrable<AddImplBackward_cpu<1>, std::tuple<DataType, DataType>, void(const std::size_t, const void*, void*)> {};
-
-template <>
-class AddImplForward_cpu<2> : public Registrable<AddImplForward_cpu<2>, std::tuple<DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, void*)> {};
-template <>
-class AddImplBackward_cpu<2> : public Registrable<AddImplBackward_cpu<2>, std::tuple<DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, void*)> {};
-
-template <>
-class AddImplForward_cpu<3> : public Registrable<AddImplForward_cpu<3>, std::tuple<DataType, DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, const void*, void*)> {
-};
-template <>
-class AddImplBackward_cpu<3>
- : public Registrable<AddImplBackward_cpu<3>, std::tuple<DataType, DataType, DataType, DataType>,
- void(const std::size_t, const void*, const void*, const void*, void*)> {};
+class AddImplForward_cpu
+ : public Registrable<AddImplForward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const std::vector<const void*>, void*)> {};
+
+class AddImplBackward_cpu
+ : public Registrable<AddImplBackward_cpu, std::tuple<DataType, DataType>, void(const std::size_t, const std::vector<const void*>, void*)> {};
+
-template <DimIdx_t NUM>
class AddImpl_cpu : public OperatorImpl {
public:
- AddImpl_cpu(const Add_Op<NUM>& op) : OperatorImpl(op) {}
+ AddImpl_cpu(const Add_Op& op) : OperatorImpl(op) {}
- static std::unique_ptr<AddImpl_cpu<NUM>> create(const Add_Op<NUM>& op) {
- return std::make_unique<AddImpl_cpu<NUM>>(op);
+ static std::unique_ptr<AddImpl_cpu> create(const Add_Op& op) {
+ return std::make_unique<AddImpl_cpu>(op);
}
-};
-template <>
-class AddImpl_cpu<1> : public OperatorImpl {
public:
- AddImpl_cpu(const Add_Op<1>& op) : OperatorImpl(op) {}
-
- static std::unique_ptr<AddImpl_cpu<1>> create(const Add_Op<1>& op) {
- return std::make_unique<AddImpl_cpu<1>>(op);
- }
+ NbElts_t getNbRequiredData(const IOIndex_t inputIdx) const override final;
NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
- void forward() override;
-};
-template <>
-class AddImpl_cpu<2> : public OperatorImpl {
-public:
- AddImpl_cpu(const Add_Op<2>& op) : OperatorImpl(op) {}
-
- static std::unique_ptr<AddImpl_cpu<2>> create(const Add_Op<2>& op) {
- return std::make_unique<AddImpl_cpu<2>>(op);
- }
+ NbElts_t getRequiredMemory(const IOIndex_t outputIdx, const std::vector<DimSize_t>& /*inputsSize*/) const override final;
- NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
- void forward() override;
-};
+ NbElts_t getNbConsumedData(const IOIndex_t inputIdx) const override final;
-template <>
-class AddImpl_cpu<3> : public OperatorImpl {
-public:
- AddImpl_cpu(const Add_Op<3>& op) : OperatorImpl(op) {}
+ NbElts_t getNbProducedData(const IOIndex_t outputIdx) const override final;
- static std::unique_ptr<AddImpl_cpu<3>> create(const Add_Op<3>& op) {
- return std::make_unique<AddImpl_cpu<3>>(op);
- }
+ void updateConsummerProducer() override final;
- NbElts_t getNbRequiredProtected(const IOIndex_t /*inputIdx*/) const override final;
void forward() override;
};
namespace {
-static Registrar<Add_Op<1>> registrarAddImpl1I_cpu("cpu", Aidge::AddImpl_cpu<1>::create);
-static Registrar<Add_Op<2>> registrarAddImpl2I_cpu("cpu", Aidge::AddImpl_cpu<2>::create);
-static Registrar<Add_Op<3>> registrarAddImpl3I_cpu("cpu", Aidge::AddImpl_cpu<3>::create);
+static Registrar<Add_Op> registrarAddImpl_cpu("cpu", Aidge::AddImpl_cpu::create);
} // namespace
} // namespace Aidge
diff --git a/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp
index 221e36dcfac44e21d1b1a35674ca21403b4b57ab..198bcbacc395edf2709fa229828e2228554e6fd2 100644
--- a/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp
@@ -18,70 +18,30 @@
namespace Aidge {
-template <class I1, class O>
-void AddImpl1I_cpu_forward_kernel(const std::size_t inputLength, const void* input1_, void* output_) {
+template <class I, class O>
+void AddImpl_cpu_forward_kernel(const std::size_t inputLength, const std::vector<const void*> inputs_, void* output_) {
// FIXME: missing Add attributes as arguments
- const I1* input1 = static_cast<const I1*>(input1_);
- O* output = static_cast<O*>(output_);
-
- for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
- output[oIndex] = input1[oIndex];
- }
-}
-
-template <class I1, class I2, class O>
-void AddImpl2I_cpu_forward_kernel(const std::size_t inputLength, const void* input1_, const void* input2_,
- void* output_) {
- // FIXME: missing Add attributes as arguments
- const I1* input1 = static_cast<const I1*>(input1_);
- const I2* input2 = static_cast<const I2*>(input2_);
- O* output = static_cast<O*>(output_);
-
- for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
- output[oIndex] = input1[oIndex] + input2[oIndex];
+ std::vector<const I*> inputs;
+ for (const auto& input_ : inputs_) {
+ inputs.push_back(static_cast<const I*>(input_));
}
-}
-
-template <class I1, class I2, class I3, class O>
-void AddImpl3I_cpu_forward_kernel(const std::size_t inputLength, const void* input1_, const void* input2_,
- const void* input3_, void* output_) {
- // FIXME: missing Add attributes as arguments
- const I1* input1 = static_cast<const I1*>(input1_);
- const I2* input2 = static_cast<const I2*>(input2_);
- const I3* input3 = static_cast<const I3*>(input3_);
O* output = static_cast<O*>(output_);
- for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
- output[oIndex] = input1[oIndex] + input2[oIndex] + input3[oIndex];
- }
+ for (std::size_t iIndex = 0; iIndex < inputs.size(); ++iIndex) {
+ for (std::size_t oIndex = 0; oIndex < inputLength; ++oIndex) {
+ output[oIndex] += inputs[iIndex][oIndex];
+ }
+ }
}
namespace {
-static Registrar<AddImplForward_cpu<1>> registrarAddImpl1IForward_cpu_Float32(
- {DataType::Float32, DataType::Float32}, Aidge::AddImpl1I_cpu_forward_kernel<float, float>);
-static Registrar<AddImplForward_cpu<1>> registrarAddImpl1IForward_cpu_Int32(
- {DataType::Int32, DataType::Int32}, Aidge::AddImpl1I_cpu_forward_kernel<int, int>);
-static Registrar<AddImplForward_cpu<1>> registrarAddImpl1IForward_cpu_Float64(
- {DataType::Float64, DataType::Float64}, Aidge::AddImpl1I_cpu_forward_kernel<double, double>);
-
-static Registrar<AddImplForward_cpu<2>> registrarAddImpl2IForward_cpu_Float32(
- {DataType::Float32, DataType::Float32, DataType::Float32},
- Aidge::AddImpl2I_cpu_forward_kernel<float, float, float>);
-static Registrar<AddImplForward_cpu<2>> registrarAddImpl2IForward_cpu_Int32(
- {DataType::Int32, DataType::Int32, DataType::Int32}, Aidge::AddImpl2I_cpu_forward_kernel<int, int, int>);
-static Registrar<AddImplForward_cpu<2>> registrarAddImpl2IForward_cpu_Float64(
- {DataType::Float64, DataType::Float64, DataType::Float64}, Aidge::AddImpl2I_cpu_forward_kernel<double, double, double>);
-
-static Registrar<AddImplForward_cpu<3>> registrarAddImpl3IForward_cpu_Float32(
- {DataType::Float32, DataType::Float32, DataType::Float32, DataType::Float32},
- Aidge::AddImpl3I_cpu_forward_kernel<float, float, float, float>);
-static Registrar<AddImplForward_cpu<3>> registrarAddImpl3IForward_cpu_Int32(
- {DataType::Int32, DataType::Int32, DataType::Int32, DataType::Int32},
- Aidge::AddImpl3I_cpu_forward_kernel<int, int, int, int>);
-static Registrar<AddImplForward_cpu<3>> registrarAddImpl3IForward_cpu_Float64(
- {DataType::Float64, DataType::Float64, DataType::Float64, DataType::Float64},
- Aidge::AddImpl3I_cpu_forward_kernel<double, double, double, double>);
+static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Float32(
+ {DataType::Float32, DataType::Float32}, Aidge::AddImpl_cpu_forward_kernel<float, float>);
+static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Int32(
+ {DataType::Int32, DataType::Int32}, Aidge::AddImpl_cpu_forward_kernel<int, int>);
+static Registrar<AddImplForward_cpu> registrarAddImplForward_cpu_Float64(
+ {DataType::Float64, DataType::Float64}, Aidge::AddImpl_cpu_forward_kernel<double, double>);
} // namespace
} // namespace Aidge
-#endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_FORWARD_KERNEL_H_ */
+#endif /* AIDGE_CPU_OPERATOR_ADDIMPL_CPU_FORWARD_KERNEL_H_ */
\ No newline at end of file
diff --git a/include/aidge/backend/cpu/operator/ConcatImpl.hpp b/include/aidge/backend/cpu/operator/ConcatImpl.hpp
index 6db0045792a9db7742a97e4a0ed7f43ebfa2cc09..43ec45f11bb6e1b98ff851113c9230acacf942b6 100644
--- a/include/aidge/backend/cpu/operator/ConcatImpl.hpp
+++ b/include/aidge/backend/cpu/operator/ConcatImpl.hpp
@@ -21,14 +21,21 @@
namespace Aidge {
// class Concat_Op;
-
// compute kernel registry for forward and backward
class ConcatImplForward_cpu
- : public Registrable<ConcatImplForward_cpu, std::tuple<DataType, DataType>, void(std::size_t, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const std::vector<void*>, void*)> {
-};
+ : public Registrable<ConcatImplForward_cpu, std::tuple<DataType, DataType>, void(const Concat_Op::Attrs&,
+ const std::vector<DimSize_t>,
+ const std::vector<DimSize_t>&,
+ const std::vector<const void*>,
+ void*)> {};
+
class ConcatImplBackward_cpu
- : public Registrable<ConcatImplBackward_cpu, std::tuple<DataType, DataType>, void(std::size_t, const std::vector<DimSize_t>&, const std::vector<DimSize_t>&, const std::vector<void*>, void*)> {
-};
+ : public Registrable<ConcatImplBackward_cpu, std::tuple<DataType, DataType>, void(const Concat_Op::Attrs&,
+ const std::vector<DimSize_t>,
+ const std::vector<DimSize_t>&,
+ const std::vector<const void*>,
+ void*)> {};
+
class ConcatImpl_cpu : public OperatorImpl {
public:
@@ -38,13 +45,27 @@ public:
return std::make_unique<ConcatImpl_cpu>(op);
}
- NbElts_t getNbRequiredProtected(const IOIndex_t inputIdx) const override final;
+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 {
static Registrar<Concat_Op> registrarConcatImpl_cpu("cpu", Aidge::ConcatImpl_cpu::create);
-}
+} // namespace
} // namespace Aidge
#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_H_ */
diff --git a/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp
index 99825e10f6c3789687e64a3e45f08afb0cf43d4e..7651e055ce03816c04adabf5532d81554f5ac2b0 100644
--- a/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp
@@ -22,13 +22,18 @@
namespace Aidge {
template <class I, class O>
-void ConcatImpl_cpu_forward_kernel(std::size_t axisIdx, const std::vector<DimSize_t>& inputDims, const std::vector<DimSize_t>& dimsOnAxis, const std::vector<void*> input_, void* output_)
+void ConcatImpl_cpu_forward_kernel(const Concat_Op::Attrs& attrs,
+ const std::vector<DimSize_t>& inputDims,
+ const std::vector<DimSize_t>& concatAxisValues,
+ const std::vector<const void*>& inputs_,
+ void* output_)
{
+ std::size_t axisIdx = std::get<0>(attrs);
O* output = static_cast<O*>(output_);
- std::vector<I*> input;
- for(const auto& elem:input_)
+ std::vector<const I*> input;
+ for(const auto& elem:inputs_)
{
- input.emplace_back(static_cast<I*>(elem));
+ input.emplace_back(static_cast<const I*>(elem));
}
std::size_t postAxisElems = 1;
@@ -44,7 +49,7 @@ void ConcatImpl_cpu_forward_kernel(std::size_t axisIdx, const std::vector<DimSiz
{
for(std::size_t j=0; j < input.size(); ++j)
{
- std::size_t strideOnAxis = postAxisElems * dimsOnAxis[j];
+ std::size_t strideOnAxis = postAxisElems * concatAxisValues[j];
const I* copyPtr = std::next(input[j], i * strideOnAxis);
std::copy_n(copyPtr, strideOnAxis, output);
output += strideOnAxis;
@@ -58,8 +63,9 @@ static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Float32(
static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Int32(
{DataType::Int32, DataType::Int32}, Aidge::ConcatImpl_cpu_forward_kernel<int, int>);
static Registrar<ConcatImplForward_cpu> registrarConcatImplForward_cpu_Float64(
- {DataType::Float64, DataType::Float64}, Aidge::ConcatImpl_cpu_forward_kernel<double, double>);
+ {DataType::Float64, DataType::Float64},
+ Aidge::ConcatImpl_cpu_forward_kernel<double, double>);
} // namespace
} // namespace Aidge
-#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_FORWARD_KERNEL_H_ */
+#endif /* AIDGE_CPU_OPERATOR_CONCATIMPL_CPU_FORWARD_KERNEL_H_ */
diff --git a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
index 5aa29ac55740d46bba873bb9d85a04cd004cc3bd..f40dfee00ee940e6bc73a2fc337bbee61607d17f 100644
--- a/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ConvDepthWiseImpl_forward_kernels.hpp
@@ -17,6 +17,7 @@
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
#include "aidge/utils/Types.h"
#include <cmath>
+#include <cstddef>
#include <array>
#include <algorithm>
diff --git a/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
index 7d31dd5a8545f6276f9fd40a5deb52d02e6dc35f..5258c4c3e7376c3883b119503ee9e6765de844d5 100644
--- a/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/ScalingImpl_forward_kernels.hpp
@@ -9,8 +9,10 @@
*
********************************************************************************/
-#ifndef __AIDGE_CPU_OPERATOR_ScalingIMPL_FORWARD_KERNEL_H__
-#define __AIDGE_CPU_OPERATOR_ScalingIMPL_FORWARD_KERNEL_H__
+#ifndef AIDGE_CPU_OPERATOR_SCALINGIMPL_FORWARD_KERNEL_H
+#define AIDGE_CPU_OPERATOR_SCALINGIMPL_FORWARD_KERNEL_H
+
+#include <cmath>
#include "aidge/utils/Registrar.hpp"
@@ -61,7 +63,7 @@ const O& clamp(const O& x, const O& min, const O& max)
template<class O>
O saturate(O value, std::size_t quantizedNbBits, bool isOutputUnsigned) {
assert(quantizedNbBits > 0);
-
+
const O min = isOutputUnsigned?0:
-(1ll << (quantizedNbBits - 1ll));
const O max = isOutputUnsigned?(1ll << quantizedNbBits) - 1ll:
@@ -101,4 +103,4 @@ static Registrar<ScalingImplForward_cpu> registrarScalingImplForward_cpu_Float64
} // namespace
} // namespace Aidge
-#endif /* __AIDGE_CPU_OPERATOR_ScalingIMPL_FORWARD_KERNEL_H__ */
+#endif /* AIDGE_CPU_OPERATOR_SCALINGIMPL_FORWARD_KERNEL_H */
diff --git a/include/aidge/backend/cpu/operator/SliceImpl.hpp b/include/aidge/backend/cpu/operator/SliceImpl.hpp
index 234847c1c5e6a80fb29c22e2cd28f81504428f85..d6f7caad4febf72764892f956886c8fb6875d0ab 100644
--- a/include/aidge/backend/cpu/operator/SliceImpl.hpp
+++ b/include/aidge/backend/cpu/operator/SliceImpl.hpp
@@ -12,12 +12,14 @@
#ifndef AIDGE_CPU_OPERATOR_SLICEIMPL_H_
#define AIDGE_CPU_OPERATOR_SLICEIMPL_H_
+#include <memory>
+#include <vector>
+
#include "aidge/backend/OperatorImpl.hpp"
#include "aidge/operator/Slice.hpp"
+
#include "aidge/utils/Registrar.hpp"
#include "aidge/utils/Types.h"
-#include <memory>
-#include <vector>
namespace Aidge {
// class Slice_Op;
@@ -42,8 +44,16 @@ public:
return std::make_unique<SliceImpl_cpu>(op);
}
- NbElts_t getNbRequiredProtected(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 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 {
@@ -51,4 +61,4 @@ static Registrar<Slice_Op> registrarSliceImpl_cpu("cpu", Aidge::SliceImpl_cpu::c
}
} // namespace Aidge
-#endif /* AIDGE_CPU_OPERATOR_SLICEIMPL_H_ */
+#endif /* AIDGE_CPU_OPERATOR_SLICEIMPL_H_ */
\ No newline at end of file
diff --git a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
index e8f560c26a62e1bac22655dec0db7f90a65ed5f3..9381039bb4d8fcdc5aa34c9d34d96ec50a73d651 100644
--- a/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
+++ b/include/aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp
@@ -103,4 +103,4 @@ static Registrar<SliceImplForward_cpu> registrarSliceImplForward_cpu_Float64(
} // namespace
} // namespace Aidge
-#endif /* AIDGE_CPU_OPERATOR_SLICEIMPL_FORWARD_KERNEL_H_ */
+#endif /* AIDGE_CPU_OPERATOR_SLICEIMPL_FORWARD_KERNEL_H_ */
\ No newline at end of file
diff --git a/src/operator/AddImpl.cpp b/src/operator/AddImpl.cpp
index 4be0078199671bc09af73a5f9dbfcd0ff2e61bed..851aaa5c6bcd1acc3e8bc17b11dd00143c543b5b 100644
--- a/src/operator/AddImpl.cpp
+++ b/src/operator/AddImpl.cpp
@@ -10,93 +10,74 @@
********************************************************************************/
#include <cassert>
-#include <chrono> // std::chrono::milliseconds
#include <numeric> // std::accumulate
-#include <thread> // std::this_thread::sleep_for
#include <vector>
-#include "aidge/operator/Conv.hpp"
#include "aidge/utils/Types.h"
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
#include "aidge/backend/cpu/operator/AddImpl.hpp"
#include "aidge/backend/cpu/operator/AddImpl_forward_kernels.hpp"
-//////////////////////////////////
-// AddImpl_cpu<1>
-//////////////////////////////////
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
+ assert(mOp.getRawInput(inputIdx) && "requires valid input");
-Aidge::NbElts_t Aidge::AddImpl_cpu<1>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation can be in-place
- return 0;
+ // Requires the whole tensors
+ const auto& inputDims = std::static_pointer_cast<Tensor>(mOp.getRawInput(inputIdx))->dims();
+ return std::accumulate(inputDims.begin(), inputDims.end(), NbElts_t(1), std::multiplies<NbElts_t>());
}
-void Aidge::AddImpl_cpu<1>::forward() {
- assert(mOp.getInput(0) && "missing input #0");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<AddImplForward_cpu<1>>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- // Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+Aidge::NbElts_t Aidge::AddImpl_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::AddImpl_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;
-//////////////////////////////////
-// AddImpl_cpu<2>
-//////////////////////////////////
+ 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<2>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation of add can be in-place
- return 0;
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t inputIdx) const {
+ assert(inputIdx < mNbConsumedData.size());
+ return mNbConsumedData[inputIdx];
}
-void Aidge::AddImpl_cpu<2>::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<AddImplForward_cpu<2>>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- // Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+Aidge::NbElts_t Aidge::AddImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const {
+ assert(outputIdx < mNbProducedData.size());
+ return mNbProducedData[outputIdx];
}
+void Aidge::AddImpl_cpu::updateConsummerProducer() {
+ 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
-//////////////////////////////////
-// AddImpl_cpu<3>
-//////////////////////////////////
+ mNbProducedData[0]+= getRequiredMemory(0, {});
-Aidge::NbElts_t Aidge::AddImpl_cpu<3>::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation of add can be in-place
- return 0;
}
-void Aidge::AddImpl_cpu<3>::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
-
- // Find the correct kernel type
- auto kernelFunc = Registrar<AddImplForward_cpu<3>>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- // Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
-}
+void Aidge::AddImpl_cpu::forward() {
+ assert(mOp.getRawInput(0) && "missing input in Add operator");
+ DataType datatypeFirstInput = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType();
+ for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) {
+ 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()});
+
+ std::vector<const void*> opInputs;
+ for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
+ opInputs.push_back(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->getImpl()->rawPtr());
+ }
+
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ opInputs,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
+}
\ No newline at end of file
diff --git a/src/operator/AvgPoolingImpl.cpp b/src/operator/AvgPoolingImpl.cpp
index ae93934c23ce9bbc97d071be2f258e04ec8ae877..ad236f004ec9d806d43b9549adcec1c094573a1d 100644
--- a/src/operator/AvgPoolingImpl.cpp
+++ b/src/operator/AvgPoolingImpl.cpp
@@ -26,15 +26,15 @@ Aidge::NbElts_t Aidge::AvgPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*
}
void Aidge::AvgPoolingImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(mOp.getRawInput(0) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
- Registrar<AvgPoolingImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<AvgPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const AvgPooling_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/BatchNormImpl.cpp b/src/operator/BatchNormImpl.cpp
index c9d52b767b03008d19209e34fa9a6f2749a63450..4cfd4b1bef0a027dfd28c95235dd864101ced3c6 100644
--- a/src/operator/BatchNormImpl.cpp
+++ b/src/operator/BatchNormImpl.cpp
@@ -25,26 +25,27 @@ Aidge::NbElts_t Aidge::BatchNormImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*i
}
void Aidge::BatchNormImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
- assert(mOp.getInput(3) && "missing input #3");
- assert(mOp.getInput(4) && "missing input #4");
+ assert(mOp.getRawInput(0) && "missing input #0");
+ assert(mOp.getRawInput(1) && "missing input #1");
+ assert(mOp.getRawInput(2) && "missing input #2");
+ assert(mOp.getRawInput(3) && "missing input #3");
+ assert(mOp.getRawInput(4) && "missing input #4");
- assert(mOp.getOutput(0)->nbDims() == 4);
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->nbDims() == 4);
// Find the correct kernel type
auto kernelFunc =
- Registrar<BatchNormImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
- mOp.getOutput(0)->dataType()});
+ Registrar<BatchNormImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const BatchNorm_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getInput(3)->getImpl()->rawPtr(),
- mOp.getInput(4)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ 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.getRawInput(3))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(4))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr(),
true);
}
diff --git a/src/operator/ConcatImpl.cpp b/src/operator/ConcatImpl.cpp
index d7e5167c6b509bea0a5d20e5ffb7e72a1188fa16..16adfefc22d819659d652bfdba40113172fb86b1 100644
--- a/src/operator/ConcatImpl.cpp
+++ b/src/operator/ConcatImpl.cpp
@@ -10,44 +10,82 @@
********************************************************************************/
#include <cassert>
-#include <chrono> // std::chrono::milliseconds
#include <numeric> // std::accumulate
-#include <thread> // std::this_thread::sleep_for
#include <vector>
#include "aidge/operator/Concat.hpp"
+
#include "aidge/utils/Types.h"
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
#include "aidge/backend/cpu/operator/ConcatImpl.hpp"
#include "aidge/backend/cpu/operator/ConcatImpl_forward_kernels.hpp"
-Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation can be in-place
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t inputIdx) const {
+ assert(mOp.getRawInput(inputIdx) && "requires valid input");
+
+ // Requires the whole tensors
+ const auto& inputDims = 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 {
+ // for the direct convolution algorithm, convolutions can be in-place, if there is no padding!
return 0;
}
-void Aidge::ConcatImpl_cpu::forward() {
- for (std::size_t i = 0; i < dynamic_cast<const Concat_Op&>(mOp).mNbIn; ++i) {
- assert(mOp.getInput(i) && ("missing input #"+std::to_string(i)).c_str());
+Aidge::NbElts_t Aidge::ConcatImpl_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.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 {
+ assert(inputIdx < mNbConsumedData.size());
+ return mNbConsumedData[inputIdx];
+}
+
+Aidge::NbElts_t Aidge::ConcatImpl_cpu::getNbProducedData(const Aidge::IOIndex_t outputIdx) const {
+ assert(outputIdx < mNbProducedData.size());
+ return mNbProducedData[outputIdx];
+}
+
+void Aidge::ConcatImpl_cpu::updateConsummerProducer() {
+ 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::ConcatImpl_cpu::forward() {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input in Concat operator");
+ DataType datatypeFirstInput = std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType();
+ for (IOIndex_t i = 1; i < mOp.nbInputs(); ++i) {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i)) && "missing input in Concat operator");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i))->dataType() == datatypeFirstInput);
}
- Concat_Op::Attrs attr = dynamic_cast<const Concat_Op&>(mOp).getStaticAttributes();
- std::size_t axisIdx = static_cast<const int&>(std::get<0>(attr));
- assert(mOp.getInput(0)->nbDims() > axisIdx && ("input dim must be bigger than "+std::to_string(axisIdx)).c_str());
auto kernelFunc = Registrar<ConcatImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
-
- std::vector<void*> inputTensors;
- std::vector<std::size_t> dimsOnAxis;
- for (std::size_t i = 0; i < dynamic_cast<const Concat_Op&>(mOp).mNbIn; ++i) {
- inputTensors.push_back(mOp.getInput(i)->getImpl()->rawPtr());
- dimsOnAxis.push_back(mOp.getInput(i)->dims()[axisIdx]);
+ datatypeFirstInput,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
+
+ std::vector<const void*> opInputs;
+ std::vector<DimSize_t> opInputAxis;
+ for (IOIndex_t i = 0; i < mOp.nbInputs(); ++i) {
+ 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")]);
}
- // Call kernel
- kernelFunc(axisIdx,
- mOp.getInput(0)->dims(),
- dimsOnAxis,
- inputTensors,
- mOp.getOutput(0)->getImpl()->rawPtr());
+
+ kernelFunc(dynamic_cast<const Concat_Op&>(mOp).getStaticAttributes(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ opInputAxis,
+ opInputs,
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
+
+void Aidge::ConcatImpl_cpu::backward() { printf("Not implemented yet.\n"); }
diff --git a/src/operator/ConvDepthWiseImpl.cpp b/src/operator/ConvDepthWiseImpl.cpp
index 5ac109e2f282ce55c8a274597be08561c2baf5c8..4a722a5e4b00412617eb998f8cbfb36eb0c46035 100644
--- a/src/operator/ConvDepthWiseImpl.cpp
+++ b/src/operator/ConvDepthWiseImpl.cpp
@@ -27,19 +27,23 @@ Aidge::NbElts_t Aidge::ConvDepthWiseImpl2D_cpu::getNbRequiredProtected(IOIndex_t
}
void Aidge::ConvDepthWiseImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
+ assert(mOp.getRawInput(0) && "missing input #0");
+ assert(mOp.getRawInput(1) && "missing input #1");
+ assert(mOp.getRawInput(2) && "missing input #2");
- assert((mOp.getInput(0)->nbDims() == 4) && "support for 4-dimensions tensors only");
+ assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims() == 4) && "support for 4-dimensions tensors only");
// Find the correct kernel type
auto kernelFunc =
- Registrar<ConvDepthWiseImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<ConvDepthWiseImpl2DForward_cpu>::create({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(2))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- 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(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
+ 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(),
+ 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());
}
diff --git a/src/operator/ConvImpl.cpp b/src/operator/ConvImpl.cpp
index 347d427908502b9976c2943417775bcbf0d3b344..87b54afbfd0b4c2d3bb57812d07575bc0e255626 100644
--- a/src/operator/ConvImpl.cpp
+++ b/src/operator/ConvImpl.cpp
@@ -28,17 +28,19 @@ Aidge::NbElts_t Aidge::ConvImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*inputI
void Aidge::ConvImpl2D_cpu::forward() {
// FIXME: uncomment the following code once memory handling will work
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
+ assert(mOp.getRawInput(0) && "missing input #0");
+ assert(mOp.getRawInput(1) && "missing input #1");
+ assert(mOp.getRawInput(2) && "missing input #2");
// Find the correct kernel type
auto kernelFunc =
- Registrar<ConvImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<ConvImpl2DForward_cpu>::create({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(2))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- 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(2)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(dynamic_cast<const Conv_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(), 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());
}
diff --git a/src/operator/DivImpl.cpp b/src/operator/DivImpl.cpp
index f7cbc7d20b9126ab318a6989ebf627491cb247aa..2e913df1a4c42a2c6132a4096a92c1ab0eeab0c0 100644
--- a/src/operator/DivImpl.cpp
+++ b/src/operator/DivImpl.cpp
@@ -27,25 +27,16 @@ Aidge::NbElts_t Aidge::DivImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::DivImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
-
// Find the correct kernel type
auto kernelFunc = Registrar<DivImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(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.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)))->size(),
+ std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ErfImpl.cpp b/src/operator/ErfImpl.cpp
index dc50233e4ed4824da7760ae62d82d2814ce756b2..06ec65008aee41215192cd05e126ac4f82388c1b 100644
--- a/src/operator/ErfImpl.cpp
+++ b/src/operator/ErfImpl.cpp
@@ -27,15 +27,14 @@ Aidge::NbElts_t Aidge::ErfImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::ErfImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<ErfImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/FCImpl.cpp b/src/operator/FCImpl.cpp
index 77ce50281cf4db94a492fce88a6d73eabde1bae5..1e5450d330ee89bdceb30aca846800d7764ca911 100644
--- a/src/operator/FCImpl.cpp
+++ b/src/operator/FCImpl.cpp
@@ -23,23 +23,23 @@
void Aidge::FCImpl_cpu::forward()
{
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(2) && "missing input #2");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(2)) && "missing input #2");
// Find the correct kernel type
auto kernelFunc = Registrar<FCImplForward_cpu>::create(
- {mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getInput(2)->dataType(),
- mOp.getOutput(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(2))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- // if (mOp.getInput(0)->nbDims() == 4) {
+ // if (std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->nbDims() == 4) {
// kernelFunc(
// mOp.getStaticAttributes(),
- // std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- // mOp.getInput(0)->getImpl()->rawPtr(),
+ // std::static_pointer_cast<Tensor>(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ // std::static_pointer_cast<Tensor>(mOp.getRawInput(0)->getImpl()->rawPtr(),
// mOp.mInputs[1]->getImpl()->rawPtr(),
// mOp.mInputs[2]->getImpl()->rawPtr(),
// mOp.getOutput(0)->getImpl()->rawPtr());
@@ -47,10 +47,10 @@ void Aidge::FCImpl_cpu::forward()
// else
kernelFunc(
dynamic_cast<const FC_Op&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims()[0],
- mOp.getInput(0)->sizeM1(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ 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))->getImpl()->rawPtr(),
+ 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());
}
diff --git a/src/operator/GatherImpl.cpp b/src/operator/GatherImpl.cpp
index fb0c8713d0683c5cc4770540fc548d82dc824d00..fd5e755be6ba898d916243c7f8a67bc2c6baca1e 100644
--- a/src/operator/GatherImpl.cpp
+++ b/src/operator/GatherImpl.cpp
@@ -27,23 +27,19 @@ Aidge::NbElts_t Aidge::GatherImpl_cpu::getNbRequiredProtected(const Aidge::IOInd
}
void Aidge::GatherImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert((mOp.getInput(0)->nbDims() == 2 && mOp.getInput(1)->nbDims() == 2 )&& "only 2D tensors are supported");
-
Gather_Op::Attrs attr = dynamic_cast<const Gather_Op&>(mOp).getStaticAttributes();
const int& axisIdx = static_cast<const int&>(std::get<0>(attr));
- assert(mOp.getInput(0)->nbDims() > 1);// > axisIdx && "input dim must be bigger than "+std::to_strint(axisIdx)
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->nbDims() > 1);// > axisIdx && "input dim must be bigger than "+std::to_strint(axisIdx)
auto kernelFunc = Registrar<GatherImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(axisIdx,
- mOp.getInput(0)->dims(),
- mOp.getInput(1)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/LeakyReLUImpl.cpp b/src/operator/LeakyReLUImpl.cpp
index c81acf60f0171bd819bfd760565e59d361401e29..9ea0f2400d954bf5fd25428a7bf46fbd188b4994 100644
--- a/src/operator/LeakyReLUImpl.cpp
+++ b/src/operator/LeakyReLUImpl.cpp
@@ -27,16 +27,16 @@ Aidge::NbElts_t Aidge::LeakyReLUImpl_cpu::getNbRequiredProtected(const Aidge::IO
}
void Aidge::LeakyReLUImpl_cpu::forward() {
- assert(mOp.getInput(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({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(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(),
- std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/MatMulImpl.cpp b/src/operator/MatMulImpl.cpp
index f4812629c4bcf7b699d3eca66ff4e884df0c04d6..0ad9bd6ceb4ac27c35e72e21477864980bcecfd9 100644
--- a/src/operator/MatMulImpl.cpp
+++ b/src/operator/MatMulImpl.cpp
@@ -23,33 +23,33 @@
void Aidge::MatMulImpl_cpu::forward()
{
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(1)) && "missing input #1");
// Find the correct kernel type
auto kernelFunc = Registrar<MatMulImplForward_cpu>::create(
- {mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(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.getRawOutput(0))->dataType()});
// Call kernel
// if (mOp.getInput(0)->nbDims() == 4) {
// kernelFunc(
// mOp.getStaticAttributes(),
- // std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- // mOp.getInput(0)->getImpl()->rawPtr(),
+ // std::static_pointer_cast<Tensor>(mOp.getInput(0))->template dims<4>(),
+ // mOp.getInput(0))->getImpl()->rawPtr(),
// mOp.mInputs[1]->getImpl()->rawPtr(),
// mOp.mInputs[2]->getImpl()->rawPtr(),
- // mOp.getOutput(0)->getImpl()->rawPtr());
+ // std::static_pointer_cast<Tensor>(mOp.getRawOutput(0)->getImpl()->rawPtr());
// }
// else
kernelFunc(
dynamic_cast<const MatMul_Op&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims()[0],
- mOp.getInput(0)->sizeM1(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ 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))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/MaxPoolingImpl.cpp b/src/operator/MaxPoolingImpl.cpp
index c5127c1e4577b3da44716cdc34358a8906b9cbb0..00a279707424e0fce4eb0af07cdade80fe2dffd9 100644
--- a/src/operator/MaxPoolingImpl.cpp
+++ b/src/operator/MaxPoolingImpl.cpp
@@ -26,15 +26,15 @@ Aidge::NbElts_t Aidge::MaxPoolingImpl2D_cpu::getNbRequiredProtected(IOIndex_t /*
}
void Aidge::MaxPoolingImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
- Registrar<MaxPoolingImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<MaxPoolingImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const MaxPooling_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->template dims<4>(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/MulImpl.cpp b/src/operator/MulImpl.cpp
index b6eb245cf0b1afc8893dfbab13d3294b945b3e0e..dfd33445a527459245137f4ca6e6d5e8f416d82c 100644
--- a/src/operator/MulImpl.cpp
+++ b/src/operator/MulImpl.cpp
@@ -27,25 +27,16 @@ Aidge::NbElts_t Aidge::MulImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::MulImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
-
// Find the correct kernel type
auto kernelFunc = Registrar<MulImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(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.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ 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(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/PadImpl.cpp b/src/operator/PadImpl.cpp
index 7c2af9e2161ddc4567b702690b8f268fe1af1b6c..a5bf1c52ba39a2f805f2b28562cbab19191ac754 100644
--- a/src/operator/PadImpl.cpp
+++ b/src/operator/PadImpl.cpp
@@ -27,19 +27,21 @@ Aidge::NbElts_t Aidge::PadImpl2D_cpu::getNbRequiredProtected(IOIndex_t inputIdx)
// Padding cannot be in-place!
// We must ensure that we do not override data that has not been consummed yet.
- const auto inputSize = std::static_pointer_cast<Tensor>(mOp.getInput(0))->size();
- const auto outputSize = std::static_pointer_cast<Tensor>(mOp.getOutput(0))->size();
+ 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() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
- Registrar<PadImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<PadImpl2DForward_cpu>::create({std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(), std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(dynamic_cast<const Pad_Op<2>&>(mOp).getStaticAttributes(), std::static_pointer_cast<Tensor>(mOp.getInput(0))->dims<4>(),
- mOp.getInput(0)->getImpl()->rawPtr(), mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(dynamic_cast<const Pad_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(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/PowImpl.cpp b/src/operator/PowImpl.cpp
index 52a4f46956e0d0f348583a23772c519a64ca857d..30fafa9b3d060eada9468fc9a2bf94ec6aeab3c0 100644
--- a/src/operator/PowImpl.cpp
+++ b/src/operator/PowImpl.cpp
@@ -27,25 +27,16 @@ Aidge::NbElts_t Aidge::PowImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::PowImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
-
// Find the correct kernel type
auto kernelFunc = Registrar<PowImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(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.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ 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(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ProducerImpl.cpp b/src/operator/ProducerImpl.cpp
index 404d95ef685fea3c5796e396a2c5e17c60ce53bc..827f969e4d636862919e07b2f9457bed3e19e0f3 100644
--- a/src/operator/ProducerImpl.cpp
+++ b/src/operator/ProducerImpl.cpp
@@ -26,7 +26,7 @@ Aidge::DimSize_t Aidge::ProducerImpl_cpu::getNbProducedData(
assert(outputIdx == 0 && "operator has only one output");
(void) outputIdx;
- return std::static_pointer_cast<Tensor>(mOp.getOutput(0))->size();
+ return std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->size();
}
void Aidge::ProducerImpl_cpu::forward()
diff --git a/src/operator/ReLUImpl.cpp b/src/operator/ReLUImpl.cpp
index 647898d3f0495a74fe7c1dd48dba446bd92cb7b5..2819bb864cb552adfcd1c52e57b734fa0a9d0ce1 100644
--- a/src/operator/ReLUImpl.cpp
+++ b/src/operator/ReLUImpl.cpp
@@ -27,15 +27,15 @@ Aidge::NbElts_t Aidge::ReLUImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex
}
void Aidge::ReLUImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<ReLUImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ReduceMeanImpl.cpp b/src/operator/ReduceMeanImpl.cpp
index 1f8a0d34d713dc2893e32ea2e1298e89022527f0..e31a53d84947e5b2ced14ee9ee6e2badaef07071 100644
--- a/src/operator/ReduceMeanImpl.cpp
+++ b/src/operator/ReduceMeanImpl.cpp
@@ -34,52 +34,46 @@ Aidge::NbElts_t Aidge::ReduceMeanImpl3D_cpu::getNbRequiredProtected(IOIndex_t /*
}
void Aidge::ReduceMeanImpl1D_cpu::forward() {
- // FIXME: uncomment the following code once memory handling will work
- assert(mOp.getInput(0) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
Registrar<ReduceMeanImpl1DForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(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 ReduceMean_Op<1>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
void Aidge::ReduceMeanImpl2D_cpu::forward() {
- // FIXME: uncomment the following code once memory handling will work
- assert(mOp.getInput(0) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
Registrar<ReduceMeanImpl2DForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(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 ReduceMean_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
void Aidge::ReduceMeanImpl3D_cpu::forward() {
- // FIXME: uncomment the following code once memory handling will work
- assert(mOp.getInput(0) && "missing input #0");
// Find the correct kernel type
auto kernelFunc =
Registrar<ReduceMeanImpl3DForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(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 ReduceMean_Op<3>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
\ No newline at end of file
diff --git a/src/operator/ReshapeImpl.cpp b/src/operator/ReshapeImpl.cpp
index 59c17d8e9f01851da578ee89918d8a3396af28e4..0e1d92cf3fc535826c063088b3ea1f6a6b5fbab6 100644
--- a/src/operator/ReshapeImpl.cpp
+++ b/src/operator/ReshapeImpl.cpp
@@ -27,28 +27,25 @@ Aidge::NbElts_t Aidge::ReshapeImpl_cpu::getNbRequiredProtected(const Aidge::IOIn
}
void Aidge::ReshapeImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
- assert(mOp.getInput(1)->nbDims() == 1 && "input #1 must be a 1D array");
std::size_t outputSize = 1;
- int* shape = static_cast<int*>(mOp.getInput(1)->getImpl()->rawPtr());
- for(std::size_t i= 0; i<mOp.getInput(1)->size(); ++i)
+ int* shape = static_cast<int*>(std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr());
+ for(std::size_t i= 0; i<std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->size(); ++i)
{
assert(shape[i]>0 && "all input #1 elements must be >0");
outputSize *= shape[i];
}
- assert((mOp.getInput(0)->size() == outputSize) &&
+ assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size() == outputSize) &&
"the shape given in input #1 must give the same size of input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<ReshapeImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/ScalingImpl.cpp b/src/operator/ScalingImpl.cpp
index 39c1326dd677a704795f625440e385d3f3a6465c..c2d2b17245811ab20de310e4656bc67b1a28b257 100644
--- a/src/operator/ScalingImpl.cpp
+++ b/src/operator/ScalingImpl.cpp
@@ -26,16 +26,16 @@ Aidge::NbElts_t Aidge::ScalingImpl_cpu::getNbRequiredProtected(const Aidge::IOIn
}
void Aidge::ScalingImpl_cpu::forward() {
- assert(mOp.getInput(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({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(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(),
- std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/SliceImpl.cpp b/src/operator/SliceImpl.cpp
index 3eb57fb64a95a8717d99dc191648a2e2281b7a47..6a528afdbc1399994139f5a1b8336d04ec582159 100644
--- a/src/operator/SliceImpl.cpp
+++ b/src/operator/SliceImpl.cpp
@@ -10,44 +10,69 @@
********************************************************************************/
#include <cassert>
-#include <chrono> // std::chrono::milliseconds
-#include <numeric> // std::accumulate
-#include <thread> // std::this_thread::sleep_for
-#include <vector>
+#include <numeric> // std::accumulate
+#include <functional> // std::multiplies
#include "aidge/operator/Slice.hpp"
-#include "aidge/utils/Types.h"
#include "aidge/backend/cpu/operator/SliceImpl.hpp"
#include "aidge/backend/cpu/operator/SliceImpl_forward_kernels.hpp"
+#include "aidge/utils/Types.h"
+
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu::getNbRequiredData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "requires valid input");
+
+ // Requires the whole tensors
+ return std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims()[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const { return 0; }
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu::getRequiredMemory(const Aidge::IOIndex_t outputIdx,
+ const std::vector<Aidge::DimSize_t>& inputsSize) const {
+ (void)outputIdx;
+ (void)inputsSize;
+ return std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims()[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu::getNbConsumedData(const Aidge::IOIndex_t /*inputIdx*/) const {
+ return mNbConsumedData[0];
+}
+
+Aidge::NbElts_t Aidge::SliceImpl_cpu::getNbProducedData(const Aidge::IOIndex_t /*outputIdx*/) const {
+ return mNbProducedData[0];
+}
+
+void Aidge::SliceImpl_cpu::updateConsummerProducer() {
+ // each input is consumed by the minimum amount for a forward pass
+ mNbConsumedData[0] += getNbRequiredData(0);
-Aidge::NbElts_t Aidge::SliceImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_t /*inputIdx*/) const {
- // this implementation can be in-place
- return 0;
+ mNbProducedData[0] += getRequiredMemory(0, {});
}
void Aidge::SliceImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1"); //TODO fill axes (input #1) if not given
- assert(mOp.getInput(2) && "missing input #2");
- assert(mOp.getInput(3) && "missing input #3");
+ for (IOIndex_t i = 0; i < 4; ++i)
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(i)) && ("missing input"));
- assert((mOp.getInput(1)->nbDims() == 1) && "input #1 must either be a tensor of rank 1");
- assert((mOp.getInput(2)->nbDims() == 1) && "input #2 must either be a tensor of rank 1");
- assert((mOp.getInput(3)->nbDims() == 1) && "input #3 must either be a tensor of rank 1");
+ assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->nbDims() == 1) && "input #1 must either be a tensor of rank 1");
+ assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(2))->nbDims() == 1) && "input #2 must either be a tensor of rank 1");
+ assert((std::static_pointer_cast<Tensor>(mOp.getRawInput(3))->nbDims() == 1) && "input #3 must either be a tensor of rank 1");
// Find the correct kernel type
auto kernelFunc = Registrar<SliceImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->dims()[0],
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getInput(2)->getImpl()->rawPtr(),
- mOp.getInput(3)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
-}
\ No newline at end of file
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->dims()[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.getRawInput(3))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
+}
+
+void Aidge::SliceImpl_cpu::backward() { printf("Not implemented yet.\n"); }
diff --git a/src/operator/SoftmaxImpl.cpp b/src/operator/SoftmaxImpl.cpp
index ae89090ae1d06ccee4e3ff2441795c1c612cb661..c8736f008d337d73203d0c423c95cf674f470ad0 100644
--- a/src/operator/SoftmaxImpl.cpp
+++ b/src/operator/SoftmaxImpl.cpp
@@ -27,19 +27,19 @@ Aidge::NbElts_t Aidge::SoftmaxImpl_cpu::getNbRequiredProtected(const Aidge::IOIn
}
void Aidge::SoftmaxImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- // assert(mOp.getInput(0)->nbDims()>1);
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->nbDims()>1);
// Find the correct kernel type
auto kernelFunc = Registrar<SoftmaxImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
Softmax_Op::Attrs attr = dynamic_cast<const Softmax_Op&>(mOp).getStaticAttributes();
const int& axisIdx = static_cast<const int&>(std::get<0>(attr));
// Call kernel
kernelFunc(axisIdx,
- mOp.getInput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/SqrtImpl.cpp b/src/operator/SqrtImpl.cpp
index 75d1d2fb20b6748c931124847198b3168d9bdba7..b9a01ff9146921b55dede775e1e3f61deed21a8e 100644
--- a/src/operator/SqrtImpl.cpp
+++ b/src/operator/SqrtImpl.cpp
@@ -27,15 +27,15 @@ Aidge::NbElts_t Aidge::SqrtImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex
}
void Aidge::SqrtImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
+ assert(std::static_pointer_cast<Tensor>(mOp.getRawInput(0)) && "missing input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<SqrtImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getOutput(0)->dataType()});
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(mOp.getInput(0)->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ kernelFunc(std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->size(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
\ No newline at end of file
diff --git a/src/operator/SubImpl.cpp b/src/operator/SubImpl.cpp
index 6d87821d89ff84aa1046a9ecf0fdd83dcc5dda53..7d33d935f8aed4eef741ef81e316f387ad676abe 100644
--- a/src/operator/SubImpl.cpp
+++ b/src/operator/SubImpl.cpp
@@ -27,25 +27,17 @@ Aidge::NbElts_t Aidge::SubImpl_cpu::getNbRequiredProtected(const Aidge::IOIndex_
}
void Aidge::SubImpl_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(1) && "missing input #1");
-
- assert(((mOp.getInput(1)->size() == 1) ||
- (mOp.getInput(1)->size() == mOp.getInput(0)->size()) ||
- (mOp.getInput(1)->nbDims() == 1 && mOp.getInput(1)->size() == mOp.getInput(0)->dims()[mOp.getInput(0)->nbDims()-1])
- ) &&
- "input #1 must either be a tensor of size 1, the number of channels of input # or the same size of input #0");
// Find the correct kernel type
auto kernelFunc = Registrar<SubImplForward_cpu>::create({
- mOp.getInput(0)->dataType(),
- mOp.getInput(1)->dataType(),
- mOp.getOutput(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.getRawOutput(0))->dataType()});
// Call kernel
- kernelFunc(std::static_pointer_cast<Tensor>(mOp.getInput(0))->size(),
- std::static_pointer_cast<Tensor>(mOp.getInput(1))->size(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getInput(1)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ 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(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(1))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
diff --git a/src/operator/TransposeImpl.cpp b/src/operator/TransposeImpl.cpp
index c3e8aaec12eef69675d35925dbca3c49fdca4065..1fc4458ccb85e4776228a2bf9e1c73589c201a35 100644
--- a/src/operator/TransposeImpl.cpp
+++ b/src/operator/TransposeImpl.cpp
@@ -43,12 +43,11 @@ Aidge::NbElts_t Aidge::TransposeImpl6D_cpu::getNbRequiredProtected(IOIndex_t /*i
}
void Aidge::TransposeImpl2D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(0)->nbDims() == 2 && "input #0 must have the same size as axes attributes (2)");
-
// Find the correct kernel type
auto kernelFunc =
- Registrar<TransposeImpl2DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<TransposeImpl2DForward_cpu>::create({
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// auto attr = dynamic_cast<const Transpose_Op<2>&>(mOp).getStaticAttributes();
// std::vector<DimIdx_t> outDimsOrder;
@@ -59,70 +58,66 @@ void Aidge::TransposeImpl2D_cpu::forward() {
// Call kernel
kernelFunc(dynamic_cast<const Transpose_Op<2>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getOutput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
void Aidge::TransposeImpl3D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(0)->nbDims() == 3 && "input #0 must have the same size as axes attributes (3)");
-
// Find the correct kernel type
auto kernelFunc =
- Registrar<TransposeImpl3DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<TransposeImpl3DForward_cpu>::create({
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const Transpose_Op<3>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getOutput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
void Aidge::TransposeImpl4D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(0)->nbDims() == 4 && "input #0 must have the same size as axes attributes (4)");
-
// Find the correct kernel type
auto kernelFunc =
- Registrar<TransposeImpl4DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<TransposeImpl4DForward_cpu>::create({
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const Transpose_Op<4>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getOutput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
void Aidge::TransposeImpl5D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(0)->nbDims() == 5 && "input #0 must have the same size as axes attributes (5)");
-
// Find the correct kernel type
auto kernelFunc =
- Registrar<TransposeImpl5DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<TransposeImpl5DForward_cpu>::create({
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const Transpose_Op<5>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getOutput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
void Aidge::TransposeImpl6D_cpu::forward() {
- assert(mOp.getInput(0) && "missing input #0");
- assert(mOp.getInput(0)->nbDims() == 6 && "input #0 must have the same size as axes attributes (6)");
-
// Find the correct kernel type
auto kernelFunc =
- Registrar<TransposeImpl6DForward_cpu>::create({mOp.getInput(0)->dataType(), mOp.getOutput(0)->dataType()});
+ Registrar<TransposeImpl6DForward_cpu>::create({
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dataType(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dataType()});
// Call kernel
kernelFunc(dynamic_cast<const Transpose_Op<6>&>(mOp).getStaticAttributes(),
- mOp.getInput(0)->dims(),
- mOp.getOutput(0)->dims(),
- mOp.getInput(0)->getImpl()->rawPtr(),
- mOp.getOutput(0)->getImpl()->rawPtr());
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->dims(),
+ std::static_pointer_cast<Tensor>(mOp.getRawInput(0))->getImpl()->rawPtr(),
+ std::static_pointer_cast<Tensor>(mOp.getRawOutput(0))->getImpl()->rawPtr());
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_AddImpl.cpp b/unit_tests/operator/Test_AddImpl.cpp
index 18d98d169ddcb74310c5153d7c2c95103c395bb7..740b1a5322b55e2347d93ed2e515358080a108a5 100644
--- a/unit_tests/operator/Test_AddImpl.cpp
+++ b/unit_tests/operator/Test_AddImpl.cpp
@@ -18,7 +18,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Add(forward)") {
+TEST_CASE("[cpu/operator] Add(forward)", "[Add][CPU]") {
std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array4D<int,3,3,3,2> {
{ //
{ //
@@ -40,14 +40,15 @@ TEST_CASE("[cpu/operator] Add(forward)") {
}); //
SECTION("One input") {
- std::shared_ptr<Node> myAdd = Add<1>();
- myAdd->getOperator()->setBackend("cpu");
- myAdd->getOperator()->setDatatype(DataType::Int32);
- myAdd->getOperator()->associateInput(0, input1);
- myAdd->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myAdd = Add(1);
+ auto op = std::static_pointer_cast<OperatorTensor>(myAdd -> getOperator());
+ op->associateInput(0, input1);
+ op->setBackend("cpu");
+ op->setDataType(DataType::Int32);
+ op->computeOutputDims();
myAdd->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myAdd->getOperator()->getOutput(0)) == *input1);
+ REQUIRE(*(op->getOutput(0)) == *input1);
}
SECTION("Two inputs") {
@@ -71,15 +72,16 @@ TEST_CASE("[cpu/operator] Add(forward)") {
}
});
- std::shared_ptr<Node> myAdd = Add<2>();
- myAdd->getOperator()->setDatatype(DataType::Int32);
- myAdd->getOperator()->setBackend("cpu");
- myAdd->getOperator()->associateInput(0, input1);
- myAdd->getOperator()->associateInput(1, input1);
- myAdd->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myAdd = Add(2);
+ auto op = std::static_pointer_cast<OperatorTensor>(myAdd -> getOperator());
+ op->associateInput(0, input1);
+ op->associateInput(1, input1);
+ op->setBackend("cpu");
+ op->setDataType(DataType::Int32);
+ op->computeOutputDims();
myAdd->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myAdd->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("Three inputs") {
@@ -103,15 +105,16 @@ TEST_CASE("[cpu/operator] Add(forward)") {
}
});
- std::shared_ptr<Node> myAdd = Add<3>();
- myAdd->getOperator()->setDatatype(DataType::Int32);
- myAdd->getOperator()->setBackend("cpu");
- myAdd->getOperator()->associateInput(0, input1);
- myAdd->getOperator()->associateInput(1, input1);
- myAdd->getOperator()->associateInput(2, input1);
- myAdd->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myAdd = Add(3);
+ auto op = std::static_pointer_cast<OperatorTensor>(myAdd -> getOperator());
+ op->associateInput(0, input1);
+ op->associateInput(1, input1);
+ op->associateInput(2, input1);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myAdd->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myAdd->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*op->getOutput(0) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_AvgPoolingImpl.cpp b/unit_tests/operator/Test_AvgPoolingImpl.cpp
index 10d4c09b32528e2cdcdbf2c56204e6911fca0187..c4abf0201771c3f39a429e0f935b8216a04514e1 100644
--- a/unit_tests/operator/Test_AvgPoolingImpl.cpp
+++ b/unit_tests/operator/Test_AvgPoolingImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] AvgPooling(forward)") {
+TEST_CASE("[cpu/operator] AvgPooling(forward)", "[AvgPooling][CPU]") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<float,2,2,5,5> { //NCHW
{
{
@@ -53,10 +53,9 @@ TEST_CASE("[cpu/operator] AvgPooling(forward)") {
});
SECTION("Stride") {
std::shared_ptr<Node> myAvgPool = AvgPooling({2,2}, "mycdw", {2,2});
- myAvgPool->getOperator()->setDatatype(DataType::Float32);
- myAvgPool->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myAvgPool -> getOperator());
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
{
{
{{ 3, 5},
@@ -72,11 +71,13 @@ TEST_CASE("[cpu/operator] AvgPooling(forward)") {
}
}
});
- myAvgPool->getOperator()->associateInput(0,myInput);
- myAvgPool->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myAvgPool->forward();
- myAvgPool->getOperator()->getOutput(0)->print();
- REQUIRE(*(myAvgPool->getOperator()->getOutput(0)) == *myOutput);
+ op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Stride >= feature dim") {
@@ -90,21 +91,22 @@ TEST_CASE("[cpu/operator] AvgPooling(forward)") {
}
});
std::shared_ptr<Node> myAvgPool = AvgPooling({3,3}, "mycdw", {3,3});
- myAvgPool->getOperator()->setDatatype(DataType::Float32);
- myAvgPool->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myAvgPool -> getOperator());
- Tensor myOutput = Array4D<float,1,1,1,1> {
+ Tensor myOutput = Array4D<float,1,1,1,1> {
{{{{(0.3745 + 0.9507 + 0.7320 + 0.5987 + 0.1560 + 0.1560 + 0.0581 + 0.8662 + 0.6011)/9.0}}}}
};
- myAvgPool->getOperator()->associateInput(0,myInput2);
- myAvgPool->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myAvgPool->forward();
- myAvgPool->getOperator()->getOutput(0)->print();
- float* outPtr = static_cast<float*>(myAvgPool->getOperator()->output(0).getImpl()->rawPtr());
+ op->getOutput(0)->print();
+ float* outPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedOutPtr = static_cast<float*>(myOutput.getImpl()->rawPtr());
for (std::size_t i = 0; i < 1; ++i) {
REQUIRE(std::abs(outPtr[i] - expectedOutPtr[i]) < 0.00001);
}
}
- // std::cout << static_cast<Tensor>((*myAvgPool->getOperator())["weight"])[0][0][0][0] << std::endl;
+ // std::cout << static_cast<Tensor>((*op)["weight"])[0][0][0][0] << std::endl;
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_BatchNormImpl.cpp b/unit_tests/operator/Test_BatchNormImpl.cpp
index e6107a028e0c3d62f69821ff2650b45f34da103f..e6b7c3c655b865973028fc8c43323a7db3f4a5ef 100644
--- a/unit_tests/operator/Test_BatchNormImpl.cpp
+++ b/unit_tests/operator/Test_BatchNormImpl.cpp
@@ -19,10 +19,9 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] BatchNorm(forward)") {
+TEST_CASE("[cpu/operator] BatchNorm(forward)", "[BatchNorm][CPU]") {
std::shared_ptr<Node> myBatchNorm = BatchNorm<2>(0.00001F, 0.1F, "mybatchnorm");
- myBatchNorm->getOperator()->setDatatype(DataType::Float32);
- myBatchNorm->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myBatchNorm -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array1D<float,3> {{0.9044, 0.3028, 0.0218}});
std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<float,3> {{0.1332, 0.7503, 0.0878}});
std::shared_ptr<Tensor> myMean = std::make_shared<Tensor>(Array1D<float,3> {{0.9931, 0.8421, 0.9936}});
@@ -53,7 +52,7 @@ TEST_CASE("[cpu/operator] BatchNorm(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,3,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,3,3,3> {
{
{
{{-0.08978321, -0.12890550, -0.21362889},
@@ -79,19 +78,21 @@ TEST_CASE("[cpu/operator] BatchNorm(forward)") {
}
}
});
- myBatchNorm->getOperator()->associateInput(0,myInput);
- myBatchNorm->getOperator()->associateInput(1,myWeights);
- myBatchNorm->getOperator()->associateInput(2,myBias);
- myBatchNorm->getOperator()->associateInput(3,myMean);
- myBatchNorm->getOperator()->associateInput(4,myVar);
- myBatchNorm->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput);
+ op->associateInput(1,myWeights);
+ op->associateInput(2,myBias);
+ op->associateInput(3,myMean);
+ op->associateInput(4,myVar);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myBatchNorm->forward();
- float* resPtr = static_cast<float*>(myBatchNorm->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(myOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
}
- // std::cout << static_cast<Tensor>((*myBatchNorm->getOperator())["weight"])[0][0][0][0] << std::endl;
+ // std::cout << static_cast<Tensor>((*op)["weight"])[0][0][0][0] << std::endl;
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ConcatImpl.cpp b/unit_tests/operator/Test_ConcatImpl.cpp
index b5222810ee602e703efca62fd552ec0763d257ec..e3a3c93e9a050bf0a9f8a83df0d44ae33c53d561 100644
--- a/unit_tests/operator/Test_ConcatImpl.cpp
+++ b/unit_tests/operator/Test_ConcatImpl.cpp
@@ -21,6 +21,31 @@
using namespace Aidge;
TEST_CASE("[cpu/operator] Concat(forward)") {
+ SECTION("Concat 1D inputs") {
+ std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array1D<int,2>{{ 2, 3 }});
+ std::shared_ptr<Tensor> input2 = std::make_shared<Tensor>(Array1D<int,3>{{ 4, 5, 6 }});
+ std::shared_ptr<Tensor> input3 = std::make_shared<Tensor>(Array1D<int,4>{{ 7, 8, 9, 10 }});
+ std::shared_ptr<Tensor> input4 = std::make_shared<Tensor>(Array1D<int,5>{{ 11, 12, 13, 14, 15 }});
+ std::shared_ptr<Tensor> input5 = std::make_shared<Tensor>(Array1D<int,6>{{ 16, 17, 18, 19, 20, 21 }});
+
+ std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(Array1D<int,20>{
+ { 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17,18,19,20,21 }});
+
+ auto myConcat = Concat(5, 0);
+ myConcat->getOperator()->associateInput(0, input1);
+ myConcat->getOperator()->associateInput(1, input2);
+ myConcat->getOperator()->associateInput(2, input3);
+ myConcat->getOperator()->associateInput(3, input4);
+ myConcat->getOperator()->associateInput(4, input5);
+ myConcat->getOperator()->setBackend("cpu");
+ myConcat->getOperator()->setDataType(DataType::Int32);
+ std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->computeOutputDims();
+ myConcat->forward();
+
+ std::static_pointer_cast<Tensor>(myConcat->getOperator()->getRawOutput(0))->print();
+
+ REQUIRE(*std::static_pointer_cast<OperatorTensor>(myConcat->getOperator())->getOutput(0) == *expectedOutput);
+ }
SECTION("2D Tensors") {
std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -41,15 +66,16 @@ TEST_CASE("[cpu/operator] Concat(forward)") {
}
});
- std::shared_ptr<Node> myConcat = Concat(1, 2);
- myConcat->getOperator()->setDatatype(DataType::Float32);
- myConcat->getOperator()->setBackend("cpu");
- myConcat->getOperator()->associateInput(0,input1);
- myConcat->getOperator()->associateInput(1,input2);
- myConcat->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myConcat = Concat(2, 1);
+ auto op = std::static_pointer_cast<OperatorTensor>(myConcat->getOperator());
+ op->associateInput(0,input1);
+ op->associateInput(1,input2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myConcat->forward();
- REQUIRE(*(myConcat->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("3D Tensors") {
std::shared_ptr<Tensor> input1 = std::make_shared<Tensor>(Array3D<int,2,1,3> {
@@ -91,15 +117,16 @@ TEST_CASE("[cpu/operator] Concat(forward)") {
}
});
- std::shared_ptr<Node> myConcat = Concat(1, 3);
- myConcat->getOperator()->setDatatype(DataType::Int32);
- myConcat->getOperator()->setBackend("cpu");
- myConcat->getOperator()->associateInput(0,input1);
- myConcat->getOperator()->associateInput(1,input2);
- myConcat->getOperator()->associateInput(2,input1);
- myConcat->getOperator()->computeOutputDims();
+ std::shared_ptr<Node> myConcat = Concat(3, 1);
+ auto op = std::static_pointer_cast<OperatorTensor>(myConcat->getOperator());
+ op->associateInput(0,input1);
+ op->associateInput(1,input2);
+ op->associateInput(2,input1);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myConcat->forward();
- REQUIRE(*(myConcat->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ConvDepthWiseImpl.cpp b/unit_tests/operator/Test_ConvDepthWiseImpl.cpp
index 0d0ed4b928d64cafc96907fedf3ee0d642a255d0..112703b64162004ab708f143d6e12b0c8bb9c6b6 100644
--- a/unit_tests/operator/Test_ConvDepthWiseImpl.cpp
+++ b/unit_tests/operator/Test_ConvDepthWiseImpl.cpp
@@ -19,34 +19,33 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] ConvDepthWise(forward)") {
- std::shared_ptr<Node> myCDW = ConvDepthWise({3,3}, "mycdw");
- myCDW->getOperator()->setDatatype(DataType::Int32);
- myCDW->getOperator()->setBackend("cpu");
- std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array3D<int,4,3,3> {
+TEST_CASE("[cpu/operator] ConvDepthWise(forward)", "[ConvDepthWise][CPU]") {
+ std::shared_ptr<Node> myCDW = ConvDepthWise(4, {3,3}, "mycdw");
+ auto op = std::static_pointer_cast<OperatorTensor>(myCDW -> getOperator());
+ std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,1,3,3> {
{
- {
+ {{
{ 0, 1, 2},
{ 3, 4, 5},
{ 6, 7, 8}
- },
- {
+ }},
+ {{
{ 27, 28, 29},
{ 30, 31, 32},
{ 33, 34, 35}
- },
- {
+ }},
+ {{
{ 54, 55, 56},
{ 57, 58, 59},
{ 60, 61, 62}
- },
- {
+ }},
+ {{
{ 81, 82, 83},
{ 84, 85, 86},
{ 87, 88, 89}
- }
+ }}
}
});
std::shared_ptr<Tensor> myBias = std::make_shared<Tensor>(Array1D<int,4> {{7,0,9,0}});
@@ -104,7 +103,7 @@ TEST_CASE("[cpu/operator] ConvDepthWise(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
{
{
{{ 319, 355, 391},
@@ -142,13 +141,15 @@ TEST_CASE("[cpu/operator] ConvDepthWise(forward)") {
}
}
});
- myCDW->getOperator()->associateInput(0,myInput);
- myCDW->getOperator()->associateInput(1,myWeights);
- myCDW->getOperator()->associateInput(2,myBias);
- myCDW->getOperator()->computeOutputDims();
- myCDW->forward();
- myCDW->getOperator()->getOutput(0)->print();
- REQUIRE(*(myCDW->getOperator()->getOutput(0)) == *myOutput);
-
- // std::cout << static_cast<Tensor>((*myCDW->getOperator())["weight"])[0][0][0][0] << std::endl;
+ op -> associateInput(0, myInput);
+ op -> associateInput(1, myWeights);
+ op -> associateInput(2, myBias);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op -> computeOutputDims();
+ myCDW -> forward();
+ op -> getOutput(0) -> print();
+ REQUIRE(*(op -> getOutput(0)) == *myOutput);
+
+ // std::cout << static_cast<Tensor>((*op)["weight"])[0][0][0][0] << std::endl;
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ConvImpl.cpp b/unit_tests/operator/Test_ConvImpl.cpp
index 891f0e94b02d07d41751728e83fa9b42e4b89be8..0f46e8f6405366a32f45ce61d61fc94afabdd4a8 100644
--- a/unit_tests/operator/Test_ConvImpl.cpp
+++ b/unit_tests/operator/Test_ConvImpl.cpp
@@ -20,11 +20,10 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Conv(forward)") {
+TEST_CASE("[cpu/operator] Conv(forward)", "[Conv][CPU]") {
SECTION("Classic Conv") {
std::shared_ptr<Node> myConv = Conv(3,4,{3,3}, "myconv");
- myConv->getOperator()->setDatatype(DataType::Int32);
- myConv->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
{
{
@@ -116,7 +115,7 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
{
{
{{ 15226, 15577, 15928},
@@ -148,19 +147,20 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
}
}
});
- myConv->getOperator()->associateInput(0,myInput);
- myConv->getOperator()->associateInput(1,myWeights);
- myConv->getOperator()->associateInput(2,myBias);
- myConv->getOperator()->computeOutputDims();
+ op->associateInput(0,myInput);
+ op->associateInput(1,myWeights);
+ op->associateInput(2,myBias);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
- // myConv->getOperator()->getOutput(0)->print();
- REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
+ // op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Point-wise") {
std::shared_ptr<Node> myConv = Conv(3,4,{1,1}, "myconv", {1,1});
- myConv->getOperator()->setDatatype(DataType::Float32);
- myConv->getOperator()->setBackend("cpu");
- myConv->getOperator()->input(0) = Array4D<float,2,3,3,3> {
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
+ op->setInput(0, std::make_shared<Tensor>(Array4D<float,2,3,3,3> {
{
{
{{-1.38467371F, -0.87123615F, -0.22336592F},
@@ -185,8 +185,8 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
{ 0.09811721F, 1.74225271F, -1.35267365F}}
}
}
- };
- myConv->getOperator()->input(1) = Array4D<float,4,3,1,1> {
+ }));
+ op->setInput(1, std::make_shared<Tensor>(Array4D<float,4,3,1,1> {
{
{
{{ 0.33669037F}},
@@ -208,8 +208,8 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
{{ 0.80935723F}}
}
}
- };
- myConv->getOperator()->input(2) = Array1D<float,4> {{ 1.11029029F, -1.68979895F, -0.98895991F, 0.95797181F}};
+ }));
+ op->setInput(2, std::make_shared<Tensor>(Array1D<float,4> {{ 1.11029029F, -1.68979895F, -0.98895991F, 0.95797181F}}));
Tensor expectedOutput = Array4D<float,2,4,3,3> {
{
{
@@ -242,11 +242,12 @@ TEST_CASE("[cpu/operator] Conv(forward)") {
}
}
};
-
- myConv->getOperator()->computeOutputDims();
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
-
- float* resPtr = static_cast<float*>(myConv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput.getImpl()->rawPtr());
for (std::size_t i = 0; i< expectedOutput.size(); ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_DivImpl.cpp b/unit_tests/operator/Test_DivImpl.cpp
index c33319c88b63ee834bbcb388bbbe0775699edbd7..16f69db964a092f6be87e5d983ba00694e8006f8 100644
--- a/unit_tests/operator/Test_DivImpl.cpp
+++ b/unit_tests/operator/Test_DivImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Div(forward)") {
+TEST_CASE("[cpu/operator] Div(forward)", "[Div][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
- myDiv->forward();
-
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
+ myDiv -> forward();
+
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,14 +74,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
myDiv->forward();
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
myDiv->forward();
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -191,14 +194,15 @@ TEST_CASE("[cpu/operator] Div(forward)") {
});
std::shared_ptr<Node> myDiv = Div();
- myDiv->getOperator()->setDatatype(DataType::Float32);
- myDiv->getOperator()->setBackend("cpu");
- myDiv->getOperator()->associateInput(0, input_1);
- myDiv->getOperator()->associateInput(1, input_2);
- myDiv->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myDiv -> getOperator());
+ op -> associateInput(0, input_1);
+ op -> associateInput(1, input_2);
+ op -> setDataType(DataType::Float32);
+ op -> setBackend("cpu");
+ op -> computeOutputDims();
myDiv->forward();
- float* resPtr = static_cast<float*>(myDiv->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_ErfImpl.cpp b/unit_tests/operator/Test_ErfImpl.cpp
index d7ce4d6ab0ccc5d05c1a9a947f046598e12ea926..db2ae0437742d1cd1b298d62f5bdd7241b755ec4 100644
--- a/unit_tests/operator/Test_ErfImpl.cpp
+++ b/unit_tests/operator/Test_ErfImpl.cpp
@@ -33,13 +33,14 @@ TEST_CASE("[cpu/operator] Erf(forward)") {
});
std::shared_ptr<Node> myErf = Erf();
- myErf->getOperator()->setDatatype(DataType::Float32);
- myErf->getOperator()->setBackend("cpu");
- myErf->getOperator()->associateInput(0,input0);
- myErf->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myErf -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myErf->forward();
- float* resPtr = static_cast<float*>(myErf->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,13 +74,14 @@ TEST_CASE("[cpu/operator] Erf(forward)") {
});
std::shared_ptr<Node> myErf = Erf();
- myErf->getOperator()->setDatatype(DataType::Float32);
- myErf->getOperator()->setBackend("cpu");
- myErf->getOperator()->associateInput(0,input0);
- myErf->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myErf -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myErf->forward();
- float* resPtr = static_cast<float*>(myErf->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_FCImpl.cpp b/unit_tests/operator/Test_FCImpl.cpp
index e3494e20205f1a295eb537100b59fb7bbc26116a..4309ce1a54f14b1da0c8b173cb46992109ee034b 100644
--- a/unit_tests/operator/Test_FCImpl.cpp
+++ b/unit_tests/operator/Test_FCImpl.cpp
@@ -19,7 +19,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/oeprator] FC(forward)") {
+TEST_CASE("[cpu/oeprator] FC(forward)", "[FC][CPU]") {
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array2D<int, 5, 75>{
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8,
@@ -45,11 +45,10 @@ TEST_CASE("[cpu/oeprator] FC(forward)") {
std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array2D<int, 2, 5>{
{{23601, 23602, 23603, 23604, 23605}, {68601, 68602, 68603, 68604, 68605}}});
- std::shared_ptr<Node> myFC = FC(5, false, "myfc");
- myFC->getOperator()->setDatatype(DataType::Int32);
- myFC->getOperator()->setBackend("cpu");
- myFC->getOperator()->associateInput(1, myWeights);
- myFC->getOperator()->associateInput(2, myBias);
+ std::shared_ptr<Node> myFC = FC(75, 5, false, "myfc");
+ auto op = std::static_pointer_cast<OperatorTensor>(myFC -> getOperator());
+ op -> associateInput(1, myWeights);
+ op -> associateInput(2, myBias);
SECTION("2D input") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array2D<int, 2, 75>{
@@ -62,10 +61,12 @@ TEST_CASE("[cpu/oeprator] FC(forward)") {
105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149}}});
- myFC->getOperator()->associateInput(0, myInput);
- myFC->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op -> setDataType(DataType::Int32);
+ op -> setBackend("cpu");
+ op->computeOutputDims();
myFC->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myFC->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("4D input") {
std::shared_ptr<Tensor> myInput =
@@ -99,10 +100,12 @@ TEST_CASE("[cpu/oeprator] FC(forward)") {
{135, 136, 137, 138, 139},
{140, 141, 142, 143, 144},
{145, 146, 147, 148, 149}}}}});
- myFC->getOperator()->associateInput(0, myInput);
- myFC->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op -> setDataType(DataType::Int32);
+ op -> setBackend("cpu");
+ op->computeOutputDims();
myFC->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myFC->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
// std::cout << static_cast<Tensor>((*myFC->getOperator())["weight"])[0][0][0][0] << std::endl;
diff --git a/unit_tests/operator/Test_GatherImpl.cpp b/unit_tests/operator/Test_GatherImpl.cpp
index c295bf7c612316c1382ea73ee2dadad10d42c2e7..e0903aa77696467db3708cb26dfda4ce90a4344a 100644
--- a/unit_tests/operator/Test_GatherImpl.cpp
+++ b/unit_tests/operator/Test_GatherImpl.cpp
@@ -45,15 +45,15 @@ TEST_CASE("[cpu/operator] Gather(forward)") {
});
std::shared_ptr<Node> myGather = Gather(0);
- myGather->getOperator()->setDatatype(DataType::Int32);
- myGather->getOperator()->setBackend("cpu");
- myGather->getOperator()->associateInput(0,input);
- myGather->getOperator()->associateInput(1,indexes);
- myGather->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myGather -> getOperator());
+ op->associateInput(0,input);
+ op->associateInput(1,indexes);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myGather->forward();
- REQUIRE(myGather->getOperator()->output(0).dims() == expectedOutput->dims());
- REQUIRE(*(myGather->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("2D Tensor axis 1") {
@@ -84,15 +84,15 @@ TEST_CASE("[cpu/operator] Gather(forward)") {
});
std::shared_ptr<Node> myGather = Gather(1);
- myGather->getOperator()->setDatatype(DataType::Int32);
- myGather->getOperator()->setBackend("cpu");
- myGather->getOperator()->associateInput(0,input);
- myGather->getOperator()->associateInput(1,indexes);
- myGather->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myGather -> getOperator());
+ op->associateInput(0,input);
+ op->associateInput(1,indexes);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myGather->forward();
- REQUIRE(myGather->getOperator()->output(0).dims() == expectedOutput->dims());
- REQUIRE(*(myGather->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_LeakyReLUImpl.cpp b/unit_tests/operator/Test_LeakyReLUImpl.cpp
index d5bd91ff75404a7b928c8919c64e06315b78206f..cad2a6f97a31e4e2200a8c8ceb1d9dde7b118362 100644
--- a/unit_tests/operator/Test_LeakyReLUImpl.cpp
+++ b/unit_tests/operator/Test_LeakyReLUImpl.cpp
@@ -18,7 +18,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
+TEST_CASE("[cpu/operator] LeakyReLU(forward)", "[LeakyReLU][CPU]") {
SECTION("1D Tensor") {
std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<int,10> {
{0, 1, 2,-3, 4,-5,-6, 7, 8, 9}
@@ -28,12 +28,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myLeakyReLU->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("2D Tensor") {
@@ -51,12 +52,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("3D Tensor") {
@@ -86,12 +88,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("4D Tensor") {
@@ -145,12 +148,13 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU();
- myLeakyReLU->getOperator()->setDatatype(DataType::Int32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("Test construction attribute: negative_slop") {
@@ -162,11 +166,12 @@ TEST_CASE("[cpu/operator] LeakyReLU(forward)") {
});
std::shared_ptr<Node> myLeakyReLU = LeakyReLU(0.5f);
- myLeakyReLU->getOperator()->setDatatype(DataType::Float32);
- myLeakyReLU->getOperator()->setBackend("cpu");
- myLeakyReLU->getOperator()->associateInput(0,input0);
- myLeakyReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myLeakyReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myLeakyReLU->forward();
- REQUIRE(*myLeakyReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_MatMulImpl.cpp b/unit_tests/operator/Test_MatMulImpl.cpp
index 0da01b3287043e07e5b967df8882960cfb814f8f..1edb915fb78e3e056f455ddecb8e704eee068cd9 100644
--- a/unit_tests/operator/Test_MatMulImpl.cpp
+++ b/unit_tests/operator/Test_MatMulImpl.cpp
@@ -19,7 +19,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
+TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
// Test MatMul forward with batch size = 2 and feature size = 75
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array2D<int, 5, 75>{
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2, 3, 4,
@@ -45,10 +45,9 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array2D<int, 2, 5>{
{{23600, 23600, 23600, 23600, 23600}, {68600, 68600, 68600, 68600, 68600}}});
- std::shared_ptr<Node> myMatMul = MatMul(5, "mymatmul");
- myMatMul->getOperator()->setDatatype(DataType::Int32);
- myMatMul->getOperator()->setBackend("cpu");
- myMatMul->getOperator()->associateInput(1, myWeights);
+ std::shared_ptr<Node> myMatMul = MatMul(75, 5, "mymatmul");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMatMul -> getOperator());
+ op->associateInput(1, myWeights);
SECTION("2D input") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array2D<int, 2, 75>{
@@ -61,10 +60,12 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149}}});
- myMatMul->getOperator()->associateInput(0, myInput);
- myMatMul->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myMatMul->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myMatMul->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("4D input") {
std::shared_ptr<Tensor> myInput =
@@ -98,10 +99,12 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul]") {
{135, 136, 137, 138, 139},
{140, 141, 142, 143, 144},
{145, 146, 147, 148, 149}}}}});
- myMatMul->getOperator()->associateInput(0, myInput);
- myMatMul->getOperator()->computeOutputDims();
+ op->associateInput(0, myInput);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myMatMul->forward();
- REQUIRE(*std::static_pointer_cast<Tensor>(myMatMul->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
// std::cout << static_cast<Tensor>((*myMatMul->getOperator())["weight"])[0][0][0][0] << std::endl;
diff --git a/unit_tests/operator/Test_MaxPoolingImpl.cpp b/unit_tests/operator/Test_MaxPoolingImpl.cpp
index 83fa7eaa670399c8d6c085a14db08fa35df9de8c..9f528f2d044cf43133f3729a7f0e4f1bd95b8889 100644
--- a/unit_tests/operator/Test_MaxPoolingImpl.cpp
+++ b/unit_tests/operator/Test_MaxPoolingImpl.cpp
@@ -21,7 +21,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] MaxPooling(forward)") {
+TEST_CASE("[cpu/operator] MaxPooling(forward)", "[MaxPooling][CPU]") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<float,2,2,5,5> { //NCHW
{
{
@@ -54,10 +54,9 @@ TEST_CASE("[cpu/operator] MaxPooling(forward)") {
});
SECTION("Stride") {
std::shared_ptr<Node> myMaxPool = MaxPooling({2,2}, "mycdw", {2,2});
- myMaxPool->getOperator()->setDatatype(DataType::Float32);
- myMaxPool->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMaxPool -> getOperator());
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<float,2,2,2,2> {
{
{
{{ 0.7995, 0.6142},
@@ -74,9 +73,11 @@ TEST_CASE("[cpu/operator] MaxPooling(forward)") {
}
});
myMaxPool->getOperator()->associateInput(0,myInput);
- myMaxPool->getOperator()->computeOutputDims();
+ myMaxPool->getOperator()->setDataType(DataType::Float32);
+ myMaxPool->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMaxPool->forward();
- myMaxPool->getOperator()->getOutput(0)->print();
- REQUIRE(*(myMaxPool->getOperator()->getOutput(0)) == *myOutput);
+ op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_MulImpl.cpp b/unit_tests/operator/Test_MulImpl.cpp
index cea62f998cfc538d1d5800639e461eb4d15cb270..1707bc81e0bb549bfe90078242f8a4eae77db3c3 100644
--- a/unit_tests/operator/Test_MulImpl.cpp
+++ b/unit_tests/operator/Test_MulImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Mul(forward)") {
+TEST_CASE("[cpu/operator] Mul(forward)", "[Mul][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Mul(forward)") {
});
std::shared_ptr<Node> myMul = Mul();
- myMul->getOperator()->setDatatype(DataType::Float32);
- myMul->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMul -> getOperator());
myMul->getOperator()->associateInput(0, input_1);
myMul->getOperator()->associateInput(1, input_2);
- myMul->getOperator()->computeOutputDims();
+ myMul->getOperator()->setDataType(DataType::Float32);
+ myMul->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMul->forward();
- float* resPtr = static_cast<float*>(myMul->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,14 +74,15 @@ TEST_CASE("[cpu/operator] Mul(forward)") {
});
std::shared_ptr<Node> myMul = Mul();
- myMul->getOperator()->setDatatype(DataType::Float32);
- myMul->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMul -> getOperator());
myMul->getOperator()->associateInput(0, input_1);
myMul->getOperator()->associateInput(1, input_2);
- myMul->getOperator()->computeOutputDims();
+ myMul->getOperator()->setDataType(DataType::Float32);
+ myMul->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMul->forward();
- float* resPtr = static_cast<float*>(myMul->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Mul(forward)") {
});
std::shared_ptr<Node> myMul = Mul();
- myMul->getOperator()->setDatatype(DataType::Float32);
- myMul->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myMul -> getOperator());
myMul->getOperator()->associateInput(0, input_1);
myMul->getOperator()->associateInput(1, input_2);
- myMul->getOperator()->computeOutputDims();
+ myMul->getOperator()->setDataType(DataType::Float32);
+ myMul->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myMul->forward();
- float* resPtr = static_cast<float*>(myMul->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_PadImpl.cpp b/unit_tests/operator/Test_PadImpl.cpp
index b603e165392f1a861dc1b40d50b70a53c9256870..edcdaa9623e4a788f515ee99491accffcef576af 100644
--- a/unit_tests/operator/Test_PadImpl.cpp
+++ b/unit_tests/operator/Test_PadImpl.cpp
@@ -20,13 +20,12 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Pad(forward)") {
+TEST_CASE("[cpu/operator] Pad(forward)", "[Pad][CPU]") {
SECTION("Symmetric Pad") {
const int pv = 0; // pad value
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Constant, static_cast<double>(pv));
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -125,18 +124,19 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Asymmetric Pad") {
const int pv = 0; // pad value
std::shared_ptr<Node> myPad = Pad<2>({1, 0, 0, 1}, "mypad", PadBorderType::Constant, static_cast<double>(pv));
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -229,16 +229,17 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Pad Edge") {
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Edge);
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -337,16 +338,17 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Pad Reflect") {
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Reflect);
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -453,16 +455,17 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
- myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ op->getOutput(0)->print();
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("Pad Wrap") {
std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Wrap);
- myPad->getOperator()->setDatatype(DataType::Int32);
- myPad->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
{
{
@@ -561,9 +564,11 @@ TEST_CASE("[cpu/operator] Pad(forward)") {
});
myPad->getOperator()->associateInput(0,myInput);
- myPad->getOperator()->computeOutputDims();
+ myPad->getOperator()->setDataType(DataType::Int32);
+ myPad->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myPad->forward();
// myPad->getOperator()->getOutput(0)->print();
- REQUIRE(*(myPad->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_PaddedConv.cpp b/unit_tests/operator/Test_PaddedConv.cpp
index e41be85ab00faae1af7239c43b74a34f558a663c..3baf0a7aa0f366a8f0dd4e3e9df6700a5cdb0cea 100644
--- a/unit_tests/operator/Test_PaddedConv.cpp
+++ b/unit_tests/operator/Test_PaddedConv.cpp
@@ -21,11 +21,10 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] PaddedConv(forward)") {
+TEST_CASE("[cpu/operator] PaddedConv(forward)", "[PaddedConv][CPU]") {
SECTION("Classic Conv") {
std::shared_ptr<Node> myConv = PaddedConv(3,4,{3,3}, "myconv");
- myConv->getOperator()->setDatatype(DataType::Int32);
- myConv->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
{
{
@@ -117,7 +116,7 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,3,3> {
{
{
{{ 15226, 15577, 15928},
@@ -153,15 +152,16 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
myConv->getOperator()->associateInput(0,myInput);
myConv->getOperator()->associateInput(1,myWeights);
myConv->getOperator()->associateInput(2,myBias);
- myConv->getOperator()->computeOutputDims();
+ myConv->getOperator()->setDataType(DataType::Int32);
+ myConv->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
- REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("test Padding") {
std::shared_ptr<Node> myConv = PaddedConv(3,4,{3,3}, "myconv", {1,1}, {1,1,1,1});
- myConv->getOperator()->setDatatype(DataType::Int32);
- myConv->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(myConv -> getOperator());
std::shared_ptr<Tensor> myWeights = std::make_shared<Tensor>(Array4D<int,4,3,3,3> {
{
{
@@ -253,7 +253,7 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
}
}
});
- std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,5,5> {
+ std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,4,5,5> {
{
{
{{ 6895, 10225, 10486, 10747, 7063},
@@ -311,9 +311,11 @@ TEST_CASE("[cpu/operator] PaddedConv(forward)") {
myConv->getOperator()->associateInput(0,myInput);
myConv->getOperator()->associateInput(1,myWeights);
myConv->getOperator()->associateInput(2,myBias);
- myConv->getOperator()->computeOutputDims();
+ myConv->getOperator()->setDataType(DataType::Int32);
+ myConv->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
myConv->forward();
- REQUIRE(*(myConv->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
diff --git a/unit_tests/operator/Test_PowImpl.cpp b/unit_tests/operator/Test_PowImpl.cpp
index 7293198f411510904ee73aced47b69dfc37374af..0c95e785958aca72b5ae1f5727134552310e5bef 100644
--- a/unit_tests/operator/Test_PowImpl.cpp
+++ b/unit_tests/operator/Test_PowImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Pow(forward)") {
+TEST_CASE("[cpu/operator] Pow(forward)", "[Pow][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -76,14 +77,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -187,14 +190,15 @@ TEST_CASE("[cpu/operator] Pow(forward)") {
});
std::shared_ptr<Node> myPow = Pow();
- myPow->getOperator()->setDatatype(DataType::Float32);
- myPow->getOperator()->setBackend("cpu");
- myPow->getOperator()->associateInput(0, input_1);
- myPow->getOperator()->associateInput(1, input_2);
- myPow->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myPow -> getOperator());
+ op->associateInput(0, input_1);
+ op->associateInput(1, input_2);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myPow->forward();
- float* resPtr = static_cast<float*>(myPow->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_ReLUImpl.cpp b/unit_tests/operator/Test_ReLUImpl.cpp
index 9752a4914b5cb3cd06f2654cf64e0c193c5dd65b..c4166ac4dba75d6719fc2f38f980065126948e1f 100644
--- a/unit_tests/operator/Test_ReLUImpl.cpp
+++ b/unit_tests/operator/Test_ReLUImpl.cpp
@@ -21,7 +21,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] ReLU(forward)") {
+TEST_CASE("[cpu/operator] ReLU(forward)", "[ReLU][CPU]") {
SECTION("1D Tensor") {
std::shared_ptr<Tensor> input0 = std::make_shared<Tensor>(Array1D<int,10> {
{0, 1, 2,-3, 4,-5,-6, 7, 8, 9}
@@ -31,12 +31,13 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*(myReLU->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("2D Tensor") {
@@ -54,12 +55,13 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*myReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*op->getOutput(0) == *expectedOutput);
}
SECTION("3D Tensor") {
@@ -89,12 +91,13 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*(myReLU->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("4D Tensor") {
@@ -148,11 +151,12 @@ TEST_CASE("[cpu/operator] ReLU(forward)") {
});
std::shared_ptr<Node> myReLU = ReLU();
- myReLU->getOperator()->setDatatype(DataType::Int32);
- myReLU->getOperator()->setBackend("cpu");
- myReLU->getOperator()->associateInput(0,input0);
- myReLU->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReLU -> getOperator());
+ op->associateInput(0,input0);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReLU->forward();
- REQUIRE(*myReLU->getOperator()->getOutput(0) == *expectedOutput);
+ REQUIRE(*op->getOutput(0) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ReduceMeanImpl.cpp b/unit_tests/operator/Test_ReduceMeanImpl.cpp
index 918e7f4857b726aea2f5a5db6b84d5bdf61baceb..ff21fc63ede6d89e85daa05bad1e08c944ce63cb 100644
--- a/unit_tests/operator/Test_ReduceMeanImpl.cpp
+++ b/unit_tests/operator/Test_ReduceMeanImpl.cpp
@@ -48,14 +48,15 @@ TEST_CASE("[cpu/operator] ReduceMean(forward)") {
});
std::shared_ptr<Node> myReduceMean = ReduceMean({1}, 1);
- myReduceMean->getOperator()->setDatatype(DataType::Float32);
- myReduceMean->getOperator()->setBackend("cpu");
- myReduceMean->getOperator()->associateInput(0,myInput);
- myReduceMean->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
+ op->associateInput(0,myInput);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReduceMean->forward();
- myReduceMean->getOperator()->getOutput(0)->print();
+ op->getOutput(0)->print();
- REQUIRE(*(myReduceMean->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("not_KeepDims") {
std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array3D<float,3,2,2> {
@@ -83,14 +84,15 @@ TEST_CASE("[cpu/operator] ReduceMean(forward)") {
});
std::shared_ptr<Node> myReduceMean = ReduceMean({1}, 0);
- myReduceMean->getOperator()->setDatatype(DataType::Float32);
- myReduceMean->getOperator()->setBackend("cpu");
- myReduceMean->getOperator()->associateInput(0,myInput);
- myReduceMean->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
+ op->associateInput(0,myInput);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReduceMean->forward();
- myReduceMean->getOperator()->getOutput(0)->print();
+ op->getOutput(0)->print();
- REQUIRE(*(myReduceMean->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
SECTION("all_axes") {
@@ -119,13 +121,14 @@ TEST_CASE("[cpu/operator] ReduceMean(forward)") {
});
std::shared_ptr<Node> myReduceMean = ReduceMean({0, 1, 2});
- myReduceMean->getOperator()->setDatatype(DataType::Float32);
- myReduceMean->getOperator()->setBackend("cpu");
- myReduceMean->getOperator()->associateInput(0,myInput);
- myReduceMean->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReduceMean -> getOperator());
+ op->associateInput(0,myInput);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReduceMean->forward();
- myReduceMean->getOperator()->getOutput(0)->print();
+ op->getOutput(0)->print();
- REQUIRE(*(myReduceMean->getOperator()->getOutput(0)) == *myOutput);
+ REQUIRE(*(op->getOutput(0)) == *myOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_ReshapeImpl.cpp b/unit_tests/operator/Test_ReshapeImpl.cpp
index b978367da861c8ea87a182de011d7ef4b9188c9c..af0f4476cafc59d26ab7a17875578385173b672c 100644
--- a/unit_tests/operator/Test_ReshapeImpl.cpp
+++ b/unit_tests/operator/Test_ReshapeImpl.cpp
@@ -34,14 +34,15 @@ TEST_CASE("[cpu/operator] Reshape(forward)") {
});
std::shared_ptr<Node> myReshape = Reshape();
- myReshape->getOperator()->setDatatype(DataType::Float32);
- myReshape->getOperator()->setBackend("cpu");
- myReshape->getOperator()->associateInput(0, input);
- myReshape->getOperator()->associateInput(1, shape);
- myReshape->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReshape -> getOperator());
+ op->associateInput(0, input);
+ op->associateInput(1, shape);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReshape->forward();
- REQUIRE(*(myReshape->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("2D Tensor") {
std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<float,2,3> {
@@ -61,13 +62,14 @@ TEST_CASE("[cpu/operator] Reshape(forward)") {
});
std::shared_ptr<Node> myReshape = Reshape();
- myReshape->getOperator()->setDatatype(DataType::Float32);
- myReshape->getOperator()->setBackend("cpu");
- myReshape->getOperator()->associateInput(0, input);
- myReshape->getOperator()->associateInput(1, shape);
- myReshape->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myReshape -> getOperator());
+ op->associateInput(0, input);
+ op->associateInput(1, shape);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myReshape->forward();
- REQUIRE(*(myReshape->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_SliceImpl.cpp b/unit_tests/operator/Test_SliceImpl.cpp
index 57344666ac07088df2096f3cfbe821df11cb50ec..e9392d3a01dabf427813b653916a79f07093c41d 100644
--- a/unit_tests/operator/Test_SliceImpl.cpp
+++ b/unit_tests/operator/Test_SliceImpl.cpp
@@ -39,16 +39,17 @@ TEST_CASE("[cpu/operator] Slice(forward)") {
});
std::shared_ptr<Node> mySlice = Slice();
- mySlice->getOperator()->setDatatype(DataType::Int32);
- mySlice->getOperator()->setBackend("cpu");
- mySlice->getOperator()->associateInput(0, input);
- mySlice->getOperator()->associateInput(1, axes);
- mySlice->getOperator()->associateInput(2, starts);
- mySlice->getOperator()->associateInput(3, ends);
- mySlice->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
+ op->associateInput(0, input);
+ op->associateInput(1, axes);
+ op->associateInput(2, starts);
+ op->associateInput(3, ends);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
mySlice->forward();
- REQUIRE(*(mySlice->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
SECTION("3D Tensor") {
@@ -87,15 +88,16 @@ TEST_CASE("[cpu/operator] Slice(forward)") {
});
std::shared_ptr<Node> mySlice = Slice();
- mySlice->getOperator()->setDatatype(DataType::Int32);
- mySlice->getOperator()->setBackend("cpu");
- mySlice->getOperator()->associateInput(0, input);
- mySlice->getOperator()->associateInput(1, axes);
- mySlice->getOperator()->associateInput(2, starts);
- mySlice->getOperator()->associateInput(3, ends);
- mySlice->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(mySlice -> getOperator());
+ op->associateInput(0, input);
+ op->associateInput(1, axes);
+ op->associateInput(2, starts);
+ op->associateInput(3, ends);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
mySlice->forward();
- REQUIRE(*(mySlice->getOperator()->getOutput(0)) == *expectedOutput);
+ REQUIRE(*(op->getOutput(0)) == *expectedOutput);
}
}
\ No newline at end of file
diff --git a/unit_tests/operator/Test_SoftmaxImpl.cpp b/unit_tests/operator/Test_SoftmaxImpl.cpp
index 81b737867123b44d291b77501ceb9bb5fb46d04f..7459a45e48cad74e722dc881e4653d34b7f549d0 100644
--- a/unit_tests/operator/Test_SoftmaxImpl.cpp
+++ b/unit_tests/operator/Test_SoftmaxImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Softmax(forward)") {
+TEST_CASE("[cpu/operator] Softmax(forward)", "[Softmax][CPU]") {
SECTION("2D Tensor") {
std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<float,2,10> {
{
@@ -40,13 +40,14 @@ TEST_CASE("[cpu/operator] Softmax(forward)") {
});
std::shared_ptr<Node> mySoftmax = Softmax(1);
- mySoftmax->getOperator()->setDatatype(DataType::Float32);
- mySoftmax->getOperator()->setBackend("cpu");
- mySoftmax->getOperator()->associateInput(0,input);
- mySoftmax->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(mySoftmax -> getOperator());
+ op->associateInput(0,input);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
mySoftmax->forward();
- float* resPtr = static_cast<float*>(mySoftmax->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -108,13 +109,14 @@ TEST_CASE("[cpu/operator] Softmax(forward)") {
});
std::shared_ptr<Node> mySoftmax = Softmax(1);
- mySoftmax->getOperator()->setDatatype(DataType::Float32);
- mySoftmax->getOperator()->setBackend("cpu");
- mySoftmax->getOperator()->associateInput(0,input);
- mySoftmax->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(mySoftmax -> getOperator());
+ op->associateInput(0,input);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
mySoftmax->forward();
- float* resPtr = static_cast<float*>(mySoftmax->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< expectedOutput->size(); ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_SqrtImpl.cpp b/unit_tests/operator/Test_SqrtImpl.cpp
index cf17499aba50359547218adc6b3938176e729ed3..653ecf0d04907ad8f7887e79cf149d79b37a9bbc 100644
--- a/unit_tests/operator/Test_SqrtImpl.cpp
+++ b/unit_tests/operator/Test_SqrtImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Sqrt(forward)") {
+TEST_CASE("[cpu/operator] Sqrt(forward)", "[Sqrt][CPU]") {
SECTION("2D Tensor") {
std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -36,13 +36,14 @@ TEST_CASE("[cpu/operator] Sqrt(forward)") {
});
std::shared_ptr<Node> mySqrt = Sqrt();
- mySqrt->getOperator()->setDatatype(DataType::Float32);
- mySqrt->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySqrt -> getOperator());
mySqrt->getOperator()->associateInput(0,input);
- mySqrt->getOperator()->computeOutputDims();
+ mySqrt->getOperator()->setDataType(DataType::Float32);
+ mySqrt->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySqrt->forward();
- float* resPtr = static_cast<float*>(mySqrt->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -106,13 +107,14 @@ TEST_CASE("[cpu/operator] Sqrt(forward)") {
});
std::shared_ptr<Node> mySqrt = Sqrt();
- mySqrt->getOperator()->setDatatype(DataType::Float32);
- mySqrt->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySqrt -> getOperator());
mySqrt->getOperator()->associateInput(0,input);
- mySqrt->getOperator()->computeOutputDims();
+ mySqrt->getOperator()->setDataType(DataType::Float32);
+ mySqrt->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySqrt->forward();
- float* resPtr = static_cast<float*>(mySqrt->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 54; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_SubImpl.cpp b/unit_tests/operator/Test_SubImpl.cpp
index d741602cf02958a88bb41bbd2927577027acb069..dfd64078b77a557e07eb11cb958ac24eeb1f9aa3 100644
--- a/unit_tests/operator/Test_SubImpl.cpp
+++ b/unit_tests/operator/Test_SubImpl.cpp
@@ -20,7 +20,7 @@
using namespace Aidge;
-TEST_CASE("[cpu/operator] Sub(forward)") {
+TEST_CASE("[cpu/operator] Sub(forward)", "[Sub][CPU]") {
SECTION("2D Tensor by Singleton") {
std::shared_ptr<Tensor> input_1 = std::make_shared<Tensor>(Array2D<float,2,2> {
{
@@ -37,14 +37,15 @@ TEST_CASE("[cpu/operator] Sub(forward)") {
});
std::shared_ptr<Node> mySub = Sub();
- mySub->getOperator()->setDatatype(DataType::Float32);
- mySub->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySub -> getOperator());
mySub->getOperator()->associateInput(0, input_1);
mySub->getOperator()->associateInput(1, input_2);
- mySub->getOperator()->computeOutputDims();
+ mySub->getOperator()->setDataType(DataType::Float32);
+ mySub->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySub->forward();
- float* resPtr = static_cast<float*>(mySub->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -73,14 +74,15 @@ TEST_CASE("[cpu/operator] Sub(forward)") {
});
std::shared_ptr<Node> mySub = Sub();
- mySub->getOperator()->setDatatype(DataType::Float32);
- mySub->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySub -> getOperator());
mySub->getOperator()->associateInput(0, input_1);
mySub->getOperator()->associateInput(1, input_2);
- mySub->getOperator()->computeOutputDims();
+ mySub->getOperator()->setDataType(DataType::Float32);
+ mySub->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySub->forward();
- float* resPtr = static_cast<float*>(mySub->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 4; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
@@ -112,14 +114,15 @@ TEST_CASE("[cpu/operator] Sub(forward)") {
});
std::shared_ptr<Node> mySub = Sub();
- mySub->getOperator()->setDatatype(DataType::Float32);
- mySub->getOperator()->setBackend("cpu");
+ auto op = std::static_pointer_cast<OperatorTensor>(mySub -> getOperator());
mySub->getOperator()->associateInput(0, input_1);
mySub->getOperator()->associateInput(1, input_2);
- mySub->getOperator()->computeOutputDims();
+ mySub->getOperator()->setDataType(DataType::Float32);
+ mySub->getOperator()->setBackend("cpu");
+ op->computeOutputDims();
mySub->forward();
- float* resPtr = static_cast<float*>(mySub->getOperator()->getOutput(0)->getImpl()->rawPtr());
+ float* resPtr = static_cast<float*>(op->getOutput(0)->getImpl()->rawPtr());
float* expectedPtr = static_cast<float*>(expectedOutput->getImpl()->rawPtr());
for (std::size_t i = 0; i< 12; ++i) {
REQUIRE(std::abs(resPtr[i]-expectedPtr[i]) < 0.00001);
diff --git a/unit_tests/operator/Test_TransposeImpl.cpp b/unit_tests/operator/Test_TransposeImpl.cpp
index 5ec38e52a84d0c7d2693f52e1cc0d3851cb09946..d381faadd7750f6a9a48fe9371f98e813b94a310 100644
--- a/unit_tests/operator/Test_TransposeImpl.cpp
+++ b/unit_tests/operator/Test_TransposeImpl.cpp
@@ -46,13 +46,14 @@ TEST_CASE("[cpu/operator] Transpose(forward)") {
}
});
std::shared_ptr<Node> myTranspose = Transpose<3>(std::array<DimSize_t,3>{{0,2,1}});
- myTranspose->getOperator()->setDatatype(DataType::Float32);
- myTranspose->getOperator()->setBackend("cpu");
- myTranspose->getOperator()->associateInput(0,input);
- myTranspose->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myTranspose -> getOperator());
+ op->associateInput(0,input);
+ op->setDataType(DataType::Float32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myTranspose->forward();
- REQUIRE(*(myTranspose->getOperator()->getOutput(0)) == *output);
+ REQUIRE(*(op->getOutput(0)) == *output);
}
SECTION("4D Tensor") {
std::shared_ptr<Tensor> input = std::make_shared<Tensor>(Array4D<int,2,3,1,4> {
@@ -114,12 +115,13 @@ TEST_CASE("[cpu/operator] Transpose(forward)") {
}
});
std::shared_ptr<Node> myTranspose = Transpose<4>(std::array<DimSize_t,4>{{0,3,2,1}});
- myTranspose->getOperator()->setDatatype(DataType::Int32);
- myTranspose->getOperator()->setBackend("cpu");
- myTranspose->getOperator()->associateInput(0,input);
- myTranspose->getOperator()->computeOutputDims();
+ auto op = std::static_pointer_cast<OperatorTensor>(myTranspose -> getOperator());
+ op->associateInput(0,input);
+ op->setDataType(DataType::Int32);
+ op->setBackend("cpu");
+ op->computeOutputDims();
myTranspose->forward();
- REQUIRE(*(myTranspose->getOperator()->getOutput(0)) == *output);
+ REQUIRE(*(op->getOutput(0)) == *output);
}
}
\ No newline at end of file
diff --git a/unit_tests/scheduler/Test_Scheduler.cpp b/unit_tests/scheduler/Test_Scheduler.cpp
index 78ab8d5b149e8f702558658fef0442f225de3813..8ea8e726f286035a1059a317471b893ce4639251 100644
--- a/unit_tests/scheduler/Test_Scheduler.cpp
+++ b/unit_tests/scheduler/Test_Scheduler.cpp
@@ -50,13 +50,11 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
Conv(1, 3, {3, 3}, "conv1"),
Conv(3, 4, {1, 1}, "conv2"),
Conv(4, 3, {1, 1}, "conv3"),
- FC(5, false, "fc")});
- g->setDatatype(Aidge::DataType::Int32);
- g->setBackend("cpu");
+ FC(27, 5, false, "fc")});
- g->getNode("conv1")->getOperator()->input(0) = *inputTensor;
- g->getNode("conv1")->getOperator()->input(1) = *weight1;
- g->getNode("conv1")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1")->getOperator()->setInput(0, inputTensor);
+ g->getNode("conv1")->getOperator()->setInput(1, weight1);
+ g->getNode("conv1")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> weight2 =
std::make_shared<Tensor>(Array4D<int, 4, 3, 1, 1>{{{{{1}}, {{2}}, {{3}}},
@@ -64,8 +62,8 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{{{7}}, {{8}}, {{9}}},
{{{10}}, {{11}}, {{12}}}}});
std::shared_ptr<Tensor> bias2 = std::make_shared<Tensor>(Array1D<int, 4>{{1, 2, 3, 4}});
- g->getNode("conv2")->getOperator()->input(1) = *weight2;
- g->getNode("conv2")->getOperator()->input(2) = *bias2;
+ g->getNode("conv2")->getOperator()->setInput(1, weight2);
+ g->getNode("conv2")->getOperator()->setInput(2, bias2);
// *(g->getNode("conv2")->getOperator()->input(1, weight2);
std::shared_ptr<Tensor> weight3 = std::make_shared<Tensor>(
@@ -73,8 +71,8 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{{{5}}, {{6}}, {{7}}, {{8}}},
{{{9}}, {{10}}, {{11}}, {{12}}}}});
std::shared_ptr<Tensor> bias3 = std::make_shared<Tensor>(Array1D<int, 3>{{1, 2, 3}});
- g->getNode("conv3")->getOperator()->input(1) = *weight3;
- g->getNode("conv3")->getOperator()->input(2) = *bias3;
+ g->getNode("conv3")->getOperator()->setInput(1, weight3);
+ g->getNode("conv3")->getOperator()->setInput(2, bias3);
std::shared_ptr<Tensor> weightfc = std::make_shared<Tensor>(
Array2D<int, 5, 27>{{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
@@ -88,10 +86,12 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}}});
std::shared_ptr<Tensor> biasfc = std::make_shared<Tensor>(Array1D<int, 5>{{1, 2, 3, 4, 5}});
- g->getNode("fc")->getOperator()->input(1) = *weightfc;
- g->getNode("fc")->getOperator()->input(2) = *biasfc;
+ g->getNode("fc")->getOperator()->setInput(1, weightfc);
+ g->getNode("fc")->getOperator()->setInput(2, biasfc);
// input->addChild(g);
+ g->setDataType(Aidge::DataType::Int32);
+ g->setBackend("cpu");
g->forwardDims();
SequentialScheduler scheduler(g);
REQUIRE_NOTHROW(scheduler.forward());
@@ -126,17 +126,17 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
Tensor expectedOutput4 = Array2D<int, 2, 5>{
{{205050376, 198925904, 181355097, 196978090, 238868348},
{598467376, 561797804, 560823897, 593043790, 698672948}}};
- Tensor other1 = g->getNode("conv1")->getOperator()->output(0);
- bool equal1 = (other1 == *expectedOutput1);
+ std::shared_ptr<Tensor> other1 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv1")->getOperator())->getOutput(0);
+ bool equal1 = (*other1 == *expectedOutput1);
REQUIRE(equal1);
- Tensor other2 = g->getNode("conv2")->getOperator()->output(0);
- bool equal2 = (other2 == *expectedOutput2);
+ std::shared_ptr<Tensor> other2 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv2")->getOperator())->getOutput(0);
+ bool equal2 = (*other2 == *expectedOutput2);
REQUIRE(equal2);
- Tensor other3 = g->getNode("conv3")->getOperator()->output(0);
- bool equal3 = (other3 == *expectedOutput3);
+ std::shared_ptr<Tensor> other3 = std::static_pointer_cast<OperatorTensor>(g->getNode("conv3")->getOperator())->getOutput(0);
+ bool equal3 = (*other3 == *expectedOutput3);
REQUIRE(equal3);
- Tensor other4 = g->getNode("fc")->getOperator()->output(0);
- bool equal4 = (other4 == expectedOutput4);
+ std::shared_ptr<Tensor> other4 = std::static_pointer_cast<OperatorTensor>(g->getNode("fc")->getOperator())->getOutput(0);
+ bool equal4 = (*other4 == expectedOutput4);
REQUIRE(equal4);
}
@@ -147,36 +147,34 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
Conv(3, 3, {1, 1}, "conv1.1"),
Conv(3, 3, {1, 1}, "conv1.2"),
Conv(3, 3, {1, 1}, "conv1.3")}),
- Add<3>("add1"),
+ Add(3, "add1"),
Conv(3, 2, {1, 1}, "conv2"),
- FC(5, false, "out")});
- g->setBackend("cpu");
- g->setDatatype(Aidge::DataType::Int32);
+ FC(18, 5, false, "out")});
- g->getNode("inputConv")->getOperator()->input(0) = *inputTensor;
- g->getNode("inputConv")->getOperator()->input(1) = *weight1;
- g->getNode("inputConv")->getOperator()->input(2) = *bias1;
+ g->getNode("inputConv")->getOperator()->setInput(0, inputTensor);
+ g->getNode("inputConv")->getOperator()->setInput(1, weight1);
+ g->getNode("inputConv")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv11Weight = std::make_shared<Tensor>(Array4D<int, 3, 3, 1, 1>{
{{{{1}}, {{2}}, {{3}}}, {{{4}}, {{5}}, {{6}}}, {{{7}}, {{8}}, {{9}}}}});
- g->getNode("conv1.1")->getOperator()->input(1) = *conv11Weight;
- g->getNode("conv1.1")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1.1")->getOperator()->setInput(1, conv11Weight);
+ g->getNode("conv1.1")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv12Weight = std::make_shared<Tensor>(Array4D<int, 3, 3, 1, 1>{
{{{{11}}, {{12}}, {{13}}}, {{{14}}, {{15}}, {{16}}}, {{{17}}, {{18}}, {{19}}}}});
- g->getNode("conv1.2")->getOperator()->input(1) = *conv12Weight;
- g->getNode("conv1.2")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1.2")->getOperator()->setInput(1, conv12Weight);
+ g->getNode("conv1.2")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv13Weight = std::make_shared<Tensor>(Array4D<int, 3, 3, 1, 1>{
{{{{21}}, {{22}}, {{23}}}, {{{24}}, {{25}}, {{26}}}, {{{27}}, {{28}}, {{29}}}}});
- g->getNode("conv1.3")->getOperator()->input(1) = *conv13Weight;
- g->getNode("conv1.3")->getOperator()->input(2) = *bias1;
+ g->getNode("conv1.3")->getOperator()->setInput(1, conv13Weight);
+ g->getNode("conv1.3")->getOperator()->setInput(2, bias1);
std::shared_ptr<Tensor> conv2Weight = std::make_shared<Tensor>(
Array4D<int, 2, 3, 1, 1>{{{{{1}}, {{2}}, {{3}}}, {{{4}}, {{5}}, {{6}}}}});
std::shared_ptr<Tensor> bias2 = std::make_shared<Tensor>(Array1D<int, 2>{{1, 2}});
- g->getNode("conv2")->getOperator()->input(1) = *conv2Weight;
- g->getNode("conv2")->getOperator()->input(2) = *bias2;
+ g->getNode("conv2")->getOperator()->setInput(1, conv2Weight);
+ g->getNode("conv2")->getOperator()->setInput(2, bias2);
std::shared_ptr<Tensor> fcWeight = std::make_shared<Tensor>(
Array2D<int, 5, 18>{{{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3},
@@ -185,19 +183,21 @@ TEST_CASE("[cpu/scheduler] SequentialScheduler(forward)") {
{5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2},
{3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5}}});
std::shared_ptr<Tensor> fcBias = std::make_shared<Tensor>(Array1D<int, 5>{{1, 2, 3, 4, 5}});
- g->getNode("out")->getOperator()->input(1) = *fcWeight;
- g->getNode("out")->getOperator()->input(2) = *fcBias;
+ g->getNode("out")->getOperator()->setInput(1, fcWeight);
+ g->getNode("out")->getOperator()->setInput(2, fcBias);
std::shared_ptr<Tensor> expectedOutput = std::make_shared<Tensor>(
Array2D<int, 2, 5>{{{124324368, 130692907, 133325056, 125044620, 142843879},
{369195468, 394615207, 382643056, 379441320, 416291779}}});
+ g->setBackend("cpu");
+ g->setDataType(Aidge::DataType::Int32);
g->forwardDims();
SequentialScheduler scheduler(g);
REQUIRE_NOTHROW(scheduler.forward());
scheduler.saveSchedulingDiagram("schedulingSequential");
std::shared_ptr<Tensor> result =
- std::static_pointer_cast<Tensor>(g->getNode("out")->getOperator()->getOutput(0));
+ std::static_pointer_cast<Tensor>(g->getNode("out")->getOperator()->getRawOutput(0));
bool equal = (*result == *expectedOutput);
REQUIRE(equal);
}