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; }