int run_test(double epsilon,
UBLASMatrixType & ublas_A, UBLASMatrixType & ublas_B, UBLASMatrixType & ublas_C,
ViennaCLMatrixType1 & vcl_A, ViennaCLMatrixType2 & vcl_B, ViennaCLMatrixType3 vcl_C)
{
typedef typename viennacl::result_of::cpu_value_type<typename ViennaCLMatrixType1::value_type>::type cpu_value_type;
cpu_value_type alpha = cpu_value_type(3.1415);
viennacl::scalar<cpu_value_type> gpu_alpha = alpha;
cpu_value_type beta = cpu_value_type(2.7182);
viennacl::scalar<cpu_value_type> gpu_beta = beta;
//
// Initializer:
//
std::cout << "Checking for zero_matrix initializer..." << std::endl;
ublas_A = ublas::zero_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2());
vcl_A = viennacl::zero_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2());
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Checking for scalar_matrix initializer..." << std::endl;
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), alpha);
vcl_A = viennacl::scalar_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2(), alpha);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), gpu_beta);
vcl_A = viennacl::scalar_matrix<cpu_value_type>( vcl_A.size1(), vcl_A.size2(), gpu_beta);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
/*std::cout << "Checking for identity initializer..." << std::endl;
ublas_A = ublas::identity_matrix<cpu_value_type>(ublas_A.size1());
vcl_A = viennacl::identity_matrix<cpu_value_type>(vcl_A.size1());
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;*/
std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test: Assignments //////////" << std::endl;
//std::cout << "//" << std::endl;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Testing matrix assignment... ";
//std::cout << ublas_B(0,0) << " vs. " << vcl_B(0,0) << std::endl;
ublas_A = ublas_B;
vcl_A = vcl_B;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
//std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 1: Copy to GPU //////////" << std::endl;
//std::cout << "//" << std::endl;
ublas_A = ublas_B;
viennacl::copy(ublas_B, vcl_A);
std::cout << "Testing upper left copy to GPU... ";
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_C = ublas_B;
viennacl::copy(ublas_B, vcl_C);
std::cout << "Testing lower right copy to GPU... ";
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 2: Copy from GPU //////////" << std::endl;
//std::cout << "//" << std::endl;
std::cout << "Testing upper left copy to A... ";
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Testing lower right copy to C... ";
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 3: Addition //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_C, vcl_C);
std::cout << "Assignment: ";
{
ublas_C = ublas_B;
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), vcl_B); // same as vcl_C = vcl_B;
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
}
std::cout << "Inplace add: ";
{
ublas_C += ublas_C;
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_inplace_add(), vcl_C); // same as vcl_C += vcl_C;
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
}
std::cout << "Inplace sub: ";
{
ublas_C -= ublas_C;
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_inplace_sub(), vcl_C); // same as vcl_C -= vcl_C;
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
}
std::cout << "Add: ";
{
ublas_C = ublas_A + ublas_B;
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), vcl_A + vcl_B); // same as vcl_C = vcl_A + vcl_B;
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
}
std::cout << "Sub: ";
{
ublas_C = ublas_A - ublas_B;
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), vcl_A - vcl_B); // same as vcl_C = vcl_A - vcl_B;
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
}
std::cout << "Composite assignments: ";
{
ublas_C += alpha * ublas_A - beta * ublas_B + ublas_A / beta - ublas_B / alpha;
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_inplace_add(), alpha * vcl_A - beta * vcl_B + vcl_A / beta - vcl_B / alpha); // same as vcl_C += alpha * vcl_A - beta * vcl_B + vcl_A / beta - vcl_B / alpha;
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
}
std::cout << "--- Testing elementwise operations (binary) ---" << std::endl;
std::cout << "x = element_prod(x, y)... ";
{
ublas_C = element_prod(ublas_A, ublas_B);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_prod(vcl_A, vcl_B));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_prod(x + y, y)... ";
{
ublas_C = element_prod(ublas_A + ublas_B, ublas_B);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_prod(x, x + y)... ";
{
ublas_C = element_prod(ublas_A, ublas_A + ublas_B);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_prod(x - y, y + x)... ";
{
ublas_C = element_prod(ublas_A - ublas_B, ublas_B + ublas_A);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_prod(vcl_A - vcl_B, vcl_B + vcl_A));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_div(x, y)... ";
{
ublas_C = element_div(ublas_A, ublas_B);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_div(vcl_A, vcl_B));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_div(x + y, y)... ";
{
ublas_C = element_div(ublas_A + ublas_B, ublas_B);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_div(x, x + y)... ";
{
ublas_C = element_div(ublas_A, ublas_A + ublas_B);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "x = element_div(x - y, y + x)... ";
{
ublas_C = element_div(ublas_A - ublas_B, ublas_B + ublas_A);
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_div(vcl_A - vcl_B, vcl_B + vcl_A));
viennacl::scheduler::execute(my_statement);
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS)
return EXIT_FAILURE;
}
std::cout << "--- Testing elementwise operations (unary) ---" << std::endl;
#define GENERATE_UNARY_OP_TEST(OPNAME) \
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), cpu_value_type(0.21)); \
ublas_B = cpu_value_type(3.1415) * ublas_A; \
viennacl::copy(ublas_A, vcl_A); \
viennacl::copy(ublas_B, vcl_B); \
{ \
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) = static_cast<cpu_value_type>(OPNAME(ublas_A(i,j))); \
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_##OPNAME(vcl_A)); \
viennacl::scheduler::execute(my_statement); \
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS) \
return EXIT_FAILURE; \
} \
{ \
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) = static_cast<cpu_value_type>(OPNAME(ublas_A(i,j) / cpu_value_type(2))); \
viennacl::scheduler::statement my_statement(vcl_C, viennacl::op_assign(), viennacl::linalg::element_##OPNAME(vcl_A / cpu_value_type(2))); \
viennacl::scheduler::execute(my_statement); \
if (!check_for_equality(ublas_C, vcl_C, epsilon) != EXIT_SUCCESS) \
return EXIT_FAILURE; \
}
GENERATE_UNARY_OP_TEST(cos);
GENERATE_UNARY_OP_TEST(cosh);
GENERATE_UNARY_OP_TEST(exp);
GENERATE_UNARY_OP_TEST(floor);
GENERATE_UNARY_OP_TEST(fabs);
GENERATE_UNARY_OP_TEST(log);
GENERATE_UNARY_OP_TEST(log10);
GENERATE_UNARY_OP_TEST(sin);
GENERATE_UNARY_OP_TEST(sinh);
GENERATE_UNARY_OP_TEST(fabs);
//GENERATE_UNARY_OP_TEST(abs); //OpenCL allows abs on integers only
GENERATE_UNARY_OP_TEST(sqrt);
GENERATE_UNARY_OP_TEST(tan);
GENERATE_UNARY_OP_TEST(tanh);
#undef GENERATE_UNARY_OP_TEST
std::cout << std::endl;
std::cout << "----------------------------------------------" << std::endl;
std::cout << std::endl;
return EXIT_SUCCESS;
}
int run_test(double epsilon,
UBLASMatrixType & ublas_A, UBLASMatrixType & ublas_B, UBLASMatrixType & ublas_C,
ViennaCLMatrixType1 & vcl_A, ViennaCLMatrixType2 & vcl_B, ViennaCLMatrixType3 vcl_C)
{
typedef typename viennacl::result_of::cpu_value_type<typename ViennaCLMatrixType1::value_type>::type cpu_value_type;
cpu_value_type alpha = 3.1415;
viennacl::scalar<cpu_value_type> gpu_alpha = alpha;
cpu_value_type beta = 2.7182;
viennacl::scalar<cpu_value_type> gpu_beta = beta;
//
// Initializer:
//
std::cout << "Checking for zero_matrix initializer..." << std::endl;
ublas_A = ublas::zero_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2());
vcl_A = viennacl::zero_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2());
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Checking for scalar_matrix initializer..." << std::endl;
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), alpha);
vcl_A = viennacl::scalar_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2(), alpha);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), gpu_beta);
vcl_A = viennacl::scalar_matrix<cpu_value_type>( vcl_A.size1(), vcl_A.size2(), gpu_beta);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
/*std::cout << "Checking for identity initializer..." << std::endl;
ublas_A = ublas::identity_matrix<cpu_value_type>(ublas_A.size1());
vcl_A = viennacl::identity_matrix<cpu_value_type>(vcl_A.size1());
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;*/
std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test: Assignments //////////" << std::endl;
//std::cout << "//" << std::endl;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Testing matrix assignment... ";
//std::cout << ublas_B(0,0) << " vs. " << vcl_B(0,0) << std::endl;
ublas_A = ublas_B;
vcl_A = vcl_B;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
//std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 1: Copy to GPU //////////" << std::endl;
//std::cout << "//" << std::endl;
ublas_A = ublas_B;
viennacl::copy(ublas_B, vcl_A);
std::cout << "Testing upper left copy to GPU... ";
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_C = ublas_B;
viennacl::copy(ublas_B, vcl_C);
std::cout << "Testing lower right copy to GPU... ";
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 2: Copy from GPU //////////" << std::endl;
//std::cout << "//" << std::endl;
std::cout << "Testing upper left copy to A... ";
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Testing lower right copy to C... ";
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 3: Addition //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_C, vcl_C);
std::cout << "Inplace add: ";
ublas_C += ublas_C;
vcl_C += vcl_C;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled inplace add: ";
ublas_C += beta * ublas_A;
vcl_C += gpu_beta * vcl_A;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Add: ";
ublas_C = ublas_A + ublas_B;
vcl_C = vcl_A + vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Add with flipsign: ";
ublas_C = - ublas_A + ublas_B;
vcl_C = - vcl_A + vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add (left): ";
ublas_C = alpha * ublas_A + ublas_B;
vcl_C = alpha * vcl_A + vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add (left): ";
vcl_C = gpu_alpha * vcl_A + vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add (right): ";
ublas_C = ublas_A + beta * ublas_B;
vcl_C = vcl_A + beta * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add (right): ";
vcl_C = vcl_A + gpu_beta * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add (both): ";
ublas_C = alpha * ublas_A + beta * ublas_B;
vcl_C = alpha * vcl_A + beta * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add (both): ";
vcl_C = gpu_alpha * vcl_A + gpu_beta * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 4: Subtraction //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_C, vcl_C);
std::cout << "Inplace sub: ";
ublas_C -= ublas_B;
vcl_C -= vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled Inplace sub: ";
ublas_C -= alpha * ublas_B;
vcl_C -= alpha * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Sub: ";
ublas_C = ublas_A - ublas_B;
vcl_C = vcl_A - vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub (left): ";
ublas_B = alpha * ublas_A - ublas_C;
vcl_B = alpha * vcl_A - vcl_C;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub (left): ";
vcl_B = gpu_alpha * vcl_A - vcl_C;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub (right): ";
ublas_B = ublas_A - beta * ublas_C;
vcl_B = vcl_A - vcl_C * beta;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub (right): ";
vcl_B = vcl_A - vcl_C * gpu_beta;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub (both): ";
ublas_B = alpha * ublas_A - beta * ublas_C;
vcl_B = alpha * vcl_A - vcl_C * beta;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub (both): ";
vcl_B = gpu_alpha * vcl_A - vcl_C * gpu_beta;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Unary operator-: ";
ublas_C = - ublas_A;
vcl_C = - vcl_A;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 5: Scaling //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_A, vcl_A);
std::cout << "Multiplication with CPU scalar: ";
ublas_A *= alpha;
vcl_A *= alpha;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Multiplication with GPU scalar: ";
ublas_A *= beta;
vcl_A *= gpu_beta;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Division with CPU scalar: ";
ublas_A /= alpha;
vcl_A /= alpha;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Division with GPU scalar: ";
ublas_A /= beta;
vcl_A /= gpu_beta;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Testing elementwise multiplication..." << std::endl;
ublas_B = ublas::scalar_matrix<cpu_value_type>(ublas_B.size1(), ublas_B.size2(), 1.4142);
ublas_A = 3.1415 * ublas_B;
viennacl::copy(ublas_A, vcl_A);
viennacl::copy(ublas_B, vcl_B);
viennacl::copy(ublas_B, vcl_B);
ublas_A = ublas::element_prod(ublas_A, ublas_B);
vcl_A = viennacl::linalg::element_prod(vcl_A, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_prod(ublas_A, ublas_B);
vcl_A += viennacl::linalg::element_prod(vcl_A, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_prod(ublas_A, ublas_B);
vcl_A -= viennacl::linalg::element_prod(vcl_A, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
///////
ublas_A = ublas::element_prod(ublas_A + ublas_B, ublas_B);
vcl_A = viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_prod(ublas_A + ublas_B, ublas_B);
vcl_A += viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_prod(ublas_A + ublas_B, ublas_B);
vcl_A -= viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
///////
ublas_A = ublas::element_prod(ublas_A, ublas_B + ublas_A);
vcl_A = viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_prod(ublas_A, ublas_B + ublas_A);
vcl_A += viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_prod(ublas_A, ublas_B + ublas_A);
vcl_A -= viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
///////
ublas_A = ublas::element_prod(ublas_A + ublas_B, ublas_B + ublas_A);
vcl_A = viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_prod(ublas_A + ublas_B, ublas_B + ublas_A);
vcl_A += viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_prod(ublas_A + ublas_B, ublas_B + ublas_A);
vcl_A -= viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_B = ublas::scalar_matrix<cpu_value_type>(ublas_B.size1(), ublas_B.size2(), 1.4142);
ublas_A = 3.1415 * ublas_B;
viennacl::copy(ublas_A, vcl_A);
viennacl::copy(ublas_B, vcl_B);
viennacl::copy(ublas_B, vcl_B);
ublas_A = ublas::element_div(ublas_A, ublas_B);
vcl_A = viennacl::linalg::element_div(vcl_A, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_div(ublas_A, ublas_B);
vcl_A += viennacl::linalg::element_div(vcl_A, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_div(ublas_A, ublas_B);
vcl_A -= viennacl::linalg::element_div(vcl_A, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
///////
ublas_A = ublas::element_div(ublas_A + ublas_B, ublas_B);
vcl_A = viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_div(ublas_A + ublas_B, ublas_B);
vcl_A += viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_div(ublas_A + ublas_B, ublas_B);
vcl_A -= viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
///////
ublas_A = ublas::element_div(ublas_A, ublas_B + ublas_A);
vcl_A = viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_div(ublas_A, ublas_B + ublas_A);
vcl_A += viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_div(ublas_A, ublas_B + ublas_A);
vcl_A -= viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
///////
ublas_A = ublas::element_div(ublas_A + ublas_B, ublas_B + ublas_A);
vcl_A = viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A += ublas::element_div(ublas_A + ublas_B, ublas_B + ublas_A);
vcl_A += viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A -= ublas::element_div(ublas_A + ublas_B, ublas_B + ublas_A);
vcl_A -= viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B + vcl_A);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Testing unary elementwise operations..." << std::endl;
#define GENERATE_UNARY_OP_TEST(FUNCNAME) \
ublas_B = ublas::scalar_matrix<cpu_value_type>(ublas_B.size1(), ublas_B.size2(), 1.4142); \
ublas_A = 3.1415 * ublas_B; \
ublas_C = 2.7172 * ublas_A; \
viennacl::copy(ublas_A, vcl_A); \
viennacl::copy(ublas_B, vcl_B); \
viennacl::copy(ublas_C, vcl_C); \
viennacl::copy(ublas_B, vcl_B); \
\
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) = std::FUNCNAME(ublas_A(i,j)); \
vcl_C = viennacl::linalg::element_##FUNCNAME(vcl_A); \
\
if (!check_for_equality(ublas_C, vcl_C, epsilon)) \
{ \
std::cout << "Failure at C = " << #FUNCNAME << "(A)" << std::endl; \
return EXIT_FAILURE; \
} \
\
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) = std::FUNCNAME(ublas_A(i,j) + ublas_B(i,j)); \
vcl_C = viennacl::linalg::element_##FUNCNAME(vcl_A + vcl_B); \
\
if (!check_for_equality(ublas_C, vcl_C, epsilon)) \
{ \
std::cout << "Failure at C = " << #FUNCNAME << "(A + B)" << std::endl; \
return EXIT_FAILURE; \
} \
\
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) += std::FUNCNAME(ublas_A(i,j)); \
vcl_C += viennacl::linalg::element_##FUNCNAME(vcl_A); \
\
if (!check_for_equality(ublas_C, vcl_C, epsilon)) \
{ \
std::cout << "Failure at C += " << #FUNCNAME << "(A)" << std::endl; \
return EXIT_FAILURE; \
} \
\
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) += std::FUNCNAME(ublas_A(i,j) + ublas_B(i,j)); \
vcl_C += viennacl::linalg::element_##FUNCNAME(vcl_A + vcl_B); \
\
if (!check_for_equality(ublas_C, vcl_C, epsilon)) \
{ \
std::cout << "Failure at C += " << #FUNCNAME << "(A + B)" << std::endl; \
return EXIT_FAILURE; \
} \
\
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) -= std::FUNCNAME(ublas_A(i,j)); \
vcl_C -= viennacl::linalg::element_##FUNCNAME(vcl_A); \
\
if (!check_for_equality(ublas_C, vcl_C, epsilon)) \
{ \
std::cout << "Failure at C -= " << #FUNCNAME << "(A)" << std::endl; \
return EXIT_FAILURE; \
} \
\
for (std::size_t i=0; i<ublas_C.size1(); ++i) \
for (std::size_t j=0; j<ublas_C.size2(); ++j) \
ublas_C(i,j) -= std::FUNCNAME(ublas_A(i,j) + ublas_B(i,j)); \
vcl_C -= viennacl::linalg::element_##FUNCNAME(vcl_A + vcl_B); \
\
if (!check_for_equality(ublas_C, vcl_C, epsilon)) \
{ \
std::cout << "Failure at C -= " << #FUNCNAME << "(A + B)" << std::endl; \
return EXIT_FAILURE; \
} \
\
GENERATE_UNARY_OP_TEST(cos);
GENERATE_UNARY_OP_TEST(cosh);
GENERATE_UNARY_OP_TEST(exp);
GENERATE_UNARY_OP_TEST(floor);
GENERATE_UNARY_OP_TEST(fabs);
GENERATE_UNARY_OP_TEST(log);
GENERATE_UNARY_OP_TEST(log10);
GENERATE_UNARY_OP_TEST(sin);
GENERATE_UNARY_OP_TEST(sinh);
GENERATE_UNARY_OP_TEST(fabs);
GENERATE_UNARY_OP_TEST(sqrt);
GENERATE_UNARY_OP_TEST(tan);
GENERATE_UNARY_OP_TEST(tanh);
std::cout << "Complicated expressions: ";
//std::cout << "ublas_A: " << ublas_A << std::endl;
//std::cout << "ublas_B: " << ublas_B << std::endl;
//std::cout << "ublas_C: " << ublas_C << std::endl;
ublas_B += alpha * (- ublas_A - beta * ublas_C + ublas_A);
vcl_B += gpu_alpha * (- vcl_A - vcl_C * beta + vcl_A);
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
ublas_B += (- ublas_A - beta * ublas_C + ublas_A * beta) / gpu_alpha;
vcl_B += (- vcl_A - vcl_C * beta + gpu_beta * vcl_A) / gpu_alpha;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
ublas_B -= alpha * (- ublas_A - beta * ublas_C - ublas_A);
vcl_B -= gpu_alpha * (- vcl_A - vcl_C * beta - vcl_A);
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
ublas_B -= (- ublas_A - beta * ublas_C - ublas_A * beta) / alpha;
vcl_B -= (- vcl_A - vcl_C * beta - gpu_beta * vcl_A) / gpu_alpha;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << std::endl;
std::cout << "----------------------------------------------" << std::endl;
std::cout << std::endl;
return EXIT_SUCCESS;
}
int run_test(double epsilon,
UBLASMatrixType & ublas_A, UBLASMatrixType & ublas_B, UBLASMatrixType & ublas_C,
ViennaCLMatrixType1 & vcl_A, ViennaCLMatrixType2 & vcl_B, ViennaCLMatrixType3 vcl_C)
{
typedef typename viennacl::result_of::cpu_value_type<typename ViennaCLMatrixType1::value_type>::type cpu_value_type;
cpu_value_type alpha = 3.1415;
viennacl::scalar<cpu_value_type> gpu_alpha = alpha;
cpu_value_type beta = 2.7182;
viennacl::scalar<cpu_value_type> gpu_beta = beta;
//
// Initializer:
//
std::cout << "Checking for zero_matrix initializer..." << std::endl;
ublas_A = ublas::zero_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2());
vcl_A = viennacl::zero_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2());
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Checking for scalar_matrix initializer..." << std::endl;
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), alpha);
vcl_A = viennacl::scalar_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2(), alpha);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_A = ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), gpu_beta);
vcl_A = viennacl::scalar_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2(), gpu_beta);
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
/*std::cout << "Checking for identity initializer..." << std::endl;
ublas_A = ublas::identity_matrix<cpu_value_type>(ublas_A.size1());
vcl_A = viennacl::identity_matrix<cpu_value_type>(vcl_A.size1());
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;*/
std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test: Assignments //////////" << std::endl;
//std::cout << "//" << std::endl;
std::cout << "Testing matrix assignment... ";
//std::cout << ublas_B(0,0) << " vs. " << vcl_B(0,0) << std::endl;
ublas_A = ublas_B;
vcl_A = vcl_B;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
//std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 1: Copy to GPU //////////" << std::endl;
//std::cout << "//" << std::endl;
ublas_A = ublas_B;
viennacl::copy(ublas_B, vcl_A);
std::cout << "Testing upper left copy to GPU... ";
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
ublas_C = ublas_B;
viennacl::copy(ublas_B, vcl_C);
std::cout << "Testing lower right copy to GPU... ";
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << std::endl;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 2: Copy from GPU //////////" << std::endl;
//std::cout << "//" << std::endl;
std::cout << "Testing upper left copy to A... ";
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Testing lower right copy to C... ";
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 3: Addition //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_C, vcl_C);
std::cout << "Inplace add: ";
ublas_C += ublas_C;
vcl_C += vcl_C;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled inplace add: ";
ublas_C += beta * ublas_A;
vcl_C += gpu_beta * vcl_A;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Add: ";
ublas_C = ublas_A + ublas_B;
vcl_C = vcl_A + vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add: ";
ublas_C = alpha * ublas_A + beta * ublas_B;
vcl_C = alpha * vcl_A + beta * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled add: ";
vcl_C = gpu_alpha * vcl_A + gpu_beta * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 4: Subtraction //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_C, vcl_C);
std::cout << "Inplace sub: ";
ublas_C -= ublas_B;
vcl_C -= vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled Inplace sub: ";
ublas_C -= alpha * ublas_B;
vcl_C -= alpha * vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Sub: ";
ublas_C = ublas_A - ublas_B;
vcl_C = vcl_A - vcl_B;
if (!check_for_equality(ublas_C, vcl_C, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub: ";
ublas_B = alpha * ublas_A - beta * ublas_C;
vcl_B = alpha * vcl_A - vcl_C * beta;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
std::cout << "Scaled sub: ";
vcl_B = gpu_alpha * vcl_A - vcl_C * gpu_beta;
if (!check_for_equality(ublas_B, vcl_B, epsilon))
return EXIT_FAILURE;
//std::cout << "//" << std::endl;
//std::cout << "////////// Test 5: Scaling //////////" << std::endl;
//std::cout << "//" << std::endl;
viennacl::copy(ublas_A, vcl_A);
std::cout << "Multiplication with CPU scalar: ";
ublas_A *= alpha;
vcl_A *= alpha;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Multiplication with GPU scalar: ";
ublas_A *= beta;
vcl_A *= gpu_beta;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Division with CPU scalar: ";
ublas_A /= alpha;
vcl_A /= alpha;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << "Division with GPU scalar: ";
ublas_A /= beta;
vcl_A /= gpu_beta;
if (!check_for_equality(ublas_A, vcl_A, epsilon))
return EXIT_FAILURE;
std::cout << std::endl;
std::cout << "----------------------------------------------" << std::endl;
std::cout << std::endl;
return EXIT_SUCCESS;
}
