sunwen/Aurora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add sum,mean, sort to function2D

Browse Source
This commit is contained in:
kradchen
2023-12-07 14:03:17 +08:00
parent 6f32a05ee0
commit cdf4777dbe
4 changed files with 744 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

423
test/Function2D_Cuda_Test.cpp
View File

@@ -1,5 +1,6 @@
#include <gtest/gtest.h>
#include <chrono>
#include "AuroraDefs.h"
#include "CudaMatrix.h"
#include "Function.h"
#include "Matrix.h"
@@ -30,21 +31,19 @@ protected:
TEST_F(Function2D_Cuda_Test, min)
{
// big data for test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
{
float *dataB = Aurora::random(4096*41472);
B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -54,16 +53,11 @@ TEST_F(Function2D_Cuda_Test, min)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::min(B, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::min(dB, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -73,21 +67,20 @@ TEST_F(Function2D_Cuda_Test, min)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// different size speed
// Aurora::Matrix Aurora::min(const Aurora::Matrix &aMatrix,
// Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
// in col wise
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -98,16 +91,11 @@ TEST_F(Function2D_Cuda_Test, min)
}
B.forceReshape( 111,3157, 1);
dB = B.toDeviceMatrix();
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -117,6 +105,8 @@ TEST_F(Function2D_Cuda_Test, min)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, float aValue)
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
@@ -125,14 +115,10 @@ TEST_F(Function2D_Cuda_Test, min)
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, 500.5f);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, 500.5f);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -142,6 +128,10 @@ TEST_F(Function2D_Cuda_Test, min)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// const Aurora::Matrix &aOther)
// with same size matrix
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157*111);
@@ -151,17 +141,11 @@ TEST_F(Function2D_Cuda_Test, min)
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -171,6 +155,10 @@ TEST_F(Function2D_Cuda_Test, min)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// const Aurora::Matrix &aOther)
// with col-vec and matrix
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157);
@@ -180,17 +168,11 @@ TEST_F(Function2D_Cuda_Test, min)
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -199,11 +181,9 @@ TEST_F(Function2D_Cuda_Test, min)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::min(dA, dB);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -213,6 +193,10 @@ TEST_F(Function2D_Cuda_Test, min)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// const Aurora::Matrix &aOther)
// with row-vec and matrix
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(111);
@@ -225,14 +209,9 @@ TEST_F(Function2D_Cuda_Test, min)
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -246,21 +225,18 @@ TEST_F(Function2D_Cuda_Test, min)
TEST_F(Function2D_Cuda_Test, max)
{
// big data for test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
{
float *dataB = Aurora::random(4096*41472);
B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -270,16 +246,10 @@ TEST_F(Function2D_Cuda_Test, max)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::max(B, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::max(dB, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -289,21 +259,20 @@ TEST_F(Function2D_Cuda_Test, max)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// different size speed
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
// in col wise
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -314,16 +283,11 @@ TEST_F(Function2D_Cuda_Test, max)
}
B.forceReshape( 111,3157, 1);
dB = B.toDeviceMatrix();
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -333,22 +297,18 @@ TEST_F(Function2D_Cuda_Test, max)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, float aValue)
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, 500.5f);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, 500.5f);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -358,6 +318,10 @@ TEST_F(Function2D_Cuda_Test, max)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// const Aurora::Matrix &aOther)
// with same size matrix
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157*111);
@@ -370,14 +334,9 @@ TEST_F(Function2D_Cuda_Test, max)
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -387,26 +346,23 @@ TEST_F(Function2D_Cuda_Test, max)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// const Aurora::Matrix &aOther)
// with col-vec and matrix
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157);
auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
// mat x vec
auto ret2 = Aurora::max(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -415,20 +371,20 @@ TEST_F(Function2D_Cuda_Test, max)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
// vec x mat
ret2 = Aurora::max(dA, dB);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
// test
// Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
// const Aurora::Matrix &aOther)
// with row-vec and matrix
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(111);
@@ -441,14 +397,20 @@ TEST_F(Function2D_Cuda_Test, max)
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
// mat x vec
auto ret2 = Aurora::max(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
//vec x mat
ret2 = Aurora::max(dA, dB);
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
@@ -458,4 +420,197 @@ TEST_F(Function2D_Cuda_Test, max)
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
}
TEST_F(Function2D_Cuda_Test, sum)
{
//
{
float *dataB = Aurora::random(4096*50000);
// float* dataB = new float[4096*50000];
// for (size_t i = 0; i < 4096*50000; i++)
// {
// dataB[i] = (float)(i/4096);
// }
B = Aurora::Matrix::fromRawData(dataB, 4096, 50000);
// B = Aurora::Matrix::fromRawData(dataB, 200, 200);
auto dD = B.toDeviceMatrix();
auto ret1 = Aurora::sum(B, Aurora::FunctionDirection::All);
auto ret2 = Aurora::sum(dD, Aurora::FunctionDirection::All);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
ret1 = Aurora::sum(B, Aurora::FunctionDirection::Column);
ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Column);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
}
ret1 = Aurora::sum(B, Aurora::FunctionDirection::Row);
ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Row);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
}
}
//complex type
{
float* dataB = new float[3000*2000*2];
for (size_t i = 0; i < 3000*4000; i++)
{
dataB[i] = i%2==0?2.0f:1.0f;
}
B = Aurora::Matrix::fromRawData(dataB,3000, 2000,1,Aurora::Complex);
auto dD = B.toDeviceMatrix();
auto ret1 = Aurora::sum(B, Aurora::FunctionDirection::All);
auto ret2 = Aurora::sum(dD, Aurora::FunctionDirection::All);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize()*2; i++)
{
EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
ret1 = Aurora::sum(B, Aurora::FunctionDirection::Column);
ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Column);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
}
ret1 = Aurora::sum(B, Aurora::FunctionDirection::Row);
ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Row);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
}
}
}
TEST_F(Function2D_Cuda_Test, mean)
{
//
{
float* dataB = new float[4096*500];
for (size_t i = 0; i < 4096*500; i++)
{
dataB[i] = (float)(i%2==0?1:0);
}
B = Aurora::Matrix::fromRawData(dataB, 4096, 500);
// B = Aurora::Matrix::fromRawData(dataB, 200, 200);
auto dD = B.toDeviceMatrix();
auto ret1 = Aurora::mean(B, Aurora::FunctionDirection::All);
auto ret2 = Aurora::mean(dD, Aurora::FunctionDirection::All);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
ret1 = Aurora::mean(B, Aurora::FunctionDirection::Column);
ret2 = Aurora::mean(dD, Aurora::FunctionDirection::Column);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
}
ret1 = Aurora::mean(B, Aurora::FunctionDirection::Row);
ret2 = Aurora::mean(dD, Aurora::FunctionDirection::Row);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
}
}
}
TEST_F(Function2D_Cuda_Test, sort)
{
//
{
float* dataB = Aurora::random(25000000);
B = Aurora::Matrix::fromRawData(dataB, 500, 500);
// B = Aurora::Matrix::fromRawData(dataB, 200, 200);
auto dD = B.toDeviceMatrix();
auto ret1 = Aurora::sort(B, Aurora::Column);
auto ret2 = Aurora::sort(dD,Aurora::Column);
EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
}