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

Add cuda matrix function1d function compare set

Browse Source
This commit is contained in:
kradchen
2023-11-28 09:46:11 +08:00
parent a598de6ea3
commit 7d879c17d4
4 changed files with 639 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@@ -1,13 +1,15 @@
cmake_minimum_required(VERSION 3.16)
project(Aurora)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(Aurora_USE_CUDA ON)
if (Aurora_USE_CUDA)
set(CMAKE_CUDA_COMPILER /usr/local/cuda/bin/nvcc)
enable_language(CUDA)
find_package(CUDAToolkit REQUIRED)
add_definitions(-DUSE_CUDA)
@@ -44,7 +46,7 @@ if (Aurora_USE_CUDA)
target_include_directories(Aurora PRIVATE ./src /usr/local/cuda/include)
set_target_properties(Aurora PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_compile_options(Aurora PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:
-arch=sm_75
-arch=sm_75 --expt-extended-lambda
>)
target_link_libraries(Aurora PRIVATE ${CUDA_RUNTIME_LIBRARY} CUDA::cufft CUDA::cudart)
endif(Aurora_USE_CUDA)
@@ -70,7 +72,7 @@ if (Aurora_USE_CUDA)
target_include_directories(Aurora_Test PRIVATE ./src /usr/local/cuda/include)
set_target_properties(Aurora_Test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_compile_options(Aurora_Test PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:
-arch=sm_75
-arch=sm_75 --expt-extended-lambda
>)
target_link_libraries(Aurora_Test PRIVATE ${CUDA_RUNTIME_LIBRARY} CUDA::cufft CUDA::cudart)
endif(Aurora_USE_CUDA)

267
src/Function1D.cu
View File

@@ -6,9 +6,12 @@
#include <thrust/device_vector.h>
#include <thrust/transform.h>
#include <thrust/iterator/constant_iterator.h>
#include <thrust/iterator/counting_iterator.h>
#include <thrust/complex.h>
#include <cuda_runtime.h>
using namespace Aurora;
using namespace thrust::placeholders;
namespace
{
@@ -247,7 +250,7 @@ CudaMatrix Aurora::abs(const CudaMatrix& aMatrix)
float* data = nullptr;
cudaMalloc((void**)&data, sizeof(float) * size);
int blocksPerGrid = (size + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK;
absKernel<<<blocksPerGrid, THREADS_PER_BLOCK>>>(aMatrix.getData(), data, size, aMatrix.isComplex());
absKernel<<<blocksPerGrid,THREADS_PER_BLOCK >>>(aMatrix.getData(), data, size, aMatrix.isComplex());
cudaDeviceSynchronize();
return Aurora::CudaMatrix::fromRawData(data, aMatrix.getDimSize(0), aMatrix.getDimSize(1), aMatrix.getDimSize(2));
}
@@ -313,6 +316,268 @@ CudaMatrix Aurora::sign(const CudaMatrix&& aMatrix)
return Aurora::CudaMatrix::fromRawData(data, aMatrix.getDimSize(0), aMatrix.getDimSize(1), aMatrix.getDimSize(2), aMatrix.getValueType());
}
void Aurora::compareSet(CudaMatrix& aValueMatrix,float compareValue, float newValue,CompareOp op)
{
switch (op)
{
case GT:
{
auto lambda = [=] __host__ __device__ (const float& x){
return x>compareValue?newValue:x;
};
thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
break;
}
case NG:{
auto lambda = [=] __host__ __device__ (const float& x){
return x<=compareValue?newValue:x;
};
thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
break;
}
case EQ:{
auto lambda = [=] __host__ __device__ (const float& x){
return x==compareValue?newValue:x;
};
thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
break;
}
case NE:{
auto lambda = [=] __host__ __device__ (const float& x){
return x!=compareValue?newValue:x;
};
thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
break;
}
case NL:{
auto lambda = [=] __host__ __device__ (const float& x){
return x>=compareValue?newValue:x;
};
thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
break;
}
case LT:{
auto lambda = [=] __host__ __device__ (const float& x){
return x<compareValue?newValue:x;
};
thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
break;
}
default:
break;
}
}
void Aurora::compareSet(CudaMatrix& aValueMatrix,CudaMatrix& aCompareMatrix,float compareValue, float newValue,CompareOp op){
switch (op)
{
case GT:
{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x>compareValue?newValue:y;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aValueMatrix.getDataSize(),
aValueMatrix.getData(), aValueMatrix.getData(),
lambda);
break;
}
case NG:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x<=compareValue?newValue:y;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aValueMatrix.getDataSize(),
aValueMatrix.getData(), aValueMatrix.getData(),
lambda);
break;
}
case EQ:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x==compareValue?newValue:y;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aValueMatrix.getDataSize(),
aValueMatrix.getData(), aValueMatrix.getData(),
lambda);
break;
}
case NE:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x!=compareValue?newValue:y;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aValueMatrix.getDataSize(),
aValueMatrix.getData(), aValueMatrix.getData(),
lambda);
break;
}
case NL:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x>=compareValue?newValue:y;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aValueMatrix.getDataSize(),
aValueMatrix.getData(), aValueMatrix.getData(),
lambda);
break;
}
case LT:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x<compareValue?newValue:y;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aValueMatrix.getDataSize(),
aValueMatrix.getData(), aValueMatrix.getData(),
lambda);
break;
}
default:
break;
}
}
void Aurora::compareSet(CudaMatrix& aDesAndCompareMatrix,CudaMatrix& aOtherCompareMatrix, float newValue,CompareOp op){
switch (op)
{
case GT:
{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x>y?newValue:x;
};
thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
lambda);
break;
}
case NG:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x<=y?newValue:x;
};
thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
lambda);
break;
}
case EQ:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x==y?newValue:x;
};
thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
lambda);
break;
}
case NE:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x!=y?newValue:x;
};
thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
lambda);
break;
}
case NL:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x>=y?newValue:x;
};
thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
lambda);
break;
}
case LT:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x<y?newValue:x;
};
thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
lambda);
break;
}
default:
break;
}
}
void Aurora::compareSet(CudaMatrix& aCompareMatrix,float compareValue, CudaMatrix& aNewValueMatrix,CompareOp op)
{
switch (op)
{
case GT:
{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x>compareValue?y:x;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
aNewValueMatrix.getData(), aCompareMatrix.getData(),
lambda);
break;
}
case NG:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x<=compareValue?y:x;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
aNewValueMatrix.getData(), aCompareMatrix.getData(),
lambda);
break;
}
case EQ:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x==compareValue?y:x;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
aNewValueMatrix.getData(), aCompareMatrix.getData(),
lambda);
break;
}
case NE:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x!=compareValue?y:x;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
aNewValueMatrix.getData(), aCompareMatrix.getData(),
lambda);
break;
}
case NL:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x>=compareValue?y:x;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
aNewValueMatrix.getData(), aCompareMatrix.getData(),
lambda);
break;
}
case LT:{
auto lambda = [=] __host__ __device__ (const float& x, const float& y){
return x<compareValue?y:x;
};
thrust::transform(thrust::device,aCompareMatrix.getData(),
aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
aNewValueMatrix.getData(), aCompareMatrix.getData(),
lambda);
break;
}
default:
break;
}
}
__global__ void repMatKernel(float* aInputData, float* aOutput, unsigned int aInputSize, bool aIsComplex)
{
unsigned int idX = blockIdx.x * blockDim.x + threadIdx.x;

13
src/Function1D.cuh
View File

@@ -2,6 +2,7 @@
#define AURORA_CUDA_FUNCTION1D_H
#include "CudaMatrix.h"
#include "Function1D.h"
namespace Aurora
{
@@ -33,6 +34,8 @@ namespace Aurora
CudaMatrix sqrt(const CudaMatrix&& aMatrix);
CudaMatrix abs(const CudaMatrix& aMatrix);
CudaMatrix abs2(const CudaMatrix& aMatrix);
CudaMatrix abs(const CudaMatrix&& aMatrix);
@@ -47,6 +50,16 @@ namespace Aurora
CudaMatrix repmat3d(const CudaMatrix& aMatrix,int aRowTimes, int aColumnTimes, int aSliceTimes);
CudaMatrix log(const CudaMatrix& aMatrix, int aBaseNum = -1);
// ------compareSet----------------------------------------------------
void compareSet(CudaMatrix& aValueMatrix,float compareValue, float newValue,CompareOp op);
void compareSet(CudaMatrix& aValueMatrix,CudaMatrix& aCompareMatrix,float compareValue, float newValue,CompareOp op);
void compareSet(CudaMatrix& aDesAndCompareMatrix,CudaMatrix& aOtherCompareMatrix, float newValue,CompareOp op);
void compareSet(CudaMatrix& aCompareMatrix,float compareValue, CudaMatrix& aNewValueMatrix,CompareOp op);
}
#endif //AURORA_CUDA_FUNCTION1D_H

357
test/Function1D_Cuda_Test.cpp
View File

@@ -173,24 +173,33 @@ TEST_F(Function1D_Cuda_Test, sqrt)
TEST_F(Function1D_Cuda_Test, abs)
{
Aurora::Matrix hostMatrix = Aurora::Matrix::fromRawData(new float[8]{1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8}, 2,4);
Aurora::Matrix hostMatrix = Aurora::Matrix::fromRawData(new float[10000]{0}, 1,10000);
for (size_t i = 0; i < 10000; i++)
{
hostMatrix[i]=i;
}
Aurora::CudaMatrix deviceMatrix = hostMatrix.toDeviceMatrix();
auto result1 = Aurora::abs(hostMatrix);
auto result2 = Aurora::abs(deviceMatrix).toHostMatrix();
EXPECT_EQ(result2.getDataSize(), 8);
// EXPECT_EQ(result2.getDataSize(), 8);
EXPECT_EQ(result2.getValueType(), Aurora::Normal);
for(size_t i=0; i<result1.getDataSize(); ++i)
{
EXPECT_EQ(result1[i], result2[i]);
}
hostMatrix = Aurora::Matrix::fromRawData(new float[8]{1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8}, 2,2,1,Aurora::Complex);
deviceMatrix = hostMatrix.toDeviceMatrix();
result1 = Aurora::abs(hostMatrix);
result2 = Aurora::abs(deviceMatrix).toHostMatrix();
EXPECT_EQ(result2.getDataSize(), 4);
EXPECT_EQ(result2.getValueType(), Aurora::Normal);
for(size_t i=0; i<result1.getDataSize() * result1.getValueType(); ++i)
{
EXPECT_EQ(result1[i], result2[i]);
@@ -294,3 +303,347 @@ TEST_F(Function1D_Cuda_Test, log)
EXPECT_FLOAT_AE(result1[i], result2[i]);
}
}
TEST_F(Function1D_Cuda_Test, compareSet)
{
Aurora::Matrix A =Aurora::Matrix::fromRawData(new float[9]{0},9,1);
Aurora::Matrix B =Aurora::Matrix::fromRawData(new float[9]{0},9,1);
for (int i = 0; i < 9; ++i) {
A[i]=(float)(i-3);
B[i]=(float)(i+2);
}
{
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,0,0,Aurora::LT);
compareSet(A,0,0,Aurora::LT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
{
Aurora::CudaMatrix dA = A.toDeviceMatrix();
auto A = dA.toHostMatrix();
compareSet(dA,0,0,Aurora::GT);
compareSet(A,0,0,Aurora::GT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
{
Aurora::CudaMatrix dA = A.toDeviceMatrix();
auto A = dA.toHostMatrix();
compareSet(dA,-1,0,Aurora::EQ);
compareSet(A,-1,0,Aurora::EQ);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
{
Aurora::CudaMatrix dA = A.toDeviceMatrix();
auto A = dA.toHostMatrix();
compareSet(dA,-1,0,Aurora::NE);
compareSet(A,-1,0,Aurora::NE);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
{
Aurora::CudaMatrix dA = A.toDeviceMatrix();
auto A = dA.toHostMatrix();
compareSet(dA,-1,0,Aurora::NL);
compareSet(A,-1,0,Aurora::NL);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
{
Aurora::CudaMatrix dA = A.toDeviceMatrix();
auto A = dA.toHostMatrix();
compareSet(dA,-1,0,Aurora::NG);
compareSet(A,-1,0,Aurora::NG);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//Function m m v v
//NE
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,4,-1,Aurora::NE);
compareSet(A,B,4,-1,Aurora::NE);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//EQ
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,4,-1,Aurora::EQ);
compareSet(A,B,4,-1,Aurora::EQ);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//GT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,1,-1,Aurora::GT);
compareSet(A,B,1,-1,Aurora::GT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,3,-1,Aurora::LT);
compareSet(A,B,3,-1,Aurora::LT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//NL
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,3,-1,Aurora::NL);
compareSet(A,B,3,-1,Aurora::NL);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,3,-1,Aurora::NG);
compareSet(A,B,3,-1,Aurora::NG);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//Function m m v
//NE
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,-1,Aurora::NE);
compareSet(A,B,-1,Aurora::NE);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//EQ
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,-1,Aurora::EQ);
compareSet(A,B,-1,Aurora::EQ);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//GT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,-1,Aurora::GT);
compareSet(A,B,-1,Aurora::GT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,-1,Aurora::LT);
compareSet(A,B,-1,Aurora::LT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//NL
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,-1,Aurora::NL);
compareSet(A,B,-1,Aurora::NL);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,-1,Aurora::NG);
compareSet(A,B,-1,Aurora::NG);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//Function m m v v
//NE
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,4,-1,Aurora::NE);
compareSet(A,B,4,-1,Aurora::NE);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//EQ
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,4,-1,Aurora::EQ);
compareSet(A,B,4,-1,Aurora::EQ);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//GT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,1,-1,Aurora::GT);
compareSet(A,B,1,-1,Aurora::GT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,3,-1,Aurora::LT);
compareSet(A,B,3,-1,Aurora::LT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//NL
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,3,-1,Aurora::NL);
compareSet(A,B,3,-1,Aurora::NL);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,dB,3,-1,Aurora::NG);
compareSet(A,B,3,-1,Aurora::NG);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//Function m v m
//NE
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,-1,dB,Aurora::NE);
compareSet(A,-1,B,Aurora::NE);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//EQ
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,-1,dB,Aurora::EQ);
compareSet(A,-1,B,Aurora::EQ);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//GT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,-1,dB,Aurora::GT);
compareSet(A,-1,B,Aurora::GT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,-1,dB,Aurora::LT);
compareSet(A,-1,B,Aurora::LT);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//NL
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,-1,dB,Aurora::NL);
compareSet(A,-1,B,Aurora::NL);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
//LT
{
Aurora::CudaMatrix dB = B.toDeviceMatrix();
Aurora::CudaMatrix dA = A.toDeviceMatrix();
compareSet(dA,-1,dB,Aurora::NG);
compareSet(A,-1,B,Aurora::NG);
for (size_t i = 0; i < 9; i++)
{
EXPECT_EQ(dA.getValue(i), A[i]);
}
}
}