diff --git a/CMakeLists.txt b/CMakeLists.txt
index d91428631a7e52cb5e86c98ec248f77b73453414..3992cc33577334104f5cdb06c7c0c1eb403a1c22 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -285,6 +285,9 @@ if ( CHAMELEON_SCHED_PARSEC )
set( CHAMELEON_COPY_DIAG OFF )
endif()
mark_as_advanced(CHAMELEON_COPY_DIAG)
+
+# If ON generates vendor_ztesting in testings
+option(CHAMELEON_TESTINGS_VENDOR "Generate testings of the blas / lapack vendor (e.g. intel MKL MT)" OFF)
#------------------------------------------------------------------------------
###############################################################################
diff --git a/cmake_modules/local_subs.py b/cmake_modules/local_subs.py
index 75ce13a204fa9e320bf532b7739472b32ec2e508..dde6c21e18cbb668c824dae285045ded022c820d 100644
--- a/cmake_modules/local_subs.py
+++ b/cmake_modules/local_subs.py
@@ -108,6 +108,8 @@ subs = {
# ('CORE_P', 'CORE_S', 'CORE_D', 'CORE_C', 'CORE_Z' ),
# ('vec_p', 'vec_s', 'vec_d', 'vec_c', 'vec_z' ),
+ # ----- Vendors Prefixes
+ ('vendor_p', 'vendor_s', 'vendor_d', 'vendor_c', 'vendor_z' ),
('', 'cublasS', 'cublasD', 'cublasC', 'cublasZ' ),
# ('', 'starpu_s', 'starpu_d', 'starpu_c', 'starpu_z' ),
# ('', 'STARPU_S', 'STARPU_D', 'STARPU_C', 'STARPU_Z' ),
diff --git a/testing/CMakeLists.txt b/testing/CMakeLists.txt
index 5187d6f5de6c0a76c9f6d119d2604a8bab7356b3..e8bb1e02ae1ddea09a6a86013e3ecb78f86cb6e4 100644
--- a/testing/CMakeLists.txt
+++ b/testing/CMakeLists.txt
@@ -43,22 +43,11 @@ set(CHAMELEON_SOURCES_TARGETS "${CHAMELEON_SOURCES_TARGETS};testing_include" CAC
# Generate chameleon testing sources for all possible precisions
# ----------------------------------------------------------
-set(ZSRC
- chameleon_ztesting.c
- testing_zcheck.c
- testing_zprint.c
- ##################
- # LAPACK
- ##################
- #testing_zlaset.c
- testing_zlacpy.c
+set(ZSRC_W_STDAPI
testing_zlange.c
testing_zlanhe.c
testing_zlansy.c
testing_zlantr.c
- testing_zgeadd.c
- testing_ztradd.c
- testing_zlascal.c
testing_zgemm.c
testing_zhemm.c
testing_zherk.c
@@ -71,17 +60,25 @@ set(ZSRC
testing_zpotrf.c
testing_zpotrs.c
testing_zposv.c
- testing_ztrtri.c
- testing_zlauum.c
testing_zpotri.c
testing_zpoinv.c
+)
+
+set(ZSRC_WO_STDAPI
+ #testing_zlaset.c
+ testing_zlacpy.c
+ testing_zgeadd.c
+ testing_ztradd.c
+ testing_zlascal.c
+ testing_ztrtri.c
+ testing_zlauum.c
testing_zsytrf.c
testing_zsytrs.c
testing_zsysv.c
testing_zgenm2.c
+ testing_zgesv.c
testing_zgetrf.c
testing_zgetrs.c
- testing_zgesv.c
testing_zgeqrf.c
testing_zungqr.c
testing_zunmqr.c
@@ -105,8 +102,23 @@ set(ZSRC
testing_zplrnk.c
testing_zcesca.c
testing_zgram.c
- )
+)
+foreach(_precision ${CHAMELEON_PRECISION} )
+
+ precisions_rules_py(${_precision}SRC_W_STDAPI_GENERATED "${ZSRC_W_STDAPI}"
+ PRECISIONS "${_precision}" )
+
+ precisions_rules_py(${_precision}SRC_WO_STDAPI_GENERATED "${ZSRC_WO_STDAPI}"
+ PRECISIONS "${_precision}" )
+
+endforeach()
+
+set(ZSRC
+ chameleon_ztesting.c
+ testing_zcheck.c
+ testing_zprint.c
+)
# Create one testing per precision with all files
# -----------------------------------------------
@@ -118,9 +130,12 @@ foreach(_precision ${CHAMELEON_PRECISION} )
set( __target_name chameleon_${_precision}testing )
add_executable( ${__target_name}
${${_precision}SRC_GENERATED}
+ ${${_precision}SRC_W_STDAPI_GENERATED}
+ ${${_precision}SRC_WO_STDAPI_GENERATED}
values.c
run_list.c
parameters.c
+ testings.c
)
add_dependencies(${__target_name}
chameleon_include
@@ -159,6 +174,71 @@ foreach(_precision ${CHAMELEON_PRECISION} )
endforeach()
+# VENDOR api tests
+set(ZSRC_VENDOR
+ vendor_ztesting.c
+)
+
+if ( CHAMELEON_TESTINGS_VENDOR )
+ foreach(_precision ${CHAMELEON_PRECISION} )
+
+ precisions_rules_py(${_precision}SRC_VENDOR_GENERATED "${ZSRC_VENDOR}"
+ PRECISIONS "${_precision}" )
+
+ set( __target_name vendor_${_precision}testing )
+ add_executable( ${__target_name}
+ ${${_precision}SRC_VENDOR_GENERATED}
+ ${${_precision}SRC_W_STDAPI_GENERATED}
+ values.c
+ run_list.c
+ parameters.c
+ testings.c
+ )
+
+ target_compile_definitions(${__target_name}
+ PRIVATE CHAMELEON_TESTINGS_VENDOR
+ )
+
+ add_dependencies(${__target_name}
+ chameleon_include
+ control_include
+ testing_include
+ coreblas_include
+ )
+
+ target_include_directories(${__target_name} PRIVATE
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ )
+ # testing_zcheck.c includes additional chameleon headers
+ # coreblas/include/coreblas/cblas.h, coreblas/coreblas_z.h, control/common.h, ...
+ target_include_directories(${__target_name} PRIVATE
+ ${CHAMELEON_SOURCE_DIR}
+ ${CHAMELEON_BINARY_DIR}
+ ${CHAMELEON_SOURCE_DIR}/include
+ ${CHAMELEON_BINARY_DIR}/include
+ ${CHAMELEON_SOURCE_DIR}/coreblas/include
+ ${CHAMELEON_BINARY_DIR}/coreblas/include
+ )
+
+ if (BLAS_MT_LIBRARIES)
+ target_link_libraries(${__target_name} PRIVATE
+ ${BLAS_MT_LIBRARIES})
+ else()
+ target_link_libraries(${__target_name} PRIVATE
+ MORSE::LAPACKE
+ MORSE::CBLAS)
+ endif()
+
+ target_link_libraries(${__target_name} PRIVATE MORSE::M)
+ target_link_libraries(${__target_name} PRIVATE chameleon)
+
+ install(TARGETS ${__target_name}
+ DESTINATION bin/ )
+
+ endforeach()
+endif()
+
# Force generation of sources
# ---------------------------
set(TESTING_SRCS)
@@ -168,6 +248,13 @@ endforeach()
add_custom_target(testing_sources ALL SOURCES ${TESTING_SRCS})
set(CHAMELEON_SOURCES_TARGETS "${CHAMELEON_SOURCES_TARGETS};testing_sources" CACHE INTERNAL "List of targets of sources")
+set(VENDOR_SRCS)
+foreach(_precision ${CHAMELEON_PRECISION})
+ list(APPEND VENDOR_SRCS ${${_precision}SRC_VENDOR_GENERATED})
+endforeach()
+add_custom_target(vendor_sources ALL SOURCES ${VENDOR_SRCS})
+set(CHAMELEON_SOURCES_TARGETS "${CHAMELEON_SOURCES_TARGETS};vendor_sources" CACHE INTERNAL "List of targets of sources")
+
#-------- Tests ---------
include(CTestLists.cmake)
diff --git a/testing/CTestLists.cmake b/testing/CTestLists.cmake
index af64f0c774b47675be03106acd79044f5f1f03df..6b5b96eecbc057e6b6579799b49ada50c9293980 100644
--- a/testing/CTestLists.cmake
+++ b/testing/CTestLists.cmake
@@ -89,6 +89,7 @@ if (NOT CHAMELEON_SIMULATION)
endforeach()
endforeach()
+ # STD api tests
foreach(prec ${RP_CHAMELEON_PRECISIONS})
set (CMD ./chameleon_${prec}testing)
diff --git a/testing/chameleon_ztesting.c b/testing/chameleon_ztesting.c
index b76f74e637d943b7bf7d4d65cc265139ba3563ff..d928ca4582831e1566a7c2430a91245d1ca87a47 100644
--- a/testing/chameleon_ztesting.c
+++ b/testing/chameleon_ztesting.c
@@ -24,581 +24,6 @@
*
*/
#include "testings.h"
-#if defined(CHAMELEON_HAVE_GETOPT_LONG)
-#include <getopt.h>
-#else
-struct option;
-#endif
-
-/**
- * @brief Defines all the parameters of the testings
- */
-static parameter_t parameters[] = {
- /* Name, helper, shname, flags, has_arg, psize, valtype, value, vallist, read, sprint */
- { "id", "Id of the run", 0, PARAM_OUTPUT, 0, 3, TestValInt, {0}, NULL, NULL, sprint_int },
-
- { NULL, "Options", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "help", "Show this help", 'h', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "check", "Enable checking of the result", 'c', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "human", "Enable human readable mode", 'H', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "niter", "Perform multiple iteration per test", 'l', PARAM_OPTION, 1, 0, TestValInt, {1}, NULL, pread_int, sprint_int },
- { "trace", "Enable the trace generation", -30, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "nowarmup", "Disable the warmup run to load libraries", -31, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "mtxfmt", "Change the way the matrix is stored (0: global, 1: tiles, 2: OOC)", -32, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 1, 6, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "profile", "Display the kernel profiling", -33, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "forcegpu", "Force kernels on GPU", -34, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "async", "Switch to the Async interface", 's', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "splitsub", "Split the task submission and execution stages", 'S', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "generic", "Switch to the non optimized generic algorithms", -35, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "api", "Select the API to test (0: Descriptors, 1: Standard)", -36, PARAM_OPTION, 1, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { NULL, "Machine parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "threads", "Number of CPU workers per node", 't', PARAM_OPTION | PARAM_OUTPUT, 1, 7, TestValInt, {-1}, NULL, pread_int, sprint_int },
- { "gpus", "Number of GPU workers per node", 'g', PARAM_OPTION | PARAM_OUTPUT, 1, 4, TestValInt, { 0}, NULL, pread_int, sprint_int },
- { "P", "Rows (P) in the PxQ process grid", 'P', PARAM_OPTION | PARAM_OUTPUT, 1, 2, TestValInt, { 1}, NULL, pread_int, sprint_int },
- { "Q", "Columns (Q) in the PxQ process grid", 'Q', PARAM_OUTPUT, 1, 2, TestValInt, { 1}, NULL, pread_int, sprint_int },
-
- { NULL, "Main input parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "op", "Operation to test/time ('-o help' to get the list of functions)", 'o', PARAM_OPTION | PARAM_OUTPUT, 1, 1, TestString, {0}, NULL, pread_string, sprint_string },
- { "file", "Input file", 'f', PARAM_OPTION, 1, 1, TestString, {0}, NULL, pread_string, sprint_string },
-
- { NULL, "Matrix definition parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "m", "Dimension M of the operation", 'm', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "n", "Dimension N of the operation", 'n', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "k", "Dimension K of the operation", 'k', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "nrhs", "Dimension NRHS of the operation", 'r', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { "nb", "Tile size nb", 'b', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "ib", "Inner tile size ib", 'i', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 2, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { "l1", "Size of the first level of recursion", '1', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "l2", "Size of the second level of recursion", '2', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "l3", "Size of the third level of recursion", '3', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { "lda", "Leading dimension of the matrix A", 'A', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "ldb", "Leading dimension of the matrix B", 'B', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "ldc", "Leading dimension of the matrix C", 'C', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { "seedA", "Seed for the matrix A random generation", 'X', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 11, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "seedB", "Seed for the matrix B random generation", 'Y', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 11, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "seedC", "Seed for the matrix C random generation", 'Z', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 11, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { NULL, "Matrix generation numerical parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "bump", "Bump value to make a matrix diagonal dominant", 'z', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValComplex64, {0}, NULL, pread_complex64, sprint_complex64 },
- { "mode", "Mode that specifies the eigen/singular values in xlatms", -30, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "cond", "Conditional number of the matrix used by xlatms", -31, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
-
- { NULL, "Operation specific parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "trans", "Value of the trans parameter", -11, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 9, TestTrans, {0}, NULL, pread_trans, sprint_trans },
- { "transA", "Value of the transA parameter", -12, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 9, TestTrans, {0}, NULL, pread_trans, sprint_trans },
- { "transB", "Value of the transB parameter", -13, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 9, TestTrans, {0}, NULL, pread_trans, sprint_trans },
- { "uplo", "Value of the uplo parameter", -14, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 7, TestUplo, {0}, NULL, pread_uplo, sprint_uplo },
- { "diag", "Value of the diag parameter", -15, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 7, TestDiag, {0}, NULL, pread_diag, sprint_diag },
- { "side", "Value of the side parameter", -16, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestSide, {0}, NULL, pread_side, sprint_side },
- { "norm", "Value of the norm parameter", -17, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestNormtype, {0}, NULL, pread_norm, sprint_norm },
-
- { NULL, "Operation specific scalar", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "alpha", "Value of the scalar alpha", 'x', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValComplex64, {0}, NULL, pread_complex64, sprint_complex64 },
- { "beta", "Value of the scalar beta", 'y', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValComplex64, {0}, NULL, pread_complex64, sprint_complex64 },
-
- { NULL, "QR/LQ parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
- { "qra", "Size of TS domain (=RH for householder trees)", -20, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "qrp", "Size of high level tree for distributed", -21, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "llvl", "Tree used for low level reduction insides nodes", -22, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "hlvl", "Tree used for high level reduction between nodes", -23, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestValInt, {0}, NULL, pread_int, sprint_int },
- { "domino", "Enable/Disable the domino between upper and lower trees", -24, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 6, TestValInt, {0}, NULL, pread_int, sprint_int },
-
- { "tsub", "Graph submission time in s", 999, PARAM_OUTPUT, 2, 13, TestValFixdbl, {0}, NULL, pread_fixdbl, sprint_fixdbl },
- { "time", "Time in s", 1000, PARAM_OUTPUT, 2, 13, TestValFixdbl, {0}, NULL, pread_fixdbl, sprint_fixdbl },
- { "gflops", "GFlop/s", 1001, PARAM_OUTPUT, 2, 13, TestValFixdbl, {0}, NULL, pread_fixdbl, sprint_fixdbl },
- { "RETURN", "Result of the testing: SUCCESS/FAILED", 1002, PARAM_OUTPUT, 2, 7, TestValInt, {0}, NULL, pread_int, sprint_check },
- { "||Ax-b||", "Norm of the residual", 1003, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||A-fact(A)||", "Norm of the residual", 1004, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||A||", "Norm of the matrix A", 1005, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||B||", "Norm of the matrix B", 1006, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||C||", "Norm of the matrix C", 1007, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||R||", "Residual norm", 1008, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||b||", "Norm of the vector b", 1009, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||x||", "Norm of the vector x", 1010, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||Ax-b||/N/eps/(||A||||x||+||b||", "", 1011, PARAM_OUTPUT, 2, 22, TestValDouble, {0}, NULL, pread_double, sprint_double },
- { "||I-QQ'||", "Orthonormality of Q", 1012, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
-};
-
-#define STR_MAX_LENGTH 256
-
-void print_usage( const char* prog_name )
-{
- int rank;
- if ( CHAMELEON_Initialized() ) {
- rank = CHAMELEON_Comm_rank();
- }
- else {
- rank = 0;
- }
-
- if (rank == 0) {
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
- printf( "Usage:\n"
- " %s -o|--op operation_name [options]\n"
- " %s -f|--file input_file [options]\n",
- prog_name, prog_name );
-
- for (i=0; i<nbparams; i++, param++) {
- char str[STR_MAX_LENGTH];
-
- /* This is not an option, we skip it */
- if ( !(param->flags & PARAM_OPTION) ) {
- continue;
- }
-
- /* This is an option header */
- if ( param->name == NULL ) {
- printf( "\n %s:\n", param->helper );
- continue;
- }
-
- if ( param->shname > 0 ) {
- snprintf( str, STR_MAX_LENGTH, "-%c, --%s",
- param->shname, param->name );
- }
- else {
- snprintf( str, STR_MAX_LENGTH, " --%s",
- param->name );
- }
-
- /* If an argument is needed, add " x" */
- if ( param->has_arg > 0 ) {
- int len = strlen(str);
- assert( len < (STR_MAX_LENGTH-3) );
-
- str[ len ] = ' ';
- str[ len+1 ] = 'x';
- str[ len+2 ] = '\0';
- }
- printf( " %-23s %s\n",
- str, param->helper );
- }
-
- printf( "\n"
- "For example: %s -H -o gemm -t 2 -m 2000 -n 2000 -k 2000 -b 200\n"
- " will run one gemm with three matrices of size 2000x2000 each and a tile size of 200.\n"
- " The output will be in the human readable format\n"
- "\n", prog_name );
- printf( "Remarks about timing:\n"
- " Timings are reported respectively as 'tsub' for the graph submission time, and 'time'\n"
- " for the execution time.\n"
- " By default the synchronous tile interface is used to perform the timings. 'tsub' is null.\n"
- " If the --async option is enabled, then the asynchronous interface is called. 'tsub' reports\n"
- " the task submission time, and 'time' the execution time that includes 'tsub'.\n"
- " If the --splitsub option is enabled, then the asynchronous interface is called and task\n"
- " submission is fully performed before starting the computation. 'tsub' reports the\n"
- " task submission time, and 'time' the execution time excluding 'tsub'.\n"
- " Note that the 'gflops' field is always computed with 'time'\n" );
- }
-}
-
-/**
- * @brief List of all the testings available.
- */
-static testing_t *testings = NULL;
-
-/**
- * @brief Function to register a new testing
- */
-void
-testing_register( testing_t *test )
-{
- assert( test->next == NULL );
- test->next = testings;
- testings = test;
-}
-
-/**
- * @brief Get the testing structure associated to a test
- */
-testing_t *
-testing_gettest( const char *prog_name,
- const char *func_name )
-{
- testing_t *test = testings;
- int rank = CHAMELEON_Comm_rank();
-
- if ( func_name == NULL ) {
- print_usage( prog_name );
- exit(1);
- }
-
- while( test != NULL ) {
- /* Check the name with and without the precision */
- if ( (strcasecmp( func_name, test->name ) == 0) ||
- (strcasecmp( func_name, test->name + 1 ) == 0) )
- {
- break;
- }
- test = test->next;
- }
-
- if ( test == NULL ) {
- if ( rank == 0 ) {
- printf( "Operation %s not found\n", func_name );
- printf( "The available operations are:\n" );
- test = testings;
- while( test != NULL ) {
- printf( " %-10s %s\n", test->name, test->helper );
- test = test->next;
- }
- }
- exit(1);
- }
-
- return test;
-}
-
-int
-parameters_compute_q( int p )
-{
- parameter_t *param;
- int np = CHAMELEON_Comm_size();
-
- if ( (np % p) != 0 ) {
- fprintf( stderr, "ERROR: The number of processes (%d) must be a multiple of P (%d)\n", np, p );
- exit(1);
- }
-
- param = parameters_get( 'Q' );
- param->value.ival = np / p;
- return param->value.ival;
-}
-
-void
-parameters_getopt_init( char *optstring,
- struct option **longopts )
-{
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
- int nboptions = 0;
- int strpos = 0;
-
- for ( i=0; i<nbparams; i++, param++ ) {
- /* This is not an option, we skip it */
- if ( !(param->flags & PARAM_OPTION) ||
- (param->name == NULL) )
- {
- continue;
- }
-
- nboptions++;
-
- if ( param->shname < 0 ) {
- continue;
- }
-
- optstring[strpos] = param->shname;
- strpos++;
- assert( strpos < STR_MAX_LENGTH );
-
- if ( param->has_arg > 0 ) {
- optstring[strpos] = ':';
- strpos++;
- assert( strpos < STR_MAX_LENGTH );
- }
- }
- optstring[strpos] = '\0';
-
- /* Now, let's generate the long opt if needed */
-#if defined(CHAMELEON_HAVE_GETOPT_LONG)
- if ( longopts != NULL ) {
- struct option *opt;
- *longopts = calloc( nboptions+1, sizeof( struct option ) );
-
- opt = *longopts;
- param = parameters;
-
- for ( i=0; i<nboptions; i++, opt++, param++ ) {
-
- /* Look for a valid option */
- while ( !(param->flags & PARAM_OPTION) ||
- (param->name == NULL) )
- {
- param++;
- }
-
- opt->name = param->name;
- opt->has_arg = ( param->has_arg > 0 ) ? 1 : 0;
- opt->flag = NULL;
- opt->val = param->shname;
- }
- }
-#endif
-}
-
-parameter_t *
-parameters_get( int shname )
-{
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
-
- for ( i=0; i<nbparams; i++, param++ ) {
- /* This is not an option, we skip it */
- if ( param->name == NULL ) {
- continue;
- }
-
- if ( shname == param->shname ) {
- return param;
- }
- }
-
- fprintf( stderr, "parameters_get could not find parameter %d(%c)\n", shname, shname );
- return NULL;
-}
-
-int
-parameters_getvalue_int( const char *name )
-{
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
-
- for ( i=0; i<nbparams; i++, param++ ) {
- /* This is not an option, we skip it */
- if ( param->name == NULL ) {
- continue;
- }
-
- if ( strcasecmp( name, param->name ) != 0 ) {
- continue;
- }
-
- if ( param->has_arg > 1 ) {
- fprintf( stderr, "parameters_getvalue_int should not be called with parameter %s\n", name );
- return -1;
- }
-
- if ( param->valtype != TestValInt ) {
- fprintf( stderr, "parameters_getvalue_int has been called with a non integer parameter (%s)\n", name );
- return -1;
- }
-
- return param->value.ival;
- }
-
- fprintf( stderr, "parameters_getvalue_int could not find parameter %s\n", name );
- return -1;
-}
-
-char *
-parameters_getvalue_str( const char *name )
-{
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
-
- for ( i=0; i<nbparams; i++, param++ ) {
- /* This is not an option, we skip it */
- if ( param->name == NULL ) {
- continue;
- }
-
- if ( strcasecmp( name, param->name ) != 0 ) {
- continue;
- }
-
- if ( param->has_arg > 1 ) {
- fprintf( stderr, "parameters_getvalue_str should not be called with parameter %s\n", name );
- return NULL;
- }
-
- if ( param->valtype != TestString ) {
- fprintf( stderr, "parameters_getvalue_str has been called with a non string parameter (%s)\n", name );
- return NULL;
- }
-
- return param->value.str;
- }
-
- fprintf( stderr, "parameters_getvalue_str could not find parameter %s\n", name );
- return NULL;
-}
-
-parameter_t *
-parameters_getbyname( const char *name )
-{
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
-
- for ( i=0; i<nbparams; i++, param++ ) {
- /* This is not an option, we skip it */
- if ( param->name == NULL ) {
- continue;
- }
-
- if ( strcasecmp( name, param->name ) != 0 ) {
- continue;
- }
-
- /* if ( param->has_arg < 2 ) { */
- /* fprintf( stderr, "parameters_getbyname should not be called with parameter %s\n", name ); */
- /* return NULL; */
- /* } */
-
- return param;
- }
-
- fprintf( stderr, "parameters_getbyname could not find parameter %s\n", name );
- return NULL;
-}
-
-void parameters_parser( int argc, char **argv )
-{
- int opt;
- char optstring[STR_MAX_LENGTH];
- struct option *longopts = NULL;
- parameter_t *param;
-
- parameters_getopt_init( optstring, &longopts );
-
-#if defined(CHAMELEON_HAVE_GETOPT_LONG)
- while ((opt = getopt_long(argc, argv, optstring, longopts, NULL)) != -1)
-#else
- while ((opt = getopt(argc, argv, optstring)) != -1)
-#endif
- {
- switch(opt) {
- case 'h':
- print_usage(argv[0]);
- exit(0);
-
- case '?': /* error from getopt[_long] */
- exit(1);
- break;
-
- default:
- param = parameters_get( opt );
- if ( param == NULL ) {
- print_usage(argv[0]);
- exit(1);
- }
- parameters_addvalues( param, optarg );
- }
- }
-
- if ( longopts != NULL ) {
- free( longopts );
- }
-
- /* Force Async if splitsub is enabled */
- {
- int splitsub = parameters_getvalue_int( "splitsub" );
-
- if ( splitsub ) {
- param = parameters_get( 's' );
- if ( param == NULL ) {
- print_usage(argv[0]);
- exit(1);
- }
- parameters_addvalues( param, NULL );
-
-#if defined(CHAMELEON_RUNTIME_SYNC)
- fprintf( stderr, "Spliting the submission and the execution stages is not possible when the option CHAMELEON_RUNTIME_SYNC is enabled\n" );
- exit(0);
-#endif
- }
- }
-}
-
-void
-parameters_destroy()
-{
- parameter_t *param = parameters;
- int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
- vallist_t *current, *next;
-
- for ( i=0; i<nbparams; i++, param++ ) {
- /* This is not an option, we skip it */
- if ( param->has_arg < 2 ) {
- continue;
- }
-
- current = param->vallist;
- while ( current != NULL )
- {
- next = current->next;
- free( current );
- current = next;
- }
- }
- return;
-}
-
-void
-testing_start( testdata_t *tdata )
-{
- int splitsub = parameters_getvalue_int( "splitsub" );
- int async = parameters_getvalue_int( "async" ) || splitsub;
-
- tdata->sequence = NULL;
- tdata->request.status = 0;
- tdata->request.schedopt = NULL;
-
-#if defined(CHAMELEON_USE_MPI)
- CHAMELEON_Distributed_start();
-#endif
-
- if ( async ) {
- CHAMELEON_Sequence_Create( &(tdata->sequence) );
- }
-
- if ( splitsub ) {
- CHAMELEON_Pause();
- }
-
- /* Register starting time */
- tdata->tsub = RUNTIME_get_time();
- tdata->texec = tdata->tsub;
-}
-
-void
-testing_stop( testdata_t *tdata, cham_fixdbl_t flops )
-{
- cham_fixdbl_t t0, t1, t2, gflops;
-
- int splitsub = parameters_getvalue_int( "splitsub" );
- int async = parameters_getvalue_int( "async" ) || splitsub;
-
- /* Submission is done, we need to start the computations */
- if ( async ) {
- tdata->tsub = RUNTIME_get_time();
- if ( splitsub ) {
- CHAMELEON_Resume();
- }
- CHAMELEON_Sequence_Wait( tdata->sequence );
- CHAMELEON_Sequence_Destroy( tdata->sequence );
- }
-#if defined(CHAMELEON_USE_MPI)
- CHAMELEON_Distributed_stop();
-#endif
- t2 = RUNTIME_get_time();
-
- t0 = tdata->texec;
- t1 = tdata->tsub;
- /*
- * texec / Submission / tsub / Execution / t
- *
- * => texec = t2 - t1
- * => tsub = t1 - t0
- */
- tdata->tsub = t1 - t0;
- if ( splitsub ) {
- tdata->texec = t2 - t1;
- }
- else {
- tdata->texec = t2 - t0;
- }
- gflops = flops * 1.e-9 / tdata->texec;
- run_arg_add_fixdbl( tdata->args, "time", tdata->texec );
- run_arg_add_fixdbl( tdata->args, "tsub", tdata->tsub );
- run_arg_add_fixdbl( tdata->args, "gflops", ( tdata->hres == CHAMELEON_SUCCESS ) ? gflops : -1. );
-}
int main (int argc, char **argv) {
@@ -633,7 +58,6 @@ int main (int argc, char **argv) {
api = parameters_getvalue_int( "api" );
rc = CHAMELEON_Init( ncores, ngpus );
-
if ( rc != CHAMELEON_SUCCESS ) {
fprintf( stderr, "CHAMELEON_Init failed and returned %d.\n", rc );
info = 1;
diff --git a/testing/parameters.c b/testing/parameters.c
index 247b5a0431ddd703bf105b4a66052948eee31a1b..c83f3778534a7a13f322abefe3610816378cc0f4 100644
--- a/testing/parameters.c
+++ b/testing/parameters.c
@@ -16,6 +16,181 @@
*/
#include "testings.h"
+/**
+ * @brief Defines all the parameters of the testings
+ */
+static parameter_t parameters[] = {
+ /* Name, helper, shname, flags, has_arg, psize, valtype, value, vallist, read, sprint */
+ { "id", "Id of the run", 0, PARAM_OUTPUT, 0, 3, TestValInt, {0}, NULL, NULL, sprint_int },
+
+ { NULL, "Options", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "help", "Show this help", 'h', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "human", "Enable human readable mode", 'H', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "niter", "Perform multiple iteration per test", 'l', PARAM_OPTION, 1, 0, TestValInt, {1}, NULL, pread_int, sprint_int },
+ { "nowarmup", "Disable the warmup run to load libraries", -31, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ { "check", "Enable checking of the result", 'c', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "trace", "Enable the trace generation", -30, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "mtxfmt", "Change the way the matrix is stored (0: global, 1: tiles, 2: OOC)", -32, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 1, 6, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "profile", "Display the kernel profiling", -33, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "forcegpu", "Force kernels on GPU", -34, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "async", "Switch to the Async interface", 's', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "splitsub", "Split the task submission and execution stages", 'S', PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "generic", "Switch to the non optimized generic algorithms", -35, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "api", "Select the API to test (0: Descriptors, 1: Standard)", -36, PARAM_OPTION, 1, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+#endif
+
+ { NULL, "Machine parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "threads", "Number of CPU workers per node", 't', PARAM_OPTION | PARAM_OUTPUT, 1, 7, TestValInt, {-1}, NULL, pread_int, sprint_int },
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ { "gpus", "Number of GPU workers per node", 'g', PARAM_OPTION | PARAM_OUTPUT, 1, 4, TestValInt, { 0}, NULL, pread_int, sprint_int },
+ { "P", "Rows (P) in the PxQ process grid", 'P', PARAM_OPTION | PARAM_OUTPUT, 1, 2, TestValInt, { 1}, NULL, pread_int, sprint_int },
+ { "Q", "Columns (Q) in the PxQ process grid", 'Q', PARAM_OUTPUT, 1, 2, TestValInt, { 1}, NULL, pread_int, sprint_int },
+#endif
+
+ { NULL, "Main input parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "op", "Operation to test/time ('-o help' to get the list of functions)", 'o', PARAM_OPTION | PARAM_OUTPUT, 1, 1, TestString, {0}, NULL, pread_string, sprint_string },
+ { "file", "Input file", 'f', PARAM_OPTION, 1, 1, TestString, {0}, NULL, pread_string, sprint_string },
+
+ { NULL, "Matrix definition parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "m", "Dimension M of the operation", 'm', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "n", "Dimension N of the operation", 'n', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "k", "Dimension K of the operation", 'k', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "nrhs", "Dimension NRHS of the operation", 'r', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+
+ { "nb", "Tile size nb", 'b', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ { "ib", "Inner tile size ib", 'i', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 2, TestValInt, {0}, NULL, pread_int, sprint_int },
+
+ { "l1", "Size of the first level of recursion", '1', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "l2", "Size of the second level of recursion", '2', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "l3", "Size of the third level of recursion", '3', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+#endif
+
+ { "lda", "Leading dimension of the matrix A", 'A', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "ldb", "Leading dimension of the matrix B", 'B', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "ldc", "Leading dimension of the matrix C", 'C', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestValInt, {0}, NULL, pread_int, sprint_int },
+
+ { "seedA", "Seed for the matrix A random generation", 'X', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 11, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "seedB", "Seed for the matrix B random generation", 'Y', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 11, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "seedC", "Seed for the matrix C random generation", 'Z', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 11, TestValInt, {0}, NULL, pread_int, sprint_int },
+
+ { NULL, "Matrix generation numerical parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "bump", "Bump value to make a matrix diagonal dominant", 'z', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValComplex64, {0}, NULL, pread_complex64, sprint_complex64 },
+ { "mode", "Mode that specifies the eigen/singular values in xlatms", -30, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "cond", "Conditional number of the matrix used by xlatms", -31, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+
+ { NULL, "Operation specific parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "trans", "Value of the trans parameter", -11, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 9, TestTrans, {0}, NULL, pread_trans, sprint_trans },
+ { "transA", "Value of the transA parameter", -12, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 9, TestTrans, {0}, NULL, pread_trans, sprint_trans },
+ { "transB", "Value of the transB parameter", -13, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 9, TestTrans, {0}, NULL, pread_trans, sprint_trans },
+ { "uplo", "Value of the uplo parameter", -14, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 7, TestUplo, {0}, NULL, pread_uplo, sprint_uplo },
+ { "diag", "Value of the diag parameter", -15, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 7, TestDiag, {0}, NULL, pread_diag, sprint_diag },
+ { "side", "Value of the side parameter", -16, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 5, TestSide, {0}, NULL, pread_side, sprint_side },
+ { "norm", "Value of the norm parameter", -17, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestNormtype, {0}, NULL, pread_norm, sprint_norm },
+
+ { NULL, "Operation specific scalar", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "alpha", "Value of the scalar alpha", 'x', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValComplex64, {0}, NULL, pread_complex64, sprint_complex64 },
+ { "beta", "Value of the scalar beta", 'y', PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 13, TestValComplex64, {0}, NULL, pread_complex64, sprint_complex64 },
+
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ { NULL, "QR/LQ parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
+ { "qra", "Size of TS domain (=RH for householder trees)", -20, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "qrp", "Size of high level tree for distributed", -21, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 3, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "llvl", "Tree used for low level reduction insides nodes", -22, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "hlvl", "Tree used for high level reduction between nodes", -23, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 4, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "domino", "Enable/Disable the domino between upper and lower trees", -24, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 2, 6, TestValInt, {0}, NULL, pread_int, sprint_int },
+#endif
+
+ { "tsub", "Graph submission time in s", 999, PARAM_OUTPUT, 2, 13, TestValFixdbl, {0}, NULL, pread_fixdbl, sprint_fixdbl },
+ { "time", "Time in s", 1000, PARAM_OUTPUT, 2, 13, TestValFixdbl, {0}, NULL, pread_fixdbl, sprint_fixdbl },
+ { "gflops", "GFlop/s", 1001, PARAM_OUTPUT, 2, 13, TestValFixdbl, {0}, NULL, pread_fixdbl, sprint_fixdbl },
+ { "RETURN", "Result of the testing: SUCCESS/FAILED", 1002, PARAM_OUTPUT, 2, 7, TestValInt, {0}, NULL, pread_int, sprint_check },
+ { "||Ax-b||", "Norm of the residual", 1003, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||A-fact(A)||", "Norm of the residual", 1004, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||A||", "Norm of the matrix A", 1005, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||B||", "Norm of the matrix B", 1006, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||C||", "Norm of the matrix C", 1007, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||R||", "Residual norm", 1008, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||b||", "Norm of the vector b", 1009, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||x||", "Norm of the vector x", 1010, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||Ax-b||/N/eps/(||A||||x||+||b||", "", 1011, PARAM_OUTPUT, 2, 22, TestValDouble, {0}, NULL, pread_double, sprint_double },
+ { "||I-QQ'||", "Orthonormality of Q", 1012, PARAM_OUTPUT, 2, 13, TestValDouble, {0}, NULL, pread_double, sprint_double },
+};
+
+void print_usage( const char* prog_name )
+{
+ int rank = 0;
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ if ( CHAMELEON_Initialized() ) {
+ rank = CHAMELEON_Comm_rank();
+ }
+#endif
+
+ if (rank == 0) {
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+ printf( "Usage:\n"
+ " %s -o|--op operation_name [options]\n"
+ " %s -f|--file input_file [options]\n",
+ prog_name, prog_name );
+
+ for (i=0; i<nbparams; i++, param++) {
+ char str[STR_MAX_LENGTH];
+
+ /* This is not an option, we skip it */
+ if ( !(param->flags & PARAM_OPTION) ) {
+ continue;
+ }
+
+ /* This is an option header */
+ if ( param->name == NULL ) {
+ printf( "\n %s:\n", param->helper );
+ continue;
+ }
+
+ if ( param->shname > 0 ) {
+ snprintf( str, STR_MAX_LENGTH, "-%c, --%s",
+ param->shname, param->name );
+ }
+ else {
+ snprintf( str, STR_MAX_LENGTH, " --%s",
+ param->name );
+ }
+
+ /* If an argument is needed, add " x" */
+ if ( param->has_arg > 0 ) {
+ int len = strlen(str);
+ assert( len < (STR_MAX_LENGTH-3) );
+
+ str[ len ] = ' ';
+ str[ len+1 ] = 'x';
+ str[ len+2 ] = '\0';
+ }
+ printf( " %-23s %s\n",
+ str, param->helper );
+ }
+
+ printf( "\n"
+ "For example: %s -H -o gemm -t 2 -m 2000 -n 2000 -k 2000 -b 200\n"
+ " will run one gemm with three matrices of size 2000x2000 each and a tile size of 200.\n"
+ " The output will be in the human readable format\n"
+ "\n", prog_name );
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ printf( "Remarks about timing:\n"
+ " Timings are reported respectively as 'tsub' for the graph submission time, and 'time'\n"
+ " for the execution time.\n"
+ " By default the synchronous tile interface is used to perform the timings. 'tsub' is null.\n"
+ " If the --async option is enabled, then the asynchronous interface is called. 'tsub' reports\n"
+ " the task submission time, and 'time' the execution time that includes 'tsub'.\n"
+ " If the --splitsub option is enabled, then the asynchronous interface is called and task\n"
+ " submission is fully performed before starting the computation. 'tsub' reports the\n"
+ " task submission time, and 'time' the execution time excluding 'tsub'.\n"
+ " Note that the 'gflops' field is always computed with 'time'\n" );
+#endif
+ }
+}
+
/**
********************************************************************************
*
@@ -363,3 +538,281 @@ parameters_read_file( const char *filename )
fclose(fp);
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+int
+parameters_compute_q( int p )
+{
+ parameter_t *param;
+ int np = CHAMELEON_Comm_size();
+
+ if ( (np % p) != 0 ) {
+ fprintf( stderr, "ERROR: The number of processes (%d) must be a multiple of P (%d)\n", np, p );
+ exit(1);
+ }
+
+ param = parameters_get( 'Q' );
+ param->value.ival = np / p;
+ return param->value.ival;
+}
+#endif
+
+void
+parameters_getopt_init( char *optstring,
+ struct option **longopts )
+{
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+ int nboptions = 0;
+ int strpos = 0;
+
+ for ( i=0; i<nbparams; i++, param++ ) {
+ /* This is not an option, we skip it */
+ if ( !(param->flags & PARAM_OPTION) ||
+ (param->name == NULL) )
+ {
+ continue;
+ }
+
+ nboptions++;
+
+ if ( param->shname < 0 ) {
+ continue;
+ }
+
+ optstring[strpos] = param->shname;
+ strpos++;
+ assert( strpos < STR_MAX_LENGTH );
+
+ if ( param->has_arg > 0 ) {
+ optstring[strpos] = ':';
+ strpos++;
+ assert( strpos < STR_MAX_LENGTH );
+ }
+ }
+ optstring[strpos] = '\0';
+
+ /* Now, let's generate the long opt if needed */
+#if defined(CHAMELEON_HAVE_GETOPT_LONG)
+ if ( longopts != NULL ) {
+ struct option *opt;
+ *longopts = calloc( nboptions+1, sizeof( struct option ) );
+
+ opt = *longopts;
+ param = parameters;
+
+ for ( i=0; i<nboptions; i++, opt++, param++ ) {
+
+ /* Look for a valid option */
+ while ( !(param->flags & PARAM_OPTION) ||
+ (param->name == NULL) )
+ {
+ param++;
+ }
+
+ opt->name = param->name;
+ opt->has_arg = ( param->has_arg > 0 ) ? 1 : 0;
+ opt->flag = NULL;
+ opt->val = param->shname;
+ }
+ }
+#endif
+}
+
+parameter_t *
+parameters_get( int shname )
+{
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+
+ for ( i=0; i<nbparams; i++, param++ ) {
+ /* This is not an option, we skip it */
+ if ( param->name == NULL ) {
+ continue;
+ }
+
+ if ( shname == param->shname ) {
+ return param;
+ }
+ }
+
+ fprintf( stderr, "parameters_get could not find parameter %d(%c)\n", shname, shname );
+ return NULL;
+}
+
+int
+parameters_getvalue_int( const char *name )
+{
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+
+ for ( i=0; i<nbparams; i++, param++ ) {
+ /* This is not an option, we skip it */
+ if ( param->name == NULL ) {
+ continue;
+ }
+
+ if ( strcasecmp( name, param->name ) != 0 ) {
+ continue;
+ }
+
+ if ( param->has_arg > 1 ) {
+ fprintf( stderr, "parameters_getvalue_int should not be called with parameter %s\n", name );
+ return -1;
+ }
+
+ if ( param->valtype != TestValInt ) {
+ fprintf( stderr, "parameters_getvalue_int has been called with a non integer parameter (%s)\n", name );
+ return -1;
+ }
+
+ return param->value.ival;
+ }
+
+ fprintf( stderr, "parameters_getvalue_int could not find parameter %s\n", name );
+ return -1;
+}
+
+char *
+parameters_getvalue_str( const char *name )
+{
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+
+ for ( i=0; i<nbparams; i++, param++ ) {
+ /* This is not an option, we skip it */
+ if ( param->name == NULL ) {
+ continue;
+ }
+
+ if ( strcasecmp( name, param->name ) != 0 ) {
+ continue;
+ }
+
+ if ( param->has_arg > 1 ) {
+ fprintf( stderr, "parameters_getvalue_str should not be called with parameter %s\n", name );
+ return NULL;
+ }
+
+ if ( param->valtype != TestString ) {
+ fprintf( stderr, "parameters_getvalue_str has been called with a non string parameter (%s)\n", name );
+ return NULL;
+ }
+
+ return param->value.str;
+ }
+
+ fprintf( stderr, "parameters_getvalue_str could not find parameter %s\n", name );
+ return NULL;
+}
+
+parameter_t *
+parameters_getbyname( const char *name )
+{
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+
+ for ( i=0; i<nbparams; i++, param++ ) {
+ /* This is not an option, we skip it */
+ if ( param->name == NULL ) {
+ continue;
+ }
+
+ if ( strcasecmp( name, param->name ) != 0 ) {
+ continue;
+ }
+
+ /* if ( param->has_arg < 2 ) { */
+ /* fprintf( stderr, "parameters_getbyname should not be called with parameter %s\n", name ); */
+ /* return NULL; */
+ /* } */
+
+ return param;
+ }
+
+ fprintf( stderr, "parameters_getbyname could not find parameter %s\n", name );
+ return NULL;
+}
+
+void parameters_parser( int argc, char **argv )
+{
+ int opt;
+ char optstring[STR_MAX_LENGTH];
+ struct option *longopts = NULL;
+ parameter_t *param;
+
+ parameters_getopt_init( optstring, &longopts );
+
+#if defined(CHAMELEON_HAVE_GETOPT_LONG)
+ while ((opt = getopt_long(argc, argv, optstring, longopts, NULL)) != -1)
+#else
+ while ((opt = getopt(argc, argv, optstring)) != -1)
+#endif
+ {
+ switch(opt) {
+ case 'h':
+ print_usage(argv[0]);
+ exit(0);
+
+ case '?': /* error from getopt[_long] */
+ exit(1);
+ break;
+
+ default:
+ param = parameters_get( opt );
+ if ( param == NULL ) {
+ print_usage(argv[0]);
+ exit(1);
+ }
+ parameters_addvalues( param, optarg );
+ }
+ }
+
+ if ( longopts != NULL ) {
+ free( longopts );
+ }
+
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ /* Force Async if splitsub is enabled */
+ {
+ int splitsub = parameters_getvalue_int( "splitsub" );
+
+ if ( splitsub ) {
+ param = parameters_get( 's' );
+ if ( param == NULL ) {
+ print_usage(argv[0]);
+ exit(1);
+ }
+ parameters_addvalues( param, NULL );
+
+#if defined(CHAMELEON_RUNTIME_SYNC)
+ fprintf( stderr, "Spliting the submission and the execution stages is not possible when the option CHAMELEON_RUNTIME_SYNC is enabled\n" );
+ exit(0);
+#endif
+ }
+ }
+#endif
+}
+
+void
+parameters_destroy()
+{
+ parameter_t *param = parameters;
+ int i, nbparams = sizeof( parameters ) / sizeof( parameter_t );
+ vallist_t *current, *next;
+
+ for ( i=0; i<nbparams; i++, param++ ) {
+ /* This is not an option, we skip it */
+ if ( param->has_arg < 2 ) {
+ continue;
+ }
+
+ current = param->vallist;
+ while ( current != NULL )
+ {
+ next = current->next;
+ free( current );
+ current = next;
+ }
+ }
+ return;
+}
\ No newline at end of file
diff --git a/testing/run_list.c b/testing/run_list.c
index f6deec7aa0f52b8ecfec7ed02d3347dad51c4e9f..1d13d861d65084c6d569d1c2deb9a413c2b8b13d 100644
--- a/testing/run_list.c
+++ b/testing/run_list.c
@@ -690,8 +690,11 @@ run_list_destroy( run_list_elt_t *run )
/**
* @brief The common input parameters to all tests
*/
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *common_input[] = { "threads", NULL };
+#else
const char *common_input[] = { "threads", "gpus", "P", "Q", NULL };
-
+#endif
/**
* @brief The common output parameters to all tests
*/
diff --git a/testing/testing_zcesca.c b/testing/testing_zcesca.c
index 32476093aa1421d9fa7bd8f94db10b22215f09f9..71accd144f4ae94606c98acb8ca7527085a4c362 100644
--- a/testing/testing_zcesca.c
+++ b/testing/testing_zcesca.c
@@ -25,7 +25,7 @@ static cham_fixdbl_t
flops_zcesca( int M, int N )
{
cham_fixdbl_t flops = 0.;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
/* 2 multiplications and 5 addition per element */
flops = ( 2. * 6. + 10. ) * M * N;
#else
diff --git a/testing/testing_zgeadd.c b/testing/testing_zgeadd.c
index d807f54a408967300071f9157e654cd1c24a4213..23c149ed0b2dba409ee89dce25c910d2000cb05a 100644
--- a/testing/testing_zgeadd.c
+++ b/testing/testing_zgeadd.c
@@ -26,7 +26,7 @@ static cham_fixdbl_t
flops_zgeadd( int M, int N )
{
cham_fixdbl_t flops = 0.;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
/* 2 multiplications and 1 addition per element */
flops = ( 2. * 6. + 2. ) * M * N;
#else
diff --git a/testing/testing_zgemm.c b/testing/testing_zgemm.c
index 9c63dab977e677fa2628b5b2d8358a3e921055a4..07ef9233c0c94966408795c2d825ddbb5080d18d 100644
--- a/testing/testing_zgemm.c
+++ b/testing/testing_zgemm.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zgemm_desc( run_arg_list_t *args, int check )
{
@@ -130,6 +135,7 @@ testing_zgemm_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zgemm_std( run_arg_list_t *args, int check )
@@ -191,6 +197,12 @@ testing_zgemm_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, C, LDC, seedC );
/* Calculate the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zgemm( CblasColMajor, (CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB, M, N, K,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), C, LDC );
+ testing_stop( &test_data, flops_zgemm( M, N, K ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zgemm( transA, transB, M, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
@@ -205,6 +217,7 @@ testing_zgemm_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( B );
@@ -214,9 +227,15 @@ testing_zgemm_std( run_arg_list_t *args, int check )
}
testing_t test_zgemm;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zgemm_params[] = { "transA", "transB", "m", "n",
+ "k", "lda", "ldb", "ldc", "alpha", "beta",
+ "seedA", "seedB", "seedC", NULL };
+#else
const char *zgemm_params[] = { "mtxfmt", "nb", "transA", "transB", "m", "n",
"k", "lda", "ldb", "ldc", "alpha", "beta",
"seedA", "seedB", "seedC", NULL };
+#endif
const char *zgemm_output[] = { NULL };
const char *zgemm_outchk[] = { "||A||", "||B||", "||C||", "||R||", "RETURN", NULL };
@@ -232,7 +251,11 @@ testing_zgemm_init( void )
test_zgemm.params = zgemm_params;
test_zgemm.output = zgemm_output;
test_zgemm.outchk = zgemm_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zgemm.fptr_desc = NULL;
+#else
test_zgemm.fptr_desc = testing_zgemm_desc;
+#endif
test_zgemm.fptr_std = testing_zgemm_std;
test_zgemm.next = NULL;
diff --git a/testing/testing_zgenm2.c b/testing/testing_zgenm2.c
index 33997db0226941561f2afde769d3ad69c04c24f7..3beff91f0d6db9895ff72a951b8d3a33f0944590 100644
--- a/testing/testing_zgenm2.c
+++ b/testing/testing_zgenm2.c
@@ -31,7 +31,7 @@ static cham_fixdbl_t
flops_zgenm2( int M, int N )
{
double coefabs = 1.;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
coefabs = 3.;
#endif
diff --git a/testing/testing_zgram.c b/testing/testing_zgram.c
index f1d5dec4bf632a92cad62992fc6265919db7c644..b7b8f81cdfe8c0b95580788a91b26bb5c938485f 100644
--- a/testing/testing_zgram.c
+++ b/testing/testing_zgram.c
@@ -25,7 +25,7 @@ static cham_fixdbl_t
flops_zgram( int N )
{
cham_fixdbl_t flops = 0.;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
/* 5 multiplications and 3 addition per element */
flops = ( 5. * 6. + 6. ) * N * N;
#else
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index 90c61d6bc69326792eee3cce7b644aed6fda2c3a..91adb578be68f97034d5e427dd761b5cfa1c53de 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zhemm_desc( run_arg_list_t *args, int check )
{
@@ -113,6 +118,7 @@ testing_zhemm_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zhemm_std( run_arg_list_t *args, int check )
@@ -160,6 +166,12 @@ testing_zhemm_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, C, LDC, seedC );
/* Calculates the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zhemm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, M, N,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), C, LDC );
+ testing_stop( &test_data, flops_zhemm( side, M, N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zhemm( side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
@@ -174,6 +186,7 @@ testing_zhemm_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( B );
@@ -183,8 +196,13 @@ testing_zhemm_std( run_arg_list_t *args, int check )
}
testing_t test_zhemm;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zhemm_params[] = { "side", "uplo", "m", "n", "lda", "ldb",
+ "ldc", "alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
+#else
const char *zhemm_params[] = { "mtxfmt", "nb", "side", "uplo", "m", "n", "lda", "ldb",
"ldc", "alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
+#endif
const char *zhemm_output[] = { NULL };
const char *zhemm_outchk[] = { "RETURN", NULL };
@@ -200,7 +218,11 @@ testing_zhemm_init( void )
test_zhemm.params = zhemm_params;
test_zhemm.output = zhemm_output;
test_zhemm.outchk = zhemm_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zhemm.fptr_desc = NULL;
+#else
test_zhemm.fptr_desc = testing_zhemm_desc;
+#endif
test_zhemm.fptr_std = testing_zhemm_std;
test_zhemm.next = NULL;
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index ab6baa909a5cfd425e7d9e6a9f4da4f22ed72eca..d3e8f2277c3da1eb1bc1471e5f428caebe69010c 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zher2k_desc( run_arg_list_t *args, int check )
{
@@ -115,6 +120,7 @@ testing_zher2k_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zher2k_std( run_arg_list_t *args, int check )
@@ -173,6 +179,12 @@ testing_zher2k_std( run_arg_list_t *args, int check )
CHAMELEON_zplghe( bump, uplo, N, C, LDC, seedC );
/* Calculate the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zher2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, beta, C, LDC );
+ testing_stop( &test_data, flops_zher2k( K, N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zher2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
@@ -187,6 +199,7 @@ testing_zher2k_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( B );
@@ -196,9 +209,15 @@ testing_zher2k_std( run_arg_list_t *args, int check )
}
testing_t test_zher2k;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zher2k_params[] = { "trans", "uplo", "n", "k",
+ "lda", "ldb", "ldc", "alpha", "beta", "seedA",
+ "seedB", "seedC", "bump", NULL };
+#else
const char *zher2k_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k",
"lda", "ldb", "ldc", "alpha", "beta", "seedA",
"seedB", "seedC", "bump", NULL };
+#endif
const char *zher2k_output[] = { NULL };
const char *zher2k_outchk[] = { "RETURN", NULL };
@@ -214,7 +233,11 @@ testing_zher2k_init( void )
test_zher2k.params = zher2k_params;
test_zher2k.output = zher2k_output;
test_zher2k.outchk = zher2k_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zher2k.fptr_desc = NULL;
+#else
test_zher2k.fptr_desc = testing_zher2k_desc;
+#endif
test_zher2k.fptr_std = testing_zher2k_std;
test_zher2k.next = NULL;
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index 62ad2fc0923c5974265be77ba9e892946441632f..b68fec2ac8044997c2cdf4e4ac416512f5f12d1b 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zherk_desc( run_arg_list_t *args, int check )
{
@@ -108,6 +113,7 @@ testing_zherk_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zherk_std( run_arg_list_t *args, int check )
@@ -159,6 +165,12 @@ testing_zherk_std( run_arg_list_t *args, int check )
CHAMELEON_zplghe( bump, uplo, N, C, LDC, seedC );
/* Calculates the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zherk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ alpha, A, LDA, beta, C, LDC );
+ testing_stop( &test_data, flops_zherk( N, K ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zherk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
test_data.hres = hres;
@@ -173,6 +185,7 @@ testing_zherk_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( C );
@@ -181,8 +194,13 @@ testing_zherk_std( run_arg_list_t *args, int check )
}
testing_t test_zherk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zherk_params[] = { "trans", "uplo", "n", "k", "lda",
+ "ldc", "alpha", "beta", "seedA", "seedC", "bump", NULL };
+#else
const char *zherk_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k", "lda",
"ldc", "alpha", "beta", "seedA", "seedC", "bump", NULL };
+#endif
const char *zherk_output[] = { NULL };
const char *zherk_outchk[] = { "RETURN", NULL };
@@ -198,7 +216,11 @@ testing_zherk_init( void )
test_zherk.params = zherk_params;
test_zherk.output = zherk_output;
test_zherk.outchk = zherk_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zherk.fptr_desc = NULL;
+#else
test_zherk.fptr_desc = testing_zherk_desc;
+#endif
test_zherk.fptr_std = testing_zherk_std;
test_zherk.next = NULL;
diff --git a/testing/testing_zlange.c b/testing/testing_zlange.c
index d1b081ed946520fed46a0420d2a4e0e6d589d73c..1511452c0a8cff0b409f3b53bfdf861250b16d98 100644
--- a/testing/testing_zlange.c
+++ b/testing/testing_zlange.c
@@ -22,6 +22,10 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
static cham_fixdbl_t
flops_zlange( cham_normtype_t ntype, int M, int N )
@@ -29,7 +33,7 @@ flops_zlange( cham_normtype_t ntype, int M, int N )
cham_fixdbl_t flops = 0.;
cham_fixdbl_t coefabs = 1.;
cham_fixdbl_t size;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
coefabs = 3.;
#endif
@@ -53,6 +57,7 @@ flops_zlange( cham_normtype_t ntype, int M, int N )
return sizeof( CHAMELEON_Complex64_t ) * size;
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zlange_desc( run_arg_list_t *args, int check )
{
@@ -107,6 +112,7 @@ testing_zlange_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zlange_std( run_arg_list_t *args, int check )
@@ -135,6 +141,12 @@ testing_zlange_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
/* Calculates the norm */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ norm = LAPACKE_zlange( LAPACK_COL_MAJOR, chameleon_lapack_const( norm_type ), M, N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zlange( norm_type, M, N ) );
+#else
testing_start( &test_data );
norm = CHAMELEON_zlange( norm_type, M, N, A, LDA );
test_data.hres = hres;
@@ -144,6 +156,7 @@ testing_zlange_std( run_arg_list_t *args, int check )
if ( check ) {
hres = check_znorm_std( args, ChamGeneral, norm_type, ChamUpperLower, ChamNonUnit, norm, M, N, A, LDA );
}
+#endif
free( A );
@@ -151,7 +164,11 @@ testing_zlange_std( run_arg_list_t *args, int check )
}
testing_t test_zlange;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zlange_params[] = { "norm", "m", "n", "lda", "seedA", NULL };
+#else
const char *zlange_params[] = { "mtxfmt", "nb", "norm", "m", "n", "lda", "seedA", NULL };
+#endif
const char *zlange_output[] = { NULL };
const char *zlange_outchk[] = { "RETURN", NULL };
@@ -167,7 +184,11 @@ testing_zlange_init( void )
test_zlange.params = zlange_params;
test_zlange.output = zlange_output;
test_zlange.outchk = zlange_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zlange.fptr_desc = NULL;
+#else
test_zlange.fptr_desc = testing_zlange_desc;
+#endif
test_zlange.fptr_std = testing_zlange_std;
test_zlange.next = NULL;
diff --git a/testing/testing_zlanhe.c b/testing/testing_zlanhe.c
index a61bdede4b399f2e5dd707cfab620bc9756689b6..23f9a1373e16bd1cd531aad6c0b4554aa511d87e 100644
--- a/testing/testing_zlanhe.c
+++ b/testing/testing_zlanhe.c
@@ -21,6 +21,10 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
static cham_fixdbl_t
flops_zlanhe( cham_normtype_t ntype, int N )
@@ -28,7 +32,7 @@ flops_zlanhe( cham_normtype_t ntype, int N )
cham_fixdbl_t flops = 0.;
cham_fixdbl_t coefabs = 1.;
cham_fixdbl_t size;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
coefabs = 3.;
#endif
@@ -50,6 +54,7 @@ flops_zlanhe( cham_normtype_t ntype, int N )
return sizeof( CHAMELEON_Complex64_t ) * size;
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zlanhe_desc( run_arg_list_t *args, int check )
{
@@ -106,6 +111,7 @@ testing_zlanhe_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zlanhe_std( run_arg_list_t *args, int check )
@@ -137,6 +143,12 @@ testing_zlanhe_std( run_arg_list_t *args, int check )
CHAMELEON_zplghe( bump, uplo, N, A, LDA, seedA );
/* Calculates the norm */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ norm = LAPACKE_zlanhe( LAPACK_COL_MAJOR, chameleon_lapack_const( norm_type ), uplo, N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zlanhe( norm_type, N ) );
+#else
testing_start( &test_data );
norm = CHAMELEON_zlanhe( norm_type, uplo, N, A, LDA );
test_data.hres = hres;
@@ -146,6 +158,7 @@ testing_zlanhe_std( run_arg_list_t *args, int check )
if ( check ) {
hres = check_znorm_std( args, ChamHermitian, norm_type, uplo, ChamNonUnit, norm, N, N, A, LDA );
}
+#endif
free( A );
@@ -153,7 +166,11 @@ testing_zlanhe_std( run_arg_list_t *args, int check )
}
testing_t test_zlanhe;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zlanhe_params[] = { "norm", "uplo", "n", "lda", "seedA", "bump", NULL };
+#else
const char *zlanhe_params[] = { "mtxfmt", "nb", "norm", "uplo", "n", "lda", "seedA", "bump", NULL };
+#endif
const char *zlanhe_output[] = { NULL };
const char *zlanhe_outchk[] = { "RETURN", NULL };
@@ -169,7 +186,11 @@ testing_zlanhe_init( void )
test_zlanhe.params = zlanhe_params;
test_zlanhe.output = zlanhe_output;
test_zlanhe.outchk = zlanhe_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zlanhe.fptr_desc = NULL;
+#else
test_zlanhe.fptr_desc = testing_zlanhe_desc;
+#endif
test_zlanhe.fptr_std = testing_zlanhe_std;
test_zlanhe.next = NULL;
diff --git a/testing/testing_zlansy.c b/testing/testing_zlansy.c
index b671087617638a93bc1e4a8905d6935f1bcc1c74..ff00bbc123bd1caee1500b1d25e91f5a561b0316 100644
--- a/testing/testing_zlansy.c
+++ b/testing/testing_zlansy.c
@@ -21,6 +21,10 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
static cham_fixdbl_t
flops_zlansy( cham_normtype_t ntype, int N )
@@ -28,7 +32,7 @@ flops_zlansy( cham_normtype_t ntype, int N )
cham_fixdbl_t flops = 0.;
cham_fixdbl_t coefabs = 1.;
cham_fixdbl_t size;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
coefabs = 3.;
#endif
@@ -50,6 +54,7 @@ flops_zlansy( cham_normtype_t ntype, int N )
return sizeof( CHAMELEON_Complex64_t ) * size;
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zlansy_desc( run_arg_list_t *args, int check )
{
@@ -106,6 +111,7 @@ testing_zlansy_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zlansy_std( run_arg_list_t *args, int check )
@@ -137,6 +143,12 @@ testing_zlansy_std( run_arg_list_t *args, int check )
CHAMELEON_zplgsy( bump, uplo, N, A, LDA, seedA );
/* Calculates the norm */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ norm = LAPACKE_zlansy( LAPACK_COL_MAJOR, chameleon_lapack_const( norm_type ), uplo, N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zlansy( norm_type, N ) );
+#else
testing_start( &test_data );
norm = CHAMELEON_zlansy( norm_type, uplo, N, A, LDA );
test_data.hres = hres;
@@ -146,6 +158,7 @@ testing_zlansy_std( run_arg_list_t *args, int check )
if ( check ) {
hres = check_znorm_std( args, ChamSymmetric, norm_type, uplo, ChamNonUnit, norm, N, N, A, LDA );
}
+#endif
free( A );
@@ -153,7 +166,11 @@ testing_zlansy_std( run_arg_list_t *args, int check )
}
testing_t test_zlansy;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zlansy_params[] = { "norm", "uplo", "n", "lda", "seedA", "bump", NULL };
+#else
const char *zlansy_params[] = { "mtxfmt", "nb", "norm", "uplo", "n", "lda", "seedA", "bump", NULL };
+#endif
const char *zlansy_output[] = { NULL };
const char *zlansy_outchk[] = { "RETURN", NULL };
@@ -169,7 +186,11 @@ testing_zlansy_init( void )
test_zlansy.params = zlansy_params;
test_zlansy.output = zlansy_output;
test_zlansy.outchk = zlansy_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zlansy.fptr_desc = NULL;
+#else
test_zlansy.fptr_desc = testing_zlansy_desc;
+#endif
test_zlansy.fptr_std = testing_zlansy_std;
test_zlansy.next = NULL;
diff --git a/testing/testing_zlantr.c b/testing/testing_zlantr.c
index 60ad3248daca8e170c7f7c047341c264b13ab22b..e7dc6bdce12fca56e39a5c0011545af76bd265f5 100644
--- a/testing/testing_zlantr.c
+++ b/testing/testing_zlantr.c
@@ -21,6 +21,10 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
static cham_fixdbl_t
flops_zlantr( cham_normtype_t ntype, cham_uplo_t uplo, int M, int N )
@@ -28,7 +32,7 @@ flops_zlantr( cham_normtype_t ntype, cham_uplo_t uplo, int M, int N )
cham_fixdbl_t flops = 0.;
cham_fixdbl_t coefabs = 1.;
cham_fixdbl_t size;
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
coefabs = 3.;
#endif
@@ -73,6 +77,7 @@ flops_zlantr( cham_normtype_t ntype, cham_uplo_t uplo, int M, int N )
return size;
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zlantr_desc( run_arg_list_t *args, int check )
{
@@ -128,6 +133,7 @@ testing_zlantr_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zlantr_std( run_arg_list_t *args, int check )
@@ -158,6 +164,12 @@ testing_zlantr_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
/* Calculates the norm */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ norm = LAPACKE_zlantr( LAPACK_COL_MAJOR, chameleon_lapack_const( norm_type ), uplo, diag, M, N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zlantr( norm_type, uplo, M, N ) );
+#else
testing_start( &test_data );
norm = CHAMELEON_zlantr( norm_type, uplo, diag, M, N, A, LDA );
test_data.hres = hres;
@@ -167,6 +179,7 @@ testing_zlantr_std( run_arg_list_t *args, int check )
if ( check ) {
hres = check_znorm_std( args, ChamTriangular, norm_type, uplo, diag, norm, M, N, A, LDA );
}
+#endif
free( A );
@@ -174,8 +187,13 @@ testing_zlantr_std( run_arg_list_t *args, int check )
}
testing_t test_zlantr;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zlantr_params[] = { "norm", "uplo", "diag",
+ "m", "n", "lda", "seedA", NULL };
+#else
const char *zlantr_params[] = { "mtxfmt", "nb", "norm", "uplo", "diag",
"m", "n", "lda", "seedA", NULL };
+#endif
const char *zlantr_output[] = { NULL };
const char *zlantr_outchk[] = { "||A||", "||B||", "||R||", "RETURN", NULL };
@@ -191,7 +209,11 @@ testing_zlantr_init( void )
test_zlantr.params = zlantr_params;
test_zlantr.output = zlantr_output;
test_zlantr.outchk = zlantr_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zlantr.fptr_desc = NULL;
+#else
test_zlantr.fptr_desc = testing_zlantr_desc;
+#endif
test_zlantr.fptr_std = testing_zlantr_std;
test_zlantr.next = NULL;
diff --git a/testing/testing_zlascal.c b/testing/testing_zlascal.c
index cbd6fcad42bd6d0de598c9d8ea6691db7f379232..407622ca4972a17ac3f5a15416ee1cb1a67859d6 100644
--- a/testing/testing_zlascal.c
+++ b/testing/testing_zlascal.c
@@ -39,7 +39,7 @@ flops_zlascal( cham_uplo_t uplo, int M, int N )
flops = M * N;
}
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
/* 1 multiplications per element */
flops *= 6.;
#endif
diff --git a/testing/testing_zpoinv.c b/testing/testing_zpoinv.c
index 1f6f0eb4bb94f365ea54dea7c5726237778a44cc..03f16efe678e065e69bae5148e5f34609aaa9eb7 100644
--- a/testing/testing_zpoinv.c
+++ b/testing/testing_zpoinv.c
@@ -23,6 +23,10 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
static cham_fixdbl_t
flops_zpoinv( int N )
@@ -31,6 +35,7 @@ flops_zpoinv( int N )
return flops;
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zpoinv_desc( run_arg_list_t *args, int check )
{
@@ -86,6 +91,7 @@ testing_zpoinv_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zpoinv_std( run_arg_list_t *args, int check )
@@ -112,6 +118,13 @@ testing_zpoinv_std( run_arg_list_t *args, int check )
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
/* Calculates the inversed matrix */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ hres = LAPACKE_zpotrf( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, A, LDA );
+ hres += LAPACKE_zpotri( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zpoinv( N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zpoinv( uplo, N, A, LDA );
test_data.hres = hres;
@@ -126,6 +139,7 @@ testing_zpoinv_std( run_arg_list_t *args, int check )
free( A0 );
}
+#endif
free( A );
@@ -133,7 +147,11 @@ testing_zpoinv_std( run_arg_list_t *args, int check )
}
testing_t test_zpoinv;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zpoinv_params[] = { "uplo", "n", "lda", "seedA", NULL };
+#else
const char *zpoinv_params[] = { "mtxfmt", "nb", "uplo", "n", "lda", "seedA", NULL };
+#endif
const char *zpoinv_output[] = { NULL };
const char *zpoinv_outchk[] = { "RETURN", NULL };
@@ -149,7 +167,11 @@ testing_zpoinv_init( void )
test_zpoinv.params = zpoinv_params;
test_zpoinv.output = zpoinv_output;
test_zpoinv.outchk = zpoinv_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zpoinv.fptr_desc = NULL;
+#else
test_zpoinv.fptr_desc = testing_zpoinv_desc;
+#endif
test_zpoinv.fptr_std = testing_zpoinv_std;
test_zpoinv.next = NULL;
diff --git a/testing/testing_zposv.c b/testing/testing_zposv.c
index 9392339ab4a602b1499d23df8fe4ed5bb57e6c98..0c0fcdac33f694378e8fb0dfd8043d167fe3843d 100644
--- a/testing/testing_zposv.c
+++ b/testing/testing_zposv.c
@@ -22,6 +22,10 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
static cham_fixdbl_t
flops_zposv( int N, int NRHS )
@@ -30,6 +34,7 @@ flops_zposv( int N, int NRHS )
return flops;
}
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zposv_desc( run_arg_list_t *args, int check )
{
@@ -105,6 +110,7 @@ testing_zposv_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zposv_std( run_arg_list_t *args, int check )
@@ -136,6 +142,12 @@ testing_zposv_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( N, NRHS, X, LDB, seedB );
/* Calculates the solution */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ hres = LAPACKE_zposv( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, NRHS, A, LDA, X, LDB );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zposv( N, NRHS ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zposv( uplo, N, NRHS, A, LDA, X, LDB );
test_data.hres = hres;
@@ -160,6 +172,7 @@ testing_zposv_std( run_arg_list_t *args, int check )
free( A0 );
free( B );
}
+#endif
free( A );
free( X );
@@ -168,8 +181,13 @@ testing_zposv_std( run_arg_list_t *args, int check )
}
testing_t test_zposv;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zposv_params[] = { "uplo", "n", "nrhs",
+ "lda", "ldb", "seedA", "seedB", NULL };
+#else
const char *zposv_params[] = { "mtxfmt", "nb", "uplo", "n", "nrhs",
"lda", "ldb", "seedA", "seedB", NULL };
+#endif
const char *zposv_output[] = { NULL };
const char *zposv_outchk[] = { "||A||", "||A-fact(A)||", "||X||", "||B||", "||Ax-b||", "||Ax-b||/N/eps/(||A||||x||+||b||", "RETURN", NULL };
@@ -185,7 +203,11 @@ testing_zposv_init( void )
test_zposv.params = zposv_params;
test_zposv.output = zposv_output;
test_zposv.outchk = zposv_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zposv.fptr_desc = NULL;
+#else
test_zposv.fptr_desc = testing_zposv_desc;
+#endif
test_zposv.fptr_std = testing_zposv_std;
test_zposv.next = NULL;
diff --git a/testing/testing_zpotrf.c b/testing/testing_zpotrf.c
index f28b6edcb82413da628014790650b1b24e805c8c..635fd9f12fdd631030a42c175d5b74182edaa71e 100644
--- a/testing/testing_zpotrf.c
+++ b/testing/testing_zpotrf.c
@@ -21,7 +21,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zpotrf_desc( run_arg_list_t *args, int check )
{
@@ -78,6 +83,7 @@ testing_zpotrf_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zpotrf_std( run_arg_list_t *args, int check )
@@ -104,6 +110,12 @@ testing_zpotrf_std( run_arg_list_t *args, int check )
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
/* Calculates the solution */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ hres = LAPACKE_zpotrf( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zpotrf( N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zpotrf( uplo, N, A, LDA );
test_data.hres = hres;
@@ -118,6 +130,7 @@ testing_zpotrf_std( run_arg_list_t *args, int check )
free( A0 );
}
+#endif
free( A );
@@ -125,7 +138,11 @@ testing_zpotrf_std( run_arg_list_t *args, int check )
}
testing_t test_zpotrf;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zpotrf_params[] = { "uplo", "n", "lda", "seedA", NULL };
+#else
const char *zpotrf_params[] = { "mtxfmt", "nb", "uplo", "n", "lda", "seedA", NULL };
+#endif
const char *zpotrf_output[] = { NULL };
const char *zpotrf_outchk[] = { "RETURN", NULL };
@@ -141,7 +158,11 @@ testing_zpotrf_init( void )
test_zpotrf.params = zpotrf_params;
test_zpotrf.output = zpotrf_output;
test_zpotrf.outchk = zpotrf_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zpotrf.fptr_desc = NULL;
+#else
test_zpotrf.fptr_desc = testing_zpotrf_desc;
+#endif
test_zpotrf.fptr_std = testing_zpotrf_std;
test_zpotrf.next = NULL;
diff --git a/testing/testing_zpotri.c b/testing/testing_zpotri.c
index 863b290b1bf042e741a2555400dde46f9a85f024..19c075e600422c5d88a1e5808a5e844cbb163432 100644
--- a/testing/testing_zpotri.c
+++ b/testing/testing_zpotri.c
@@ -23,7 +23,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zpotri_desc( run_arg_list_t *args, int check )
{
@@ -82,6 +87,7 @@ testing_zpotri_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zpotri_std( run_arg_list_t *args, int check )
@@ -107,10 +113,20 @@ testing_zpotri_std( run_arg_list_t *args, int check )
/* Initialise the matrix with the random values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ hres = LAPACKE_zpotrf( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, A, LDA );
+#else
hres = CHAMELEON_zpotrf( uplo, N, A, LDA );
+#endif
assert( hres == 0 );
/* Calculates the inversed matrix */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ hres += LAPACKE_zpotri( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, A, LDA );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zpotri( N ) );
+#else
testing_start( &test_data );
hres += CHAMELEON_zpotri( uplo, N, A, LDA );
test_data.hres = hres;
@@ -125,6 +141,7 @@ testing_zpotri_std( run_arg_list_t *args, int check )
free( A0 );
}
+#endif
free( A );
@@ -132,7 +149,11 @@ testing_zpotri_std( run_arg_list_t *args, int check )
}
testing_t test_zpotri;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zpotri_params[] = { "uplo", "n", "lda", "seedA", NULL };
+#else
const char *zpotri_params[] = { "mtxfmt", "nb", "uplo", "n", "lda", "seedA", NULL };
+#endif
const char *zpotri_output[] = { NULL };
const char *zpotri_outchk[] = { "RETURN", NULL };
@@ -148,7 +169,11 @@ testing_zpotri_init( void )
test_zpotri.params = zpotri_params;
test_zpotri.output = zpotri_output;
test_zpotri.outchk = zpotri_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zpotri.fptr_desc = NULL;
+#else
test_zpotri.fptr_desc = testing_zpotri_desc;
+#endif
test_zpotri.fptr_std = testing_zpotri_std;
test_zpotri.next = NULL;
diff --git a/testing/testing_zpotrs.c b/testing/testing_zpotrs.c
index 26cc02419761a46ece0465f3cb7f526bb0746862..766dd8a525c67a4575490ba4510ada5ebc650a0e 100644
--- a/testing/testing_zpotrs.c
+++ b/testing/testing_zpotrs.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/lapacke.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zpotrs_desc( run_arg_list_t *args, int check )
{
@@ -94,6 +99,7 @@ testing_zpotrs_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zpotrs_std( run_arg_list_t *args, int check )
@@ -124,10 +130,20 @@ testing_zpotrs_std( run_arg_list_t *args, int check )
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
CHAMELEON_zplrnt( N, NRHS, X, LDB, seedB );
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ hres = LAPACKE_zpotrf( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, A, LDA );
+#else
hres = CHAMELEON_zpotrf( uplo, N, A, LDA );
+#endif
assert( hres == 0 );
/* Calculates the solution */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ hres += LAPACKE_zpotrs( LAPACK_COL_MAJOR, chameleon_lapack_const(uplo), N, NRHS, A, LDA, X, LDB );
+ test_data.hres = hres;
+ testing_stop( &test_data, flops_zpotrs( N, NRHS ) );
+#else
testing_start( &test_data );
hres += CHAMELEON_zpotrs( uplo, N, NRHS, A, LDA, X, LDB );
test_data.hres = hres;
@@ -146,6 +162,7 @@ testing_zpotrs_std( run_arg_list_t *args, int check )
free( A0 );
free( B );
}
+#endif
free( A );
free( X );
@@ -154,8 +171,13 @@ testing_zpotrs_std( run_arg_list_t *args, int check )
}
testing_t test_zpotrs;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zpotrs_params[] = { "uplo", "n", "nrhs",
+ "lda", "ldb", "seedA", "seedB", NULL };
+#else
const char *zpotrs_params[] = { "mtxfmt", "nb", "uplo", "n", "nrhs",
"lda", "ldb", "seedA", "seedB", NULL };
+#endif
const char *zpotrs_output[] = { NULL };
const char *zpotrs_outchk[] = { "||A||", "||A-fact(A)||", "||X||", "||B||", "||Ax-b||", "||Ax-b||/N/eps/(||A||||x||+||b||", "RETURN", NULL };
@@ -171,7 +193,11 @@ testing_zpotrs_init( void )
test_zpotrs.params = zpotrs_params;
test_zpotrs.output = zpotrs_output;
test_zpotrs.outchk = zpotrs_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zpotrs.fptr_desc = NULL;
+#else
test_zpotrs.fptr_desc = testing_zpotrs_desc;
+#endif
test_zpotrs.fptr_std = testing_zpotrs_std;
test_zpotrs.next = NULL;
diff --git a/testing/testing_zsymm.c b/testing/testing_zsymm.c
index 4acb798037c3a2a4ba331a70edddd510f6791f48..377848b643ab489775a39795fe79bec00d855201 100644
--- a/testing/testing_zsymm.c
+++ b/testing/testing_zsymm.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zsymm_desc( run_arg_list_t *args, int check )
{
@@ -113,6 +118,7 @@ testing_zsymm_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zsymm_std( run_arg_list_t *args, int check )
@@ -160,6 +166,12 @@ testing_zsymm_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, C, LDC, seedC );
/* Calculates the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zsymm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, M, N,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), C, LDC );
+ testing_stop( &test_data, flops_zsymm( side, M, N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zsymm( side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
@@ -174,6 +186,7 @@ testing_zsymm_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( B );
@@ -183,8 +196,13 @@ testing_zsymm_std( run_arg_list_t *args, int check )
}
testing_t test_zsymm;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zsymm_params[] = { "side", "uplo", "m", "n", "lda", "ldb",
+ "ldc", "alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
+#else
const char *zsymm_params[] = { "mtxfmt", "nb", "side", "uplo", "m", "n", "lda", "ldb",
"ldc", "alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
+#endif
const char *zsymm_output[] = { NULL };
const char *zsymm_outchk[] = { "RETURN", NULL };
@@ -200,7 +218,11 @@ testing_zsymm_init( void )
test_zsymm.params = zsymm_params;
test_zsymm.output = zsymm_output;
test_zsymm.outchk = zsymm_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zsymm.fptr_desc = NULL;
+#else
test_zsymm.fptr_desc = testing_zsymm_desc;
+#endif
test_zsymm.fptr_std = testing_zsymm_std;
test_zsymm.next = NULL;
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index fd75192357ffbe20091d51c9871fbaf720bd84cd..830cc5ea688fc5f604681398ba3bb673c41b8e9e 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zsyr2k_desc( run_arg_list_t *args, int check )
{
@@ -115,6 +120,7 @@ testing_zsyr2k_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zsyr2k_std( run_arg_list_t *args, int check )
@@ -173,6 +179,12 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
CHAMELEON_zplgsy( bump, uplo, N, C, LDC, seedC );
/* Calculate the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zsyr2k( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), C, LDC );
+ testing_stop( &test_data, flops_zher2k( N, K ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zsyr2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
@@ -187,6 +199,7 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( B );
@@ -196,9 +209,15 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
}
testing_t test_zsyr2k;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zsyr2k_params[] = { "trans", "uplo", "n", "k",
+ "lda", "ldb", "ldc", "alpha", "beta", "seedA",
+ "seedB", "seedC", "bump", NULL };
+#else
const char *zsyr2k_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k",
"lda", "ldb", "ldc", "alpha", "beta", "seedA",
"seedB", "seedC", "bump", NULL };
+#endif
const char *zsyr2k_output[] = { NULL };
const char *zsyr2k_outchk[] = { "||A||", "||B||", "||C||", "||R||", "RETURN", NULL };
@@ -214,7 +233,11 @@ testing_zsyr2k_init( void )
test_zsyr2k.params = zsyr2k_params;
test_zsyr2k.output = zsyr2k_output;
test_zsyr2k.outchk = zsyr2k_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zsyr2k.fptr_desc = NULL;
+#else
test_zsyr2k.fptr_desc = testing_zsyr2k_desc;
+#endif
test_zsyr2k.fptr_std = testing_zsyr2k_std;
test_zsyr2k.next = NULL;
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index 2b2b4ec151c5b97f6b8d7b837fdcc267a13fedd9..226e5093f210290c9b42cbdab490fe624295d343 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_zsyrk_desc( run_arg_list_t *args, int check )
{
@@ -108,6 +113,7 @@ testing_zsyrk_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_zsyrk_std( run_arg_list_t *args, int check )
@@ -158,6 +164,12 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
CHAMELEON_zplgsy( bump, uplo, N, C, LDC, seedC );
/* Calculates the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_zsyrk( CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans, N, K,
+ CBLAS_SADDR(alpha), A, LDA, CBLAS_SADDR(beta), C, LDC );
+ testing_stop( &test_data, flops_zsyrk( K, N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_zsyrk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
test_data.hres = hres;
@@ -172,6 +184,7 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
free( Cinit );
}
+#endif
free( A );
free( C );
@@ -180,8 +193,13 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
}
testing_t test_zsyrk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *zsyrk_params[] = { "trans", "uplo", "n", "k", "lda",
+ "ldc", "alpha", "beta", "seedA", "seedC", "bump", NULL };
+#else
const char *zsyrk_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k", "lda",
"ldc", "alpha", "beta", "seedA", "seedC", "bump", NULL };
+#endif
const char *zsyrk_output[] = { NULL };
const char *zsyrk_outchk[] = { "RETURN", NULL };
@@ -197,7 +215,11 @@ testing_zsyrk_init( void )
test_zsyrk.params = zsyrk_params;
test_zsyrk.output = zsyrk_output;
test_zsyrk.outchk = zsyrk_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_zsyrk.fptr_desc = NULL;
+#else
test_zsyrk.fptr_desc = testing_zsyrk_desc;
+#endif
test_zsyrk.fptr_std = testing_zsyrk_std;
test_zsyrk.next = NULL;
diff --git a/testing/testing_ztradd.c b/testing/testing_ztradd.c
index 084b2530950bd3c76410c481c1f14541bc4378b3..5cd83279c61f5ef26e32b868fdcf727f79d8522b 100644
--- a/testing/testing_ztradd.c
+++ b/testing/testing_ztradd.c
@@ -39,7 +39,7 @@ flops_ztradd( cham_uplo_t uplo, int M, int N )
flops = M * N;
}
-#if defined( PRECISION_z ) || defined( PRECISION_c )
+#if defined(PRECISION_z) || defined(PRECISION_c)
/* 2 multiplications and 1 addition per element */
flops *= ( 2. * 6. + 2. );
#else
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index 8eeb605c1b472ae8c4acd7c702fc82120c80448e..92d110468666614090d1a8668c11b386405c0401 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_ztrmm_desc( run_arg_list_t *args, int check )
{
@@ -103,6 +108,7 @@ testing_ztrmm_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_ztrmm_std( run_arg_list_t *args, int check )
@@ -144,6 +150,12 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, B, LDB, seedB );
/* Calculates the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_ztrmm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ (CBLAS_DIAG)diag, M, N, CBLAS_SADDR(alpha), A, LDA, B, LDB );
+ testing_stop( &test_data, flops_ztrmm( side, N, M ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_ztrmm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
test_data.hres = hres;
@@ -158,6 +170,7 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
free( Binit );
}
+#endif
free( A );
free( B );
@@ -166,8 +179,13 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
}
testing_t test_ztrmm;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *ztrmm_params[] = { "trans", "side", "uplo", "diag", "m",
+ "n", "lda", "ldb", "alpha", "seedA", "seedB", NULL };
+#else
const char *ztrmm_params[] = { "mtxfmt", "nb", "trans", "side", "uplo", "diag", "m",
"n", "lda", "ldb", "alpha", "seedA", "seedB", NULL };
+#endif
const char *ztrmm_output[] = { NULL };
const char *ztrmm_outchk[] = { "RETURN", NULL };
@@ -183,7 +201,11 @@ testing_ztrmm_init( void )
test_ztrmm.params = ztrmm_params;
test_ztrmm.output = ztrmm_output;
test_ztrmm.outchk = ztrmm_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_ztrmm.fptr_desc = NULL;
+#else
test_ztrmm.fptr_desc = testing_ztrmm_desc;
+#endif
test_ztrmm.fptr_std = testing_ztrmm_std;
test_ztrmm.next = NULL;
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index 62301de4e9727c1e857b0e4ccd4ffdf55ba5f7c4..fcb00542fc495ed8a24c5c0a90e50305521fd24e 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -22,7 +22,12 @@
#include "testings.h"
#include "testing_zcheck.h"
#include <chameleon/flops.h>
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+#include <coreblas/cblas.h>
+#include <coreblas.h>
+#endif
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
int
testing_ztrsm_desc( run_arg_list_t *args, int check )
{
@@ -97,6 +102,7 @@ testing_ztrsm_desc( run_arg_list_t *args, int check )
return hres;
}
+#endif
int
testing_ztrsm_std( run_arg_list_t *args, int check )
@@ -136,6 +142,12 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
CHAMELEON_zplrnt( M, N, B, LDB, seedB );
/* Calculates the product */
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ testing_start( &test_data );
+ cblas_ztrsm( CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
+ (CBLAS_DIAG)diag, M, N, CBLAS_SADDR(alpha), A, LDA, B, LDB );
+ testing_stop( &test_data, flops_ztrsm( side, M, N ) );
+#else
testing_start( &test_data );
hres = CHAMELEON_ztrsm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
test_data.hres = hres;
@@ -150,6 +162,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
free( Binit );
}
+#endif
free( A );
free( B );
@@ -158,8 +171,13 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
}
testing_t test_ztrsm;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+const char *ztrsm_params[] = { "side", "uplo", "trans", "diag", "m",
+ "n", "lda", "ldb", "alpha", "seedA", "seedB", NULL };
+#else
const char *ztrsm_params[] = { "mtxfmt", "nb", "side", "uplo", "trans", "diag", "m",
"n", "lda", "ldb", "alpha", "seedA", "seedB", NULL };
+#endif
const char *ztrsm_output[] = { NULL };
const char *ztrsm_outchk[] = { "RETURN", NULL };
@@ -175,7 +193,11 @@ testing_ztrsm_init( void )
test_ztrsm.params = ztrsm_params;
test_ztrsm.output = ztrsm_output;
test_ztrsm.outchk = ztrsm_outchk;
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ test_ztrsm.fptr_desc = NULL;
+#else
test_ztrsm.fptr_desc = testing_ztrsm_desc;
+#endif
test_ztrsm.fptr_std = testing_ztrsm_std;
test_ztrsm.next = NULL;
diff --git a/testing/testings.c b/testing/testings.c
new file mode 100644
index 0000000000000000000000000000000000000000..09e1d91bee09adbffd045816fa46538b94ff4bb0
--- /dev/null
+++ b/testing/testings.c
@@ -0,0 +1,178 @@
+/**
+ *
+ * @file testings.c
+ *
+ * @copyright 2019-2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ ***
+ *
+ * @brief Chameleon auxiliary routines for testing structures
+ *
+ * @version 1.2.0
+ * @author Lucas Barros de Assis
+ * @author Mathieu Faverge
+ * @author Alycia Lisito
+ * @date 2022-03-01
+ *
+ */
+#include "testings.h"
+
+/**
+ * @brief List of all the testings available.
+ */
+static testing_t *testings = NULL;
+
+/**
+ * @brief Function to register a new testing
+ */
+void
+testing_register( testing_t *test )
+{
+ assert( test->next == NULL );
+ test->next = testings;
+ testings = test;
+}
+
+/**
+ * @brief Get the testing structure associated to a test
+ */
+testing_t *
+testing_gettest( const char *prog_name,
+ const char *func_name )
+{
+ testing_t *test = testings;
+ int rank = 0;
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ rank = CHAMELEON_Comm_rank();
+#endif
+
+ if ( func_name == NULL ) {
+ print_usage( prog_name );
+ exit(1);
+ }
+
+ while( test != NULL ) {
+ /* Check the name with and without the precision */
+ if ( (strcasecmp( func_name, test->name ) == 0) ||
+ (strcasecmp( func_name, test->name + 1 ) == 0) )
+ {
+ break;
+ }
+ test = test->next;
+ }
+
+ if ( test == NULL ) {
+ if ( rank == 0 ) {
+ printf( "Operation %s not found\n", func_name );
+ printf( "The available operations are:\n" );
+ test = testings;
+ while( test != NULL ) {
+ printf( " %-10s %s\n", test->name, test->helper );
+ test = test->next;
+ }
+ }
+ exit(1);
+ }
+
+ return test;
+}
+
+/**
+ * @brief Starts the measure for the testing.
+ */
+void
+testing_start( testdata_t *tdata )
+{
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ /*
+ * If we test the vendor functions, we want to use all the threads of the
+ * machine and in order to do so we need to free the thread of the Chameleon
+ * scheduler.
+ */
+ CHAMELEON_Pause();
+#else
+ int splitsub = parameters_getvalue_int( "splitsub" );
+ int async = parameters_getvalue_int( "async" ) || splitsub;
+#endif
+
+ tdata->sequence = NULL;
+ tdata->request.status = 0;
+ tdata->request.schedopt = NULL;
+
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+#if defined(CHAMELEON_USE_MPI)
+ CHAMELEON_Distributed_start();
+#endif
+
+ if ( async ) {
+ CHAMELEON_Sequence_Create( &(tdata->sequence) );
+ }
+
+ if ( splitsub ) {
+ CHAMELEON_Pause();
+ }
+#endif
+
+ /* Register starting time */
+ tdata->tsub = RUNTIME_get_time();
+ tdata->texec = tdata->tsub;
+}
+
+/**
+ * @brief Stops the measure for the testing.
+ */
+void
+testing_stop( testdata_t *tdata, cham_fixdbl_t flops )
+{
+ cham_fixdbl_t t0, t1, t2, gflops;
+
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ int splitsub = parameters_getvalue_int( "splitsub" );
+ int async = parameters_getvalue_int( "async" ) || splitsub;
+
+ /* Submission is done, we need to start the computations */
+ if ( async ) {
+ tdata->tsub = RUNTIME_get_time();
+ if ( splitsub ) {
+ CHAMELEON_Resume();
+ }
+ CHAMELEON_Sequence_Wait( tdata->sequence );
+ CHAMELEON_Sequence_Destroy( tdata->sequence );
+ }
+#if defined(CHAMELEON_USE_MPI)
+ CHAMELEON_Distributed_stop();
+#endif
+#endif
+ t2 = RUNTIME_get_time();
+
+ t0 = tdata->texec;
+ t1 = tdata->tsub;
+ /*
+ * texec / Submission / tsub / Execution / t
+ *
+ * => texec = t2 - t1
+ * => tsub = t1 - t0
+ */
+ tdata->tsub = t1 - t0;
+ tdata->texec = t2 - t0;
+
+#if !defined(CHAMELEON_TESTINGS_VENDOR)
+ if ( splitsub ) {
+ tdata->texec = t2 - t1;
+ }
+#endif
+
+ gflops = flops * 1.e-9 / tdata->texec;
+ run_arg_add_fixdbl( tdata->args, "time", tdata->texec );
+ run_arg_add_fixdbl( tdata->args, "tsub", tdata->tsub );
+ run_arg_add_fixdbl( tdata->args, "gflops", ( tdata->hres == CHAMELEON_SUCCESS ) ? gflops : -1. );
+
+#if defined(CHAMELEON_TESTINGS_VENDOR)
+ /*
+ * If we test the vendor functions, we now want to resume all the threads of
+ * the machine in order to do the check and potentially the next matrix
+ * initialization.
+ */
+ CHAMELEON_Resume();
+#endif
+}
diff --git a/testing/testings.h b/testing/testings.h
index 06d6cde4e923090c71c05ab9017f881fdd50624a..a938f45b746927e84aa5893df42af24315e17ff1 100644
--- a/testing/testings.h
+++ b/testing/testings.h
@@ -25,6 +25,13 @@
#include <math.h>
#include <string.h>
#include <strings.h>
+#if defined(CHAMELEON_HAVE_GETOPT_LONG)
+#include <getopt.h>
+#else
+struct option;
+#endif
+
+#define STR_MAX_LENGTH 256
typedef enum valtype_ {
TestValInt,
@@ -162,6 +169,8 @@ val_t pread_string ( const char *str );
#define pread_fixdbl pread_double
+void print_usage( const char* prog_name );
+
char *sprint_int ( val_t val, int human, int nbchar, char *str_in );
char *sprint_float ( val_t val, int human, int nbchar, char *str_in );
char *sprint_double ( val_t val, int human, int nbchar, char *str_in );
@@ -213,13 +222,20 @@ void parameters_addvalues( parameter_t *param, const char *values );
int parameters_getvalue_int( const char *name );
int parameters_compute_q( int p );
parameter_t *parameters_get( int shname );
+int parameters_compute_q( int p );
+void parameters_getopt_init( char *optstring, struct option **longopts );
+parameter_t *parameters_get( int shname );
+int parameters_getvalue_int( const char *name );
+char * parameters_getvalue_str( const char *name );
+parameter_t *parameters_getbyname( const char *name );
+void parameters_parser( int argc, char **argv );
+void parameters_destroy( );
run_list_t *run_list_generate( const char **params );
void run_list_destroy( run_list_elt_t *run );
void testing_register( testing_t *test );
-
/**
* @brief Define the data associated to a single run of a testing
*/
@@ -236,7 +252,9 @@ typedef struct testdata_ {
RUNTIME_request_t request; /**< The request to run the test if splitsub */
} testdata_t;
-void testing_start( testdata_t *tdata );
-void testing_stop( testdata_t *tdata, cham_fixdbl_t flops );
+void testing_register( testing_t *test );
+testing_t *testing_gettest( const char *prog_name, const char *func_name );
+void testing_start( testdata_t *tdata );
+void testing_stop( testdata_t *tdata, cham_fixdbl_t flops );
#endif /* _testings_h_ */
diff --git a/testing/vendor_ztesting.c b/testing/vendor_ztesting.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a8e37183768914f7df7aec7b1483e686a246c73
--- /dev/null
+++ b/testing/vendor_ztesting.c
@@ -0,0 +1,115 @@
+/**
+ *
+ * @file vendor_ztesting.c
+ *
+ * @copyright 2009-2014 The University of Tennessee and The University of
+ * Tennessee Research Foundation. All rights reserved.
+ * @copyright 2012-2022 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+ * Univ. Bordeaux. All rights reserved.
+ *
+ ***
+ *
+ * @brief MKL CHAMELEON_Complex64_t auxiliary testings routines
+ *
+ * @version 1.1.0
+ * @author Alycia Lisito
+ * @date 2022-02-25
+ * @precisions normal z -> c d s
+ *
+ */
+#include "testings.h"
+
+int main (int argc, char **argv) {
+
+ int ncores, human, i, niter;
+ int nowarmup;
+ int rc, info, check = 0;
+ int run_id = 0;
+ char *func_name;
+ char *input_file;
+ run_list_t *runlist;
+ testing_t * test;
+ run_list_elt_t *run, *next;
+
+ /* Reads the arguments from command line */
+ parameters_parser( argc, argv );
+ input_file = parameters_getvalue_str( "file" );
+ if ( input_file != NULL ) {
+ parameters_read_file( input_file );
+ free(input_file);
+ }
+ ncores = parameters_getvalue_int( "threads" );
+ human = parameters_getvalue_int( "human" );
+ func_name = parameters_getvalue_str( "op" );
+ niter = parameters_getvalue_int( "niter" );
+ nowarmup = parameters_getvalue_int( "nowarmup" );
+
+ rc = CHAMELEON_Init( ncores, 0 );
+ if ( rc != CHAMELEON_SUCCESS ) {
+ fprintf( stderr, "CHAMELEON_Init failed and returned %d.\n", rc );
+ info = 1;
+ goto end;
+ }
+
+ /* Set ncores to the right value */
+ if ( ncores == -1 ) {
+ parameter_t *param;
+ param = parameters_get( 't' );
+ param->value.ival = CHAMELEON_GetThreadNbr();
+ }
+
+ /* Binds the right function to be called and builds the parameters combinations */
+ test = testing_gettest( argv[0], func_name );
+ free(func_name);
+ test_fct_t fptr = test->fptr_std;
+ if ( fptr == NULL ) {
+ fprintf( stderr, "The vendor API is not available for function %s\n", func_name );
+ info = 1;
+ goto end;
+ }
+
+ /* Generate the cartesian product of the parameters */
+ runlist = run_list_generate( test->params );
+
+ /* Executes the tests */
+ run_print_header( test, check, human );
+ run = runlist->head;
+
+ /* Warmup */
+ if ( !nowarmup ) {
+ run_arg_list_t copy = run_arg_list_copy( &(run->args) );
+ fptr( ©, check );
+ run_arg_list_destroy( © );
+ }
+
+ /* Perform all runs */
+ while ( run != NULL ) {
+ for(i=0; i<niter; i++) {
+ run_arg_list_t copy = run_arg_list_copy( &(run->args) );
+ rc = fptr( ©, check );
+
+ /* If rc < 0, we skipped the test */
+ if ( rc >= 0 ) {
+ run_arg_add_int( ©, "RETURN", rc );
+ run_print_line( test, ©, check, human, run_id );
+ run_id++;
+ info += rc;
+ }
+ run_arg_list_destroy( © );
+ }
+
+ /* Move to next run */
+ next = run->next;
+ run_list_destroy( run );
+ run = next;
+ }
+
+ free( runlist );
+
+ end:
+ ;/* OpenMP end */
+ CHAMELEON_Finalize();
+ parameters_destroy();
+
+ return info;
+}