Skip to content
Snippets Groups Projects
Commit 85388447 authored by Maxence Naud's avatar Maxence Naud
Browse files

Make includes right and remove 'iostream' for some more tests

parent 2a5a4255
No related branches found
No related tags found
1 merge request!132[UPD] version 0.4.1 -> 0.5.0
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 368 additions and 360 deletions
unit_tests/operator/Test_ConstantOfShapeImpl.cpp
+ 14
− 19
View file @ 85388447
...@@ -9,32 +9,27 @@ ...@@ -9,32 +9,27 @@
* *
********************************************************************************/ ********************************************************************************/
#include <algorithm> #include <chrono> // std::micro, std::chrono::time_point,
#include <chrono> // std::chrono::system_clock
#include <cmath> #include <cstddef> // std::size_t
#include <cstddef> // std::size_t #include <cstdint> // std::int64_t, std::uint16_t
#include <cstdint> // std::uint16_t
#include <iostream>
#include <memory> #include <memory>
#include <numeric> // std::accumulate #include <random> // std::random_device, std::mt19937
#include <ostream> // std::uniform_int_distribution, std::uniform_real_distribution
#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution #include <vector>
#include "catch2/internal/catch_compiler_capabilities.hpp"
#include "catch2/internal/catch_enforce.hpp"
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
#include <catch2/generators/catch_generators_random.hpp> #include <catch2/generators/catch_generators_random.hpp>
#include "aidge/backend/cpu/data/TensorImpl.hpp"
#include "aidge/backend/cpu/operator/ConstantOfShapeImpl.hpp"
#include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/filler/Filler.hpp"
#include "aidge/operator/ConstantOfShape.hpp" #include "aidge/operator/ConstantOfShape.hpp"
#include "aidge/operator/OperatorTensor.hpp"
#include "aidge/utils/TensorUtils.hpp" #include "aidge/utils/TensorUtils.hpp"
#include <aidge/data/Data.hpp> #include "aidge/utils/Types.h"
#include <aidge/data/half.hpp>
#include <aidge/filler/Filler.hpp>
#include <aidge/operator/OperatorTensor.hpp>
#include <aidge/operator/Reshape.hpp>
#include <aidge/utils/TensorUtils.hpp>
#include <aidge/utils/Types.h>
namespace Aidge { namespace Aidge {
TEST_CASE("[cpu/operator] ConstantOfShape", "[ConstantOfShape][CPU]") { TEST_CASE("[cpu/operator] ConstantOfShape", "[ConstantOfShape][CPU]") {
...@@ -62,7 +57,7 @@ TEST_CASE("[cpu/operator] ConstantOfShape", "[ConstantOfShape][CPU]") { ...@@ -62,7 +57,7 @@ TEST_CASE("[cpu/operator] ConstantOfShape", "[ConstantOfShape][CPU]") {
result->setDataType(DataType::Int64); result->setDataType(DataType::Int64);
result->setBackend("cpu"); result->setBackend("cpu");
for (DimSize_t i = 0; i < result->size(); ++i) { for (DimSize_t i = 0; i < result->size(); ++i) {
result->set<int64_t>(i, input_tensor_values_dist(gen)); result->set<std::int64_t>(i, input_tensor_values_dist(gen));
} }
return result; return result;
}; };
......
unit_tests/operator/Test_DivImpl.cpp
+ 22
− 13
View file @ 85388447
...@@ -9,17 +9,26 @@ ...@@ -9,17 +9,26 @@
* *
********************************************************************************/ ********************************************************************************/
#include <catch2/catch_test_macros.hpp> #include <chrono> // std::micro, std::chrono::time_point,
#include <cstddef> // std::size_t // std::chrono::system_clock
#include <cstdint> // std::uint16_t #include <cstddef> // std::size_t
#include <chrono> #include <cstdint> // std::uint16_t
#include <iostream> #include <functional> // std::multiplies
#include <memory> #include <memory>
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution #include <random> // std::random_device, std::mt19937
// std::uniform_int_distribution, std::uniform_real_distribution
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include "aidge/backend/cpu/data/TensorImpl.hpp"
#include "aidge/backend/cpu/operator/DivImpl.hpp"
#include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/operator/Div.hpp" #include "aidge/operator/Div.hpp"
#include "aidge/operator/OperatorTensor.hpp"
#include "aidge/utils/TensorUtils.hpp" #include "aidge/utils/TensorUtils.hpp"
namespace Aidge { namespace Aidge {
...@@ -117,8 +126,8 @@ TEST_CASE("[cpu/operator] Div", "[Div][CPU]") { ...@@ -117,8 +126,8 @@ TEST_CASE("[cpu/operator] Div", "[Div][CPU]") {
// with broadcasting // with broadcasting
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("+1-D Tensor / +1-D Tensor - broadcasting") { SECTION("+1-D Tensor / +1-D Tensor - broadcasting") {
...@@ -212,8 +221,8 @@ TEST_CASE("[cpu/operator] Div", "[Div][CPU]") { ...@@ -212,8 +221,8 @@ TEST_CASE("[cpu/operator] Div", "[Div][CPU]") {
const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>()); const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>());
number_of_operation += nb_elements; number_of_operation += nb_elements;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("+1-D Tensor / 1-D Tensor") { SECTION("+1-D Tensor / 1-D Tensor") {
std::size_t number_of_operation = 0; std::size_t number_of_operation = 0;
...@@ -308,8 +317,8 @@ TEST_CASE("[cpu/operator] Div", "[Div][CPU]") { ...@@ -308,8 +317,8 @@ TEST_CASE("[cpu/operator] Div", "[Div][CPU]") {
number_of_operation += nb_elements; number_of_operation += nb_elements;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
} }
} }
......
unit_tests/operator/Test_MatMulImpl.cpp
+ 19
− 14
View file @ 85388447
...@@ -9,21 +9,26 @@ ...@@ -9,21 +9,26 @@
* *
********************************************************************************/ ********************************************************************************/
#include <catch2/catch_test_macros.hpp> #include <chrono> // std::micro, std::chrono::time_point,
#include <cstddef> // std::size_t // std::chrono::system_clock, std::chrono::duration
#include <cstdint> // std::uint16_t #include <cstddef> // std::size_t
#include <chrono> #include <cstdint> // std::uint16_t
#include <iostream>
#include <memory> #include <memory>
#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution #include <random> // std::random_device, std::mt19937
// std::uniform_int_distribution, std::uniform_real_distribution
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include "aidge/backend/cpu/data/TensorImpl.hpp"
#include "aidge/backend/cpu/operator/MatMulImpl.hpp"
#include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/operator/MatMul.hpp" #include "aidge/operator/MatMul.hpp"
#include "aidge/operator/OperatorTensor.hpp" #include "aidge/operator/OperatorTensor.hpp"
#include "aidge/utils/TensorUtils.hpp" #include "aidge/utils/TensorUtils.hpp"
#include "aidge/backend/cpu/operator/MatMulImpl.hpp"
namespace Aidge { namespace Aidge {
TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") { TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
...@@ -106,8 +111,8 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") { ...@@ -106,8 +111,8 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
delete[] bigArray2; delete[] bigArray2;
delete[] res; delete[] res;
} }
std::cout << "multiplications over time spent: " << totalComputation/duration.count() << std::endl; fmt::print("INFO: number of multiplications over time spent: {}\n", (totalComputation / duration.count()));
std::cout << "total time: " << duration.count() << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("3-D Tensors") { SECTION("3-D Tensors") {
...@@ -174,8 +179,8 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") { ...@@ -174,8 +179,8 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
delete[] bigArray2; delete[] bigArray2;
delete[] res; delete[] res;
} }
std::cout << "multiplications over time spent: " << totalComputation/duration.count() << std::endl; fmt::print("INFO: number of multiplications over time spent: {}\n", (totalComputation / duration.count()));
std::cout << "total time: " << duration.count() << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("4-D Tensors") { SECTION("4-D Tensors") {
...@@ -244,8 +249,8 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") { ...@@ -244,8 +249,8 @@ TEST_CASE("[cpu/operator] MatMul(forward)", "[MatMul][CPU]") {
delete[] bigArray2; delete[] bigArray2;
delete[] res; delete[] res;
} }
std::cout << "multiplications over time spent: " << totalComputation/duration.count() << std::endl; fmt::print("INFO: number of multiplications over time spent: {}\n", (totalComputation / duration.count()));
std::cout << "total time: " << duration.count() << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("+2-D / 1-D") { SECTION("+2-D / 1-D") {
......
unit_tests/operator/Test_MulImpl.cpp
+ 240
− 254
View file @ 85388447
This diff is collapsed.
unit_tests/operator/Test_PowImpl.cpp
+ 28
− 25
View file @ 85388447
...@@ -9,18 +9,26 @@ ...@@ -9,18 +9,26 @@
* *
********************************************************************************/ ********************************************************************************/
#include <catch2/catch_test_macros.hpp> #include <chrono> // std::micro, std::chrono::time_point,
#include <cmath> // std::chrono::system_clock, std::chrono::duration
#include <cstddef> // std::size_t #include <cstddef> // std::size_t
#include <cstdint> // std::uint16_t #include <cstdint> // std::uint16_t
#include <chrono> #include <functional> // std::multiplies
#include <iostream>
#include <memory> #include <memory>
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution #include <random> // std::random_device, std::mt19937
// std::uniform_int_distribution, std::uniform_real_distribution
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include "aidge/backend/cpu/data/TensorImpl.hpp"
#include "aidge/backend/cpu/operator/PowImpl.hpp"
#include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/operator/Pow.hpp" #include "aidge/operator/Pow.hpp"
#include "aidge/utils/ArrayHelpers.hpp"
#include "aidge/utils/TensorUtils.hpp" #include "aidge/utils/TensorUtils.hpp"
namespace Aidge { namespace Aidge {
...@@ -118,8 +126,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") { ...@@ -118,8 +126,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") {
// with broadcasting // with broadcasting
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("+1-D Tensor / +1-D Tensor - broadcasting") { SECTION("+1-D Tensor / +1-D Tensor - broadcasting") {
...@@ -213,8 +221,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") { ...@@ -213,8 +221,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") {
const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>()); const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>());
number_of_operation += nb_elements; number_of_operation += nb_elements;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
SECTION("+1-D Tensor / 1-D Tensor") { SECTION("+1-D Tensor / 1-D Tensor") {
std::size_t number_of_operation = 0; std::size_t number_of_operation = 0;
...@@ -309,8 +317,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") { ...@@ -309,8 +317,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") {
number_of_operation += nb_elements; number_of_operation += nb_elements;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
} }
...@@ -440,7 +448,7 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") { ...@@ -440,7 +448,7 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") {
} }
} }
)); ));
const auto expectedGrad0 = std::make_shared<Tensor>(Array3D<float, 2, 2, 3>( const Tensor expectedGrad0 = Array3D<float, 2, 2, 3>(
{ {
{ {
{ {
...@@ -453,18 +461,13 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") { ...@@ -453,18 +461,13 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") {
} }
} }
} }
)); );
const auto expectedGrad1 = std::make_shared<Tensor>(Array1D<float, 3>( const Tensor expectedGrad1 = Array1D<float, 3>(
{ {
{14.14779854, 22.99299049, 33.56402588} {14.14779854, 22.99299049, 33.56402588}
} }
)); );
for(const auto T: {input0, input1, gradOut, expectedGrad0, expectedGrad1})
{
T->setBackend("cpu") ;
T->setDataType(DataType::Float32);
}
std::shared_ptr<Node> powOp = Pow(); std::shared_ptr<Node> powOp = Pow();
auto opr = std::static_pointer_cast<OperatorTensor>(powOp-> getOperator()); auto opr = std::static_pointer_cast<OperatorTensor>(powOp-> getOperator());
opr->setDataType(DataType::Float32); opr->setDataType(DataType::Float32);
...@@ -475,8 +478,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") { ...@@ -475,8 +478,8 @@ TEST_CASE("[cpu/operator] Pow", "[Pow][CPU]") {
powOp->forward(); powOp->forward();
powOp->backward(); powOp->backward();
REQUIRE(approxEq<float>(*(opr->getInput(0)->grad()), *expectedGrad0)); REQUIRE(approxEq<float>(*(opr->getInput(0)->grad()), expectedGrad0));
REQUIRE(approxEq<float>(*(opr->getInput(1)->grad()), *expectedGrad1)); REQUIRE(approxEq<float>(*(opr->getInput(1)->grad()), expectedGrad1));
} }
} }
} }
......
unit_tests/operator/Test_RoundImpl.cpp
+ 23
− 22
View file @ 85388447
...@@ -9,15 +9,23 @@ ...@@ -9,15 +9,23 @@
* *
********************************************************************************/ ********************************************************************************/
#include <catch2/catch_test_macros.hpp> #include <chrono> // std::micro, std::chrono::time_point,
#include <cstddef> // std::size_t // std::chrono::system_clock, std::chrono::duration
#include <cstdint> // std::uint16_t #include <cstddef> // std::size_t
#include <chrono> #include <cstdint> // std::uint16_t
#include <iostream> #include <functional> // std::multiplies
#include <memory> #include <memory>
#include <numeric> #include <numeric> // std::accumulate
#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution #include <random> // std::random_device, std::mt19937
#include <iomanip> // std::uniform_int_distribution, std::uniform_real_distribution
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include "aidge/backend/cpu/data/TensorImpl.hpp"
#include "aidge/backend/cpu/operator/RoundImpl.hpp"
#include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/operator/Round.hpp" #include "aidge/operator/Round.hpp"
#include "aidge/utils/TensorUtils.hpp" #include "aidge/utils/TensorUtils.hpp"
...@@ -29,7 +37,7 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") { ...@@ -29,7 +37,7 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") {
// Create a random number generator // Create a random number generator
std::random_device rd; std::random_device rd;
std::mt19937 gen(rd()); std::mt19937 gen(rd());
std::uniform_real_distribution<float> valueDist(-15, 15); std::uniform_real_distribution<float> valueDist(-15, 15);
std::uniform_int_distribution<std::size_t> dimSizeDist(std::size_t(2), std::size_t(5)); std::uniform_int_distribution<std::size_t> dimSizeDist(std::size_t(2), std::size_t(5));
std::uniform_int_distribution<std::size_t> nbDimsDist(std::size_t(1), std::size_t(3)); std::uniform_int_distribution<std::size_t> nbDimsDist(std::size_t(1), std::size_t(3));
...@@ -59,7 +67,7 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") { ...@@ -59,7 +67,7 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") {
std::size_t number_of_operation = 0; std::size_t number_of_operation = 0;
for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) { for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial) {
// generate 2 random Tensors // generate 2 random Tensors
const std::size_t nbDims = nbDimsDist(gen); const std::size_t nbDims = nbDimsDist(gen);
std::vector<std::size_t> dims; std::vector<std::size_t> dims;
...@@ -72,7 +80,7 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") { ...@@ -72,7 +80,7 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") {
// without broadcasting // without broadcasting
float* array0 = new float[nb_elements]; float* array0 = new float[nb_elements];
float* result = new float[nb_elements]; float* result = new float[nb_elements];
for (std::size_t i = 0; i < nb_elements; ++i) { for (std::size_t i = 0; i < nb_elements; ++i) {
array0[i] = valueDist(gen); array0[i] = valueDist(gen);
result[i] = std::nearbyint(array0[i]); result[i] = std::nearbyint(array0[i]);
...@@ -86,29 +94,22 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") { ...@@ -86,29 +94,22 @@ TEST_CASE("[cpu/operator] Round_Test", "[Round][CPU]") {
// results // results
Tres->resize(dims); Tres->resize(dims);
Tres -> getImpl() -> setRawPtr(result, nb_elements); Tres -> getImpl() -> setRawPtr(result, nb_elements);
op->forwardDims(); op->forwardDims();
start = std::chrono::system_clock::now(); start = std::chrono::system_clock::now();
myRound->forward(); myRound->forward();
end = std::chrono::system_clock::now(); end = std::chrono::system_clock::now();
duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start); duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
bool is_eq = approxEq<float>(*(op->getOutput(0)), *Tres); REQUIRE(approxEq<float>(*(op->getOutput(0)), *Tres));
auto Output = *(op->getOutput(0));
auto prt = Output.getImpl()->rawPtr();
REQUIRE(is_eq);
delete[] array0; delete[] array0;
delete[] result; delete[] result;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {} μs\n", duration.count());
} }
} }
} // namespace Aidge } // namespace Aidge
......
unit_tests/operator/Test_SubImpl.cpp
+ 22
− 13
View file @ 85388447
...@@ -9,17 +9,26 @@ ...@@ -9,17 +9,26 @@
* *
********************************************************************************/ ********************************************************************************/
#include <catch2/catch_test_macros.hpp> #include <chrono> // std::micro, std::chrono::time_point,
#include <cstddef> // std::size_t // std::chrono::system_clock
#include <cstdint> // std::uint16_t #include <cstddef> // std::size_t
#include <chrono> #include <cstdint> // std::uint16_t
#include <iostream> #include <functional> // std::multiplies
#include <memory> #include <memory>
#include <numeric> // std::accumulate #include <numeric> // std::accumulate
#include <random> // std::random_device, std::mt19937, std::uniform_real_distribution #include <random> // std::random_device, std::mt19937
// std::uniform_int_distribution, std::uniform_real_distribution
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include <fmt/core.h>
#include "aidge/backend/cpu/data/TensorImpl.hpp"
#include "aidge/backend/cpu/operator/SubImpl.hpp"
#include "aidge/data/Data.hpp"
#include "aidge/data/Tensor.hpp" #include "aidge/data/Tensor.hpp"
#include "aidge/operator/Sub.hpp" #include "aidge/operator/Sub.hpp"
#include "aidge/operator/OperatorTensor.hpp"
#include "aidge/utils/TensorUtils.hpp" #include "aidge/utils/TensorUtils.hpp"
namespace Aidge { namespace Aidge {
...@@ -117,8 +126,8 @@ TEST_CASE("[cpu/operator] Sub", "[Sub][CPU]") { ...@@ -117,8 +126,8 @@ TEST_CASE("[cpu/operator] Sub", "[Sub][CPU]") {
// with broadcasting // with broadcasting
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {}μs\n", duration.count());
} }
SECTION("+1-D Tensor / +1-D Tensor - broadcasting") { SECTION("+1-D Tensor / +1-D Tensor - broadcasting") {
...@@ -212,8 +221,8 @@ TEST_CASE("[cpu/operator] Sub", "[Sub][CPU]") { ...@@ -212,8 +221,8 @@ TEST_CASE("[cpu/operator] Sub", "[Sub][CPU]") {
const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>()); const std::size_t nb_elements = std::accumulate(dimsOut.cbegin(), dimsOut.cend(), std::size_t(1), std::multiplies<std::size_t>());
number_of_operation += nb_elements; number_of_operation += nb_elements;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {}μs\n", duration.count());
} }
SECTION("+1-D Tensor / 1-D Tensor") { SECTION("+1-D Tensor / 1-D Tensor") {
std::size_t number_of_operation = 0; std::size_t number_of_operation = 0;
...@@ -308,8 +317,8 @@ TEST_CASE("[cpu/operator] Sub", "[Sub][CPU]") { ...@@ -308,8 +317,8 @@ TEST_CASE("[cpu/operator] Sub", "[Sub][CPU]") {
number_of_operation += nb_elements; number_of_operation += nb_elements;
} }
std::cout << "number of elements over time spent: " << (number_of_operation / duration.count())<< std::endl; fmt::print("INFO: number of elements over time spent: {}\n", (number_of_operation / duration.count()));
std::cout << "total time: " << duration.count() << "μs" << std::endl; fmt::print("INFO: total time: {}μs\n", duration.count());
} }
} }
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

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