Merge branch 'feature/eztrace/tcore' into 'master'

add eztrace module for TCORE_ functions

See merge request solverstack/chameleon!181

CMakeLists.txt

@@ -184,13 +184,6 @@ if (CHAMELEON_ENABLE_CUDA AND NOT CHAMELEON_USE_CUDA)
     message("-- ${BoldGreen}CHAMELEON_USE_CUDA is set to OFF, turn it ON to use CUDA (unsupported by Quark)${ColourReset}")
 endif()
 
-# Enable FXT if StarPU
-option(CHAMELEON_ENABLE_TRACING "Enable tracing support" OFF)
-if (NOT CHAMELEON_ENABLE_TRACING)
-    message("-- ${BoldGreen}CHAMELEON_ENABLE_TRACING is set to OFF, turn it ON to use FxT (with StarPU)${ColourReset}")
-endif()
-#option(CHAMELEON_USE_EZTRACE "Enable EZTRACE to build modules" OFF)
-
 option(CHAMELEON_RUNTIME_SYNC "Enable synchronous task submission when available to debug the code without parallelism" OFF)
 if (CHAMELEON_RUNTIME_SYNC)
     message("-- ${BoldGreen}CHAMELEON_RUNTIME_SYNC is set to ON, turn it OFF to avoid synchronisation in the tasks submission${ColourReset}")
@@ -605,9 +598,6 @@ if( CHAMELEON_SCHED_STARPU )
     if(CHAMELEON_USE_MPI)
         list(APPEND STARPU_COMPONENT_LIST "MPI")
     endif()
-    if(CHAMELEON_ENABLE_TRACING)
-        list(APPEND STARPU_COMPONENT_LIST "FXT")
-    endif()
 
     find_package(STARPU ${CHAMELEON_STARPU_VERSION} REQUIRED
                  COMPONENTS ${STARPU_COMPONENT_LIST})
@@ -673,18 +663,6 @@ if( CHAMELEON_SCHED_STARPU )
             set(CHAMELEON_USE_MIGRATE "OFF")
             message("-- ${Blue}CHAMELEON_USE_MIGRATE is turned OFF because starpu_mpi_data_migrate not found${ColourReset}")
         endif()
-        if(CHAMELEON_ENABLE_TRACING)
-            # check if fxt profiling is accessible in starpu and activate it in chameleon
-            check_function_exists(starpu_fxt_start_profiling HAVE_STARPU_FXT_PROFILING)
-            if ( HAVE_STARPU_FXT_PROFILING )
-                message("-- ${Blue}Add definition HAVE_STARPU_FXT_PROFILING"
-                " - Activate FxT profiling through StarPU${ColourReset}")
-            else()
-                message("-- ${Red}Looking for starpu with fxt"
-                " - starpu_fxt_start_profiling() test fails in StarPU${ColourReset}")
-                message("-- ${Red}Check in CMakeFiles/CMakeError.log to figure out why it fails${ColourReset}")
-            endif()
-        endif()
         if (CHAMELEON_USE_MPI)
             # Check if a specific function exist
             check_function_exists(starpu_mpi_data_register_comm HAVE_STARPU_MPI_DATA_REGISTER)
@@ -716,14 +694,6 @@ if( CHAMELEON_SCHED_STARPU )
                     Print_Find_Library_Status(hwloc libhwloc)
                 endif ()
             endif()
-            if(CHAMELEON_ENABLE_TRACING AND (NOT FXT_FOUND OR NOT FXT_LIBRARIES))
-                if (NOT FXT_fxt.h_DIRS)
-                    Print_Find_Header_Status(fxt fxt.h)
-                endif ()
-                if (NOT FXT_fxt_LIBRARY)
-                    Print_Find_Library_Status(fxt libfxt)
-                endif ()
-            endif()
             if(CHAMELEON_SIMULATION AND (NOT SIMGRID_FOUND OR NOT SIMGRID_LIBRARIES))
                 if (NOT SIMGRID_simgrid.h_DIRS)
                     Print_Find_Header_Status(simgrid simgrid.h)
@@ -758,9 +728,6 @@ if( CHAMELEON_SCHED_STARPU )
         if(CHAMELEON_SIMULATION AND (NOT SIMGRID_FOUND OR NOT SIMGRID_LIBRARIES))
             message(FATAL_ERROR "SimGrid library is required but has not been found")
         endif()
-        if(CHAMELEON_ENABLE_TRACING AND (NOT FXT_FOUND OR NOT FXT_LIBRARIES))
-            message(FATAL_ERROR "FxT library is required but has not been found")
-        endif()
         if( (NOT STARPU_SHM_FOUND) OR (NOT STARPU_SHM_LIBRARIES) OR
             ( STARPU_LOOK_FOR_MPI AND (NOT STARPU_MPI_FOUND OR NOT STARPU_MPI_LIBRARIES) )
           )
@@ -780,10 +747,6 @@ if( CHAMELEON_SCHED_PARSEC )
     if(CHAMELEON_USE_CUDA)
         list(APPEND PARSEC_COMPONENT_LIST "CUDA")
     endif()
-    # TODO: Add a CHAMELEON_WITH_PROFILING option that enables Fxt for StarPU, or PAPI for PaRSEC
-    #if(CHAMELEON_WITH_PROFILING)
-    #    list(APPEND PARSEC_COMPONENT_LIST "PAPI")
-    #endif()
     find_package(PARSEC COMPONENTS ${PARSEC_COMPONENT_LIST})
     if(PARSEC_FOUND)
         message("-- ${Blue}Add definition CHAMELEON_SCHED_PARSEC"

compute/CMakeLists.txt

@@ -304,11 +304,6 @@ elseif(CHAMELEON_SCHED_QUARK)
 elseif(CHAMELEON_SCHED_OPENMP)
   target_link_libraries(chameleon chameleon_openmp)
 endif()
-if (NOT CHAMELEON_SIMULATION)
-  # Depends on coreblas only for set_coreblas_gemm3m_enabled() (Maybe we should change that)
-  add_dependencies(chameleon coreblas_include)
-  target_link_libraries(chameleon coreblas)
-endif()
 target_link_libraries(chameleon hqr)
 
 add_dependencies(chameleon

control/context.c

@@ -148,6 +148,7 @@ int CHAMELEON_Enable(int option)
             break;
         case CHAMELEON_PROFILING_MODE:
             chamctxt->profiling_enabled = CHAMELEON_TRUE;
+            RUNTIME_start_profiling();
             break;
         case CHAMELEON_PROGRESS:
             chamctxt->progress_enabled = CHAMELEON_TRUE;
@@ -218,6 +219,7 @@ int CHAMELEON_Disable(int option)
             break;
         case CHAMELEON_PROFILING_MODE:
             chamctxt->profiling_enabled = CHAMELEON_FALSE;
+            RUNTIME_stop_profiling();
             break;
         case CHAMELEON_PROGRESS:
             chamctxt->progress_enabled = CHAMELEON_FALSE;

coreblas/eztrace_module/CMakeLists.txt

@@ -39,36 +39,39 @@ if (EZTRACE_FOUND AND EZTRACE_DIR_FOUND)
 
         set(EZTRACE_CREATE_PLUGIN "${EZTRACE_eztrace_create_plugin_DIR}/eztrace_create_plugin")
 
-        add_custom_command(
-            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/output
-            COMMAND ${EZTRACE_CREATE_PLUGIN}
-            ARGS ${CMAKE_CURRENT_SOURCE_DIR}/coreblas_eztrace_module
-            DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/coreblas_eztrace_module
-            )
-        add_custom_target(
-            eztrace-module-chameleon_core-dir ALL
-            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/output
-            )
-        add_custom_command(
-            OUTPUT libeztrace-convert-chameleon_core.so
-            COMMAND make
-            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/output
-            DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/output
-            )
-        add_custom_target(
-            eztrace-module-chameleon_core-libs ALL
-            DEPENDS libeztrace-convert-chameleon_core.so
-            )
-        # installation
-        # ------------
-        install(
-            FILES
-            ${CMAKE_CURRENT_BINARY_DIR}/output/libeztrace-autostart-chameleon_core.so
-            ${CMAKE_CURRENT_BINARY_DIR}/output/libeztrace-chameleon_core.so
-            ${CMAKE_CURRENT_BINARY_DIR}/output/libeztrace-convert-chameleon_core.so
-            DESTINATION ${EZTRACE_LIBRARY_DIRS}
-            )
+        set( COREBLAS_EZTRACE_MODULES core tcore )
 
+        foreach( _module ${COREBLAS_EZTRACE_MODULES} )
+            add_custom_command(
+                OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_module}
+                COMMAND ${EZTRACE_CREATE_PLUGIN} -o ${CMAKE_CURRENT_BINARY_DIR}/${_module} > /dev/null
+                ARGS ${CMAKE_CURRENT_SOURCE_DIR}/coreblas_${_module}_eztrace_module
+                DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/coreblas_${_module}_eztrace_module
+                )
+            add_custom_target(
+                eztrace-module-chameleon_${_module}-dir ALL
+                DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_module}
+                )
+            add_custom_command(
+                OUTPUT libeztrace-convert-chameleon_${_module}.so
+                COMMAND make
+                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_module}
+                DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${_module}
+                )
+            add_custom_target(
+                eztrace-module-chameleon_${_module}-libs ALL
+                DEPENDS libeztrace-convert-chameleon_${_module}.so
+                )
+            # installation
+            # ------------
+            install(
+                FILES
+                ${CMAKE_CURRENT_BINARY_DIR}/${_module}/libeztrace-autostart-chameleon_${_module}.so
+                ${CMAKE_CURRENT_BINARY_DIR}/${_module}/libeztrace-chameleon_${_module}.so
+                ${CMAKE_CURRENT_BINARY_DIR}/${_module}/libeztrace-convert-chameleon_${_module}.so
+                DESTINATION ${EZTRACE_LIBRARY_DIRS}
+                )
+        endforeach()
     endif (EZTRACE_eztrace_create_plugin_DIR)
 
 endif (EZTRACE_FOUND AND EZTRACE_DIR_FOUND)

coreblas/eztrace_module/coreblas_eztrace_module → coreblas/eztrace_module/coreblas_core_eztrace_module

 BEGIN_MODULE
 NAME chameleon_core
 DESC "Module for Chameleon CORE functions"
-ID 7770
-
-#include <chameleon.h>
+ID 0
 
 void CORE_scasum(int storev, int uplo, int M, int N,
                  void *A, int lda, float *work);

doc/orgmode/chapters/installing.org

@@ -61,6 +61,9 @@ we encourage users to use [[sec:spack][Spack]].
    sudo apt-get install -y libopenmpi-dev
    # Install hwloc (used by StarPU or QUARK, already a dependency of OpenMPI)
    sudo apt-get install -y libhwloc-dev
+   # install EZTrace, usefull to export some nice execution traces
+   with all runtimes
+   sudo apt-get install -y libeztrace-dev
    # install FxT, usefull to export some nice execution traces with StarPU
    sudo apt-get install -y libfxt-dev
    # Install cuda and cuBLAS: only if you have a GPU cuda compatible
@@ -209,17 +212,17 @@ we encourage users to use [[sec:spack][Spack]].
      *Caution about the compatibility:* Chameleon has been mainly tested
      with the QUARK library coming from https://github.com/ecrc/quark.
 
-**** FxT
-     [[http://download.savannah.gnu.org/releases/fkt/][FxT]] stands for both FKT (Fast Kernel Tracing) and FUT (Fast User
-     Tracing).  This library provides efficient support for recording
-     traces.  Chameleon can trace kernels execution on the different
-     workers and produce .paje files if FxT is enabled.  FxT can only
-     be used through StarPU and StarPU must be compiled with FxT
-     enabled, see how to use this feature here [[sec:trace][Execution trace using
-     StarPU]].
-
-     *Caution about the compatibility:* FxT should be compatible with
-     the version of StarPU used.
+**** EZTrace
+     This library provides efficient modules for recording
+     traces. Chameleon can trace kernels execution on CPU workers
+     thanks to EZTrace and produce .paje files. EZTrace also provides
+     integrated modules to trace MPI calls and/or memory usage. See
+     how to use this feature here [[sec:trace_ezt][Execution trace
+     using EZTrace]]. To trace kernels execution on all kind of
+     workers, such as CUDA, We recommend to use the internal tracing
+     support of the runtime system used done by the underlying
+     runtime.  See how to use this feature here [[sec:trace_fxt][Execution trace
+     using StarPU/FxT]].
 
 **** hwloc
      [[http://www.open-mpi.org/projects/hwloc/][hwloc]] (Portable Hardware Locality) is a software package for
@@ -394,11 +397,6 @@ we encourage users to use [[sec:spack][Spack]].
      * *CHAMELEON_ENABLE_TIMING=ON|OFF* (default ON): to control build
        of timing executables (performances check) contained in timing/
        sub-directory
-     * *CHAMELEON_ENABLE_TRACING=ON|OFF* (default OFF): to enable trace
-       generation during execution of timing drivers. It requires
-       StarPU to be linked with FxT library (trace execution of
-       kernels on workers), see also [[sec:trace][Execution tracing
-       with StarPU]].
      * *CHAMELEON_SIMULATION=ON|OFF* (default OFF): to enable
        simulation mode, means Chameleon will not really execute tasks,
        see details in section [[sec:simu][Use simulation mode with

doc/orgmode/chapters/using.org

@@ -129,28 +129,91 @@
      * GELS: solves overdetermined or underdetermined linear systems involving a general matrix using the QR or the LQ factorization
      * GESVD: general matrix singular value decomposition
 
-*** Execution trace using StarPU
-    <<sec:trace>>
+*** Execution trace using EZTrace
+    <<sec:trace_ezt>>
+
+    [[http://eztrace.gforge.inria.fr/support.html][EZTrace]] can be used by chameleon to generate traces. Two modules
+    are automatically generated as soon as EZTrace is detected on the
+    system. The first one (which is recommended) is the
+    ~chameleon_tcore~ module. It traces all the ~TCORE_...()~ functions
+    that are called by the codelets of all the runtime but PaRSEC. The
+    second one is the ~chameleon_core~ module which traces the lower
+    level ~CORE_...()~ functions. If using PaRSEC, you need to use this
+    module to generate the traces.
+
+    To generate traces with EZTrace, you need first to compile with
+    *-DBUILD_SHARED_LIBS=ON*. EZTrace is using weak symbols to overload
+    function calls with ld_preload and enable trace generation. Then,
+    either you install the ~libeztrace-*.so~ files into the EZTrace
+    install directory, or you can add the path of the modules to your
+    environement
+    #+begin_src
+    export EZTRACE_LIBRARY_PATH=/path/to/your/modules
+    #+end_src
+
+    To check if the modules are available you should have
+    #+begin_src
+    $ eztrace_avail
+    1	omp	Module for OpenMP parallel regions
+    2	pthread	Module for PThread synchronization functions (mutex, semaphore, spinlock, etc.)
+    3	stdio	Module for stdio functions (read, write, select, poll, etc.)
+    4	mpi	Module for MPI functions
+    5	memory	Module for memory functions (malloc, free, etc.)
+    6	papi	Module for PAPI Performance counters
+    128	chameleon_core	Module for Chameleon CORE functions
+    129	chameleon_tcore	Module for Chameleon TCORE functions
+    #+end_src
+
+    Then, you can restrict the modules used during the execution
+    #+begin_src
+    export EZTRACE_TRACE="mpi chameleon_tcore"
+    #+end_src
+
+    _The module ~mpi~ is required if you want to run in distributed._
+
+    The setup can be checked with ~eztrace_loaded~
+    #+begin_src
+    $ eztrace_loaded
+    4	mpi	Module for MPI functions
+    129	chameleon_tcore	Module for Chameleon TCORE functions
+    #+end_src
+
+    To generate the traces, you need to run your binary through
+    eztrace:
+    #+begin_src
+    eztrace ./dnew-testing -o gemm -n 1000 -b 200
+    mpirun -np 4 eztrace ./dnew-testing -o gemm -n 1000 -b 200 -P 2
+    #+end_src
+
+    Convert the binary files into a ~.trace~ file, and visualize it.
+    #+begin_src
+    eztrace_convert <username>_eztrace_log_rank_<[0-9]*>
+    vite eztrace_output.trace
+    #+end_src
+
+    For more information on EZTrace, you can follow the [[http://eztrace.gforge.inria.fr/support.html][support page]].
+
+*** Execution trace using StarPU/FxT
+    <<sec:trace_fxt>>
 
     StarPU can generate its own trace log files by compiling it with
     the ~--with-fxt~ option at the configure step (you can have to
     specify the directory where you installed FxT by giving
     ~--with-fxt=...~ instead of ~--with-fxt~ alone).  By doing so, traces
     are generated after each execution of a program which uses StarPU
-    in the directory pointed by the STARPU_FXT_PREFIX environment
+    in the directory pointed by the [[http://starpu.gforge.inria.fr/doc/html/ExecutionConfigurationThroughEnvironmentVariables.html][STARPU_FXT_PREFIX]] environment
     variable.
     #+begin_example
     export STARPU_FXT_PREFIX=/home/jdoe/fxt_files/
     #+end_example
     When executing a ~./timing/...~ Chameleon program, if it has been
-    enabled (StarPU compiled with FxT and
-    *-DCHAMELEON_ENABLE_TRACING=ON*), you can give the option ~--trace~ to
-    tell the program to generate trace log files.
+    enabled (StarPU compiled with FxT), the program will generate
+    trace files in the directory $STARPU_FXT_PREFIX.
 
     Finally, to generate the trace file which can be opened with [[http://vite.gforge.inria.fr/][Vite]]
     program, you can use the *starpu_fxt_tool* executable of StarPU.
-    This tool should be in ~$STARPU_INSTALL_REPOSITORY/bin~.  You can
-    use it to generate the trace file like this:
+    This tool should be in the bin directory of StarPU's installation.
+    You can use it to generate the trace file like this:
     #+begin_src
     path/to/your/install/starpu/bin/starpu_fxt_tool -i prof_filename
     #+end_src

example/link_chameleon/CMakeLists.txt

@@ -49,7 +49,7 @@ if (CHAMELEON_DISTRIB_DIR)
     if (CHAMELEON_CHAMELEON_USE_QUARK)
         find_package(CHAMELEON COMPONENTS QUARK)
     else()
-        find_package(CHAMELEON COMPONENTS STARPU MPI CUDA FXT)
+        find_package(CHAMELEON COMPONENTS STARPU MPI CUDA)
     endif()
     if (CHAMELEON_FOUND)
         link_directories(${CHAMELEON_LIBRARY_DIRS_DEP})

include/chameleon/config.h.in

@@ -47,9 +47,6 @@
 /* Simulation */
 #cmakedefine CHAMELEON_SIMULATION
 
-/* Tracing support */
-#cmakedefine CHAMELEON_ENABLE_TRACING
-
 /* getopt */
 #cmakedefine CHAMELEON_HAVE_GETOPT_H
 #cmakedefine CHAMELEON_HAVE_GETOPT_LONG

new-testing/testing_zauxiliary.c

@@ -30,13 +30,16 @@ struct option;
  * @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 },
+    { "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 },
 
     { 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 },
@@ -476,6 +479,7 @@ parameters_destroy()
 int main (int argc, char **argv) {
 
     int ncores, ngpus, human, check, i, niter;
+    int trace, nowarmup;
     int rc, info = 0;
     int run_id = 0;
     char *func_name;
@@ -491,12 +495,14 @@ int main (int argc, char **argv) {
         parameters_read_file( input_file );
         free(input_file);
     }
-    ncores     = parameters_getvalue_int( "threads" );
-    ngpus      = parameters_getvalue_int( "gpus" );
-    check      = parameters_getvalue_int( "check" );
-    human      = parameters_getvalue_int( "human" );
-    func_name  = parameters_getvalue_str( "op" );
-    niter      = parameters_getvalue_int( "niter" );
+    ncores    = parameters_getvalue_int( "threads"  );
+    ngpus     = parameters_getvalue_int( "gpus"     );
+    check     = parameters_getvalue_int( "check"    );
+    human     = parameters_getvalue_int( "human"    );
+    func_name = parameters_getvalue_str( "op"       );
+    niter     = parameters_getvalue_int( "niter"    );
+    trace     = parameters_getvalue_int( "trace"    );
+    nowarmup  = parameters_getvalue_int( "nowarmup" );
 
     CHAMELEON_Init( ncores, ngpus );
 
@@ -510,6 +516,20 @@ int main (int argc, char **argv) {
     /* 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) );
+        rc = test->fptr( &copy, check );
+        run_arg_list_destroy( &copy );
+    }
+
+    /* Start tracing */
+    if ( trace ) {
+        CHAMELEON_Enable( CHAMELEON_PROFILING_MODE );
+    }
+
+    /* Perform all runs */
     while ( run != NULL ) {
         for(i=0; i<niter; i++) {
             run_arg_list_t copy = run_arg_list_copy( &(run->args) );
@@ -530,6 +550,12 @@ int main (int argc, char **argv) {
         run_list_destroy( run );
         run = next;
     }
+
+    /* Stop tracing */
+    if ( trace ) {
+        CHAMELEON_Disable( CHAMELEON_PROFILING_MODE );
+    }
+
     free( runlist );
 
     CHAMELEON_Finalize();

new-testing/testing_zauxiliary.h

@@ -23,47 +23,6 @@
 
 #include "testings.h"
 
-/**
- *
- * Macro for trace generation
- *
- */
-#define START_TRACING()                         \
-    RUNTIME_start_stats();                      \
-    if(iparam[IPARAM_TRACE] == 2) {             \
-    	RUNTIME_start_profiling();              \
-    }                                           \
-    if(iparam[IPARAM_BOUND]) {                  \
-        CHAMELEON_Enable(CHAMELEON_BOUND);      \
-    }
-
-#define STOP_TRACING()                          \
-    RUNTIME_stop_stats();                       \
-    if(iparam[IPARAM_TRACE] == 2) {             \
-    	RUNTIME_stop_profiling();               \
-    }                                           \
-    if(iparam[IPARAM_BOUND]) {                  \
-        CHAMELEON_Disable(CHAMELEON_BOUND);     \
-    }
-
-/**
- *
- * Macro for DAG generation
- *
- */
-#if 0
-#define START_DAG()                   \
-    if ( iparam[IPARAM_DAG] == 2 )    \
-        CHAMELEON_Enable(CHAMELEON_DAG);
-
-#define STOP_DAG()                    \
-    if ( iparam[IPARAM_DAG] == 2 )    \
-        CHAMELEON_Disable(CHAMELEON_DAG);
-#else
-#define START_DAG()  do {} while(0);
-#define STOP_DAG()   do {} while(0);
-#endif
-
 /**
  *
  * Synchro for distributed computations
@@ -82,23 +41,6 @@
  * General Macros for timing
  *
  */
-/* #define START_TIMING()                          \ */
-/*     START_DAG();                                \ */
-/*     START_TRACING();                            \ */
-/*     START_DISTRIBUTED();                        \ */
-/*     t = -RUNTIME_get_time(); */
-
-/* #define STOP_TIMING()                           \ */
-/*     STOP_DISTRIBUTED();                         \ */
-/*     t += RUNTIME_get_time();                    \ */
-/*     STOP_TRACING();                             \ */
-/*     STOP_DAG();                                 \ */
-/*     if (iparam[IPARAM_PROFILE] == 2) {          \ */
-/*         RUNTIME_kernelprofile_display();        \ */
-/*         RUNTIME_schedprofile_display();         \ */
-/*     }                                           \ */
-/*     *t_ = t; */
-
 #define START_TIMING( _t_ )                     \
     START_DISTRIBUTED();                        \
     (_t_) = RUNTIME_get_time();

new-testing/testing_zgetrf.c

@@ -55,8 +55,6 @@ testing_zgetrf( run_arg_list_t *args, int check )
     run_arg_add_fixdbl( args, "time", t );
     run_arg_add_fixdbl( args, "gflops", ( hres == CHAMELEON_SUCCESS ) ? gflops : -1. );
 
-    fprintf( stdout, "hres = %d\n", hres );
-
     /* Checks the factorisation and residue */
     if ( check ) {
         CHAM_desc_t *descA0 = CHAMELEON_Desc_Copy( descA, NULL );

runtime/openmp/control/runtime_profiling.c

@@ -27,12 +27,10 @@ double RUNTIME_get_time(){
 
 void RUNTIME_start_profiling()
 {
-    chameleon_warning("RUNTIME_start_profiling()", "FxT profiling is not available with OpenMP\n");
 }
 
 void RUNTIME_stop_profiling()
 {
-    chameleon_warning("RUNTIME_stop_profiling()", "FxT profiling is not available with OpenMP\n");
 }
 
 void RUNTIME_start_stats()

runtime/parsec/control/runtime_profiling.c

@@ -26,12 +26,10 @@ double RUNTIME_get_time(){
 
 void RUNTIME_start_profiling()
 {
-    chameleon_warning("RUNTIME_start_profiling()", "FxT profiling is not available with PaRSEC\n");
 }
 
 void RUNTIME_stop_profiling()
 {
-    chameleon_warning("RUNTIME_stop_profiling()", "FxT profiling is not available with PaRSEC\n");
 }
 
 void RUNTIME_start_stats()

runtime/quark/control/runtime_profiling.c

@@ -26,12 +26,10 @@ double RUNTIME_get_time(){
 
 void RUNTIME_start_profiling()
 {
-    chameleon_warning("RUNTIME_start_profiling()", "FxT profiling is not available with Quark\n");
 }
 
 void RUNTIME_stop_profiling()
 {
-    chameleon_warning("RUNTIME_stop_profiling()", "FxT profiling is not available with Quark\n");
 }
 
 void RUNTIME_start_stats()

runtime/starpu/control/runtime_control.c

@@ -21,7 +21,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "chameleon_starpu.h"
-#if defined(HAVE_STARPU_FXT_PROFILING)
+#if defined(STARPU_USE_FXT)
 #include <starpu_fxt.h>
 #endif
 
@@ -40,7 +40,7 @@ static int chameleon_starpu_init( starpu_conf_t *conf )
         MPI_Initialized( &flag );
 #  endif
 
-#if defined(HAVE_STARPU_FXT_PROFILING)
+#if defined(STARPU_USE_FXT)
         starpu_fxt_autostart_profiling(0);
 #endif
 

runtime/starpu/control/runtime_profiling.c

@@ -20,7 +20,7 @@
  */
 #include <math.h>
 #include "chameleon_starpu.h"
-#if defined(HAVE_STARPU_FXT_PROFILING)
+#if defined(STARPU_USE_FXT)
 #include <starpu_fxt.h>
 #endif
 
@@ -55,18 +55,14 @@ void RUNTIME_iteration_pop( CHAM_context_t *chamctxt )
 }
 
 void RUNTIME_start_profiling(){
-#if defined(HAVE_STARPU_FXT_PROFILING)
+#if defined(STARPU_USE_FXT)
     starpu_fxt_start_profiling();
-#else
-    fprintf(stderr, "Profiling throught FxT has not been enabled in StarPU runtime (configure StarPU with --with-fxt)\n");
 #endif
 }
 
 void RUNTIME_stop_profiling(){
-#if defined(HAVE_STARPU_FXT_PROFILING)
+#if defined(STARPU_USE_FXT)
     starpu_fxt_stop_profiling();
-#else
-    fprintf(stderr, "Profiling throught FxT has not been enabled in StarPU runtime (configure StarPU with --with-fxt)\n");
 #endif
 }
 

runtime/starpu/include/chameleon_starpu.h.in

@@ -24,7 +24,6 @@
 #include "chameleon/config.h"
 
 /* StarPU options */
-#cmakedefine HAVE_STARPU_FXT_PROFILING
 #cmakedefine HAVE_STARPU_IDLE_PREFETCH
 #cmakedefine HAVE_STARPU_ITERATION_PUSH
 #cmakedefine HAVE_STARPU_DATA_WONT_USE