Add thapi_start() and thapi_stop()

.github/workflows/presubmit.yml

@@ -132,7 +132,7 @@ jobs:
         if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug_enabled }}
       - name: Integration test
         run: |
-          THAPI_BIN_DIR=./build/ici/bin bats integration_tests/
+          THAPI_INSTALL_DIR=./build/ici bats integration_tests/
 
   build-in-tree-and-check:
     needs: efficios_dep

configure.ac

@@ -102,7 +102,10 @@ AC_SUBST([ENABLE_CLANG_PARSER])
 
 PKG_CHECK_MODULES([LIBFFI], [libffi >= 3.2])
 PKG_CHECK_MODULES([BABELTRACE2], [babeltrace2 >= 2.0])
-PKG_CHECK_MODULES([LTTNG_UST], [lttng-ust >= 2.10])
+# Use of __attribute__((constructor)) requires `lttng-ust >= 2.12.8` to work properly.
+# Specifically, the following fix:
+# https://github.com/lttng/lttng-ust/commit/a8fafb675a9f580f6a889223e26664ea11cb0c99.
+PKG_CHECK_MODULES([LTTNG_UST], [lttng-ust >= 2.12.8])
 PKG_CHECK_MODULES([PROTOBUF], [protobuf >= 3.0])
 
 AX_RUBY_EXTENSION([cast-to-yaml], [yes])
@@ -137,6 +140,8 @@ AC_FUNC_MMAP
 AC_FUNC_REALLOC
 AC_CHECK_FUNCS([clock_gettime ftruncate memmove memset strdup strstr strtoull strlen strchr])
 
+AX_GCC_FUNC_ATTRIBUTE(constructor)
+
 AC_CONFIG_FILES([
 	Makefile
 	xprof/Makefile

integration_tests/setup_suite.bash

@@ -2,7 +2,10 @@
 
 setup_suite() {
   export THAPI_HOME=${THAPI_HOME:-${PWD}}
-  export THAPI_BIN_DIR=${THAPI_BIN_DIR:-${THAPI_HOME}/install/bin}
+  export THAPI_INSTALL_DIR=${THAPI_INSTALL_DIR:-${THAPI_HOME}/install}
+  export THAPI_BIN_DIR=${THAPI_BIN_DIR:-${THAPI_INSTALL_DIR}/bin}
+  export THAPI_INC_DIR=${THAPI_INC_DIR:-${THAPI_INSTALL_DIR}/include}
+  export THAPI_LIB_DIR=${THAPI_LIB_DIR:-${THAPI_INSTALL_DIR}/lib}
   export THAPI_TEST_BIN=${THAPI_TEST_BIN:-clinfo}
 
   export IPROF=${IPROF:-${THAPI_BIN_DIR}/iprof}

integration_tests/toggle.bats

@@ -0,0 +1,71 @@
+#!/usr/bin/env bats
+
+teardown_file() {
+   rm -rf $THAPI_HOME/thapi-traces
+}
+
+get_unique_jobid() {
+  echo ${BATS_TEST_NAME}.${RANDOM}
+}
+
+@test "toggle_api" {
+  rm -rf toggle_traces 2> /dev/null
+
+  cc -I${THAPI_INC_DIR} ./integration_tests/toggle.c -o toggle \
+    -Wl,-rpath,${THAPI_LIB_DIR} -L${THAPI_LIB_DIR} -lThapi
+
+  $IPROF --trace-output toggle_traces --no-analysis -- ./toggle
+  dir=$(ls -d -1 ./toggle_traces/*/)
+
+  start_count=`$BBT -c $dir | grep lttng_ust_toggle:start | wc -l`
+  [ "$start_count" -eq 1 ]
+
+  stop_count=`$BBT -c $dir | grep lttng_ust_toggle:stop | wc -l`
+  [ "$stop_count" -eq 2 ]
+}
+
+toggle_count_base() {
+  rm -rf toggle_traces 2> /dev/null
+
+  THAPI_SYNC_DAEMON=fs THAPI_JOBID=$(get_unique_jobid) timeout 40s $MPIRUN -n $1 \
+    $IPROF --trace-output toggle_traces --no-analysis -- ./toggle_mpi $2
+
+  traces=$($BBT ./toggle_traces)
+
+  echo $traces
+}
+
+toggle_count_traces() {
+  traces=$(toggle_count_base $1 $2)
+  echo $traces | sed -e "s/ \[/\n[/g" | grep . | wc -l
+}
+
+@test "toggle_plugin_mpi_np_1" {
+  mpicc -I${THAPI_INC_DIR} ./integration_tests/toggle_mpi.c -o toggle_mpi \
+    -Wl,-rpath,${THAPI_LIB_DIR} -L${THAPI_LIB_DIR} -lThapi
+
+  count_0=$(toggle_count_traces 1 0)
+  count_1=$(toggle_count_traces 1 1)
+  count_2=$(toggle_count_traces 1 2)
+
+  [ "$count_2" -eq 0 ]
+  [ "$count_0" -gt "$count_1" ]
+}
+
+toggle_count_vpids() {
+  traces=$(toggle_count_base $1 $2)
+  echo $traces | sed -e "s/ - /, /g" | sed -e "s/,/\n/g" | grep vpid | sort | uniq | wc -l
+}
+
+@test "toggle_plugin_mpi_np_2" {
+  mpicc -I${THAPI_INC_DIR} ./integration_tests/toggle_mpi.c -o toggle_mpi \
+    -Wl,-rpath,${THAPI_LIB_DIR} -L${THAPI_LIB_DIR} -lThapi
+
+  count_0=$(toggle_count_vpids 2 0)
+  count_1=$(toggle_count_vpids 2 1)
+  count_2=$(toggle_count_vpids 2 2)
+
+  [ "$count_0" -eq 2 ]
+  [ "$count_1" -eq 1 ]
+  [ "$count_2" -eq 0 ]
+}

integration_tests/toggle.c

@@ -0,0 +1,6 @@
+#include <thapi.h>
+
+int main(int argc, char *argv[]) {
+  thapi_start();
+  thapi_stop();
+}

integration_tests/toggle_mpi.c

@@ -0,0 +1,30 @@
+#include <stdlib.h>
+#include <mpi.h>
+
+#include <thapi.h>
+
+int main(int argc, char *argv[]) {
+  int variant = (argc > 1) ? atoi(argv[1]) : 0;
+
+  MPI_Init(&argc, &argv);
+
+  int rank, size;
+
+  switch (variant) {
+  case 0:
+    thapi_start();
+  case 1:
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    if (rank == 0) thapi_start();
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    break;
+  default:
+    break;
+  }
+
+  thapi_stop();
+
+  MPI_Finalize();
+
+  return 0;
+}

m4/ax_gcc_func_attribute.m4

@@ -0,0 +1,242 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_gcc_func_attribute.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_GCC_FUNC_ATTRIBUTE(ATTRIBUTE)
+#
+# DESCRIPTION
+#
+#   This macro checks if the compiler supports one of GCC's function
+#   attributes; many other compilers also provide function attributes with
+#   the same syntax. Compiler warnings are used to detect supported
+#   attributes as unsupported ones are ignored by default so quieting
+#   warnings when using this macro will yield false positives.
+#
+#   The ATTRIBUTE parameter holds the name of the attribute to be checked.
+#
+#   If ATTRIBUTE is supported define HAVE_FUNC_ATTRIBUTE_<ATTRIBUTE>.
+#
+#   The macro caches its result in the ax_cv_have_func_attribute_<attribute>
+#   variable.
+#
+#   The macro currently supports the following function attributes:
+#
+#    alias
+#    aligned
+#    alloc_size
+#    always_inline
+#    artificial
+#    cold
+#    const
+#    constructor
+#    constructor_priority for constructor attribute with priority
+#    deprecated
+#    destructor
+#    dllexport
+#    dllimport
+#    error
+#    externally_visible
+#    fallthrough
+#    flatten
+#    format
+#    format_arg
+#    gnu_format
+#    gnu_inline
+#    hot
+#    ifunc
+#    leaf
+#    malloc
+#    noclone
+#    noinline
+#    nonnull
+#    noreturn
+#    nothrow
+#    optimize
+#    pure
+#    sentinel
+#    sentinel_position
+#    unused
+#    used
+#    visibility
+#    warning
+#    warn_unused_result
+#    weak
+#    weakref
+#
+#   Unsupported function attributes will be tested with a prototype
+#   returning an int and not accepting any arguments and the result of the
+#   check might be wrong or meaningless so use with care.
+#
+# LICENSE
+#
+#   Copyright (c) 2013 Gabriele Svelto <gabriele.svelto@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 13
+
+AC_DEFUN([AX_GCC_FUNC_ATTRIBUTE], [
+    AS_VAR_PUSHDEF([ac_var], [ax_cv_have_func_attribute_$1])
+
+    AC_CACHE_CHECK([for __attribute__(($1))], [ac_var], [
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([
+            m4_case([$1],
+                [alias], [
+                    int foo( void ) { return 0; }
+                    int bar( void ) __attribute__(($1("foo")));
+                ],
+                [aligned], [
+                    int foo( void ) __attribute__(($1(32)));
+                ],
+                [alloc_size], [
+                    void *foo(int a) __attribute__(($1(1)));
+                ],
+                [always_inline], [
+                    inline __attribute__(($1)) int foo( void ) { return 0; }
+                ],
+                [artificial], [
+                    inline __attribute__(($1)) int foo( void ) { return 0; }
+                ],
+                [cold], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [const], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [constructor_priority], [
+                    int foo( void ) __attribute__((__constructor__(65535/2)));
+                ],
+                [constructor], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [deprecated], [
+                    int foo( void ) __attribute__(($1("")));
+                ],
+                [destructor], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [dllexport], [
+                    __attribute__(($1)) int foo( void ) { return 0; }
+                ],
+                [dllimport], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [error], [
+                    int foo( void ) __attribute__(($1("")));
+                ],
+                [externally_visible], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [fallthrough], [
+                    void foo( int x ) {switch (x) { case 1: __attribute__(($1)); case 2: break ; }};
+                ],
+                [flatten], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [format], [
+                    int foo(const char *p, ...) __attribute__(($1(printf, 1, 2)));
+                ],
+                [gnu_format], [
+                    int foo(const char *p, ...) __attribute__((format(gnu_printf, 1, 2)));
+                ],
+                [format_arg], [
+                    char *foo(const char *p) __attribute__(($1(1)));
+                ],
+                [gnu_inline], [
+                    inline __attribute__(($1)) int foo( void ) { return 0; }
+                ],
+                [hot], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [ifunc], [
+                    int my_foo( void ) { return 0; }
+                    static int (*resolve_foo(void))(void) { return my_foo; }
+                    int foo( void ) __attribute__(($1("resolve_foo")));
+                ],
+                [leaf], [
+                    __attribute__(($1)) int foo( void ) { return 0; }
+                ],
+                [malloc], [
+                    void *foo( void ) __attribute__(($1));
+                ],
+                [noclone], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [noinline], [
+                    __attribute__(($1)) int foo( void ) { return 0; }
+                ],
+                [nonnull], [
+                    int foo(char *p) __attribute__(($1(1)));
+                ],
+                [noreturn], [
+                    void foo( void ) __attribute__(($1));
+                ],
+                [nothrow], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [optimize], [
+                    __attribute__(($1(3))) int foo( void ) { return 0; }
+                ],
+                [pure], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [sentinel], [
+                    int foo(void *p, ...) __attribute__(($1));
+                ],
+                [sentinel_position], [
+                    int foo(void *p, ...) __attribute__(($1(1)));
+                ],
+                [returns_nonnull], [
+                    void *foo( void ) __attribute__(($1));
+                ],
+                [unused], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [used], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [visibility], [
+                    int foo_def( void ) __attribute__(($1("default")));
+                    int foo_hid( void ) __attribute__(($1("hidden")));
+                    int foo_int( void ) __attribute__(($1("internal")));
+                    int foo_pro( void ) __attribute__(($1("protected")));
+                ],
+                [warning], [
+                    int foo( void ) __attribute__(($1("")));
+                ],
+                [warn_unused_result], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [weak], [
+                    int foo( void ) __attribute__(($1));
+                ],
+                [weakref], [
+                    static int foo( void ) { return 0; }
+                    static int bar( void ) __attribute__(($1("foo")));
+                ],
+                [
+                 m4_warn([syntax], [Unsupported attribute $1, the test may fail])
+                 int foo( void ) __attribute__(($1));
+                ]
+            )], [])
+            ],
+            dnl GCC doesn't exit with an error if an unknown attribute is
+            dnl provided but only outputs a warning, so accept the attribute
+            dnl only if no warning were issued.
+            [AS_IF([grep -- -Wattributes conftest.err],
+                [AS_VAR_SET([ac_var], [no])],
+                [AS_VAR_SET([ac_var], [yes])])],
+            [AS_VAR_SET([ac_var], [no])])
+    ])
+
+    AS_IF([test yes = AS_VAR_GET([ac_var])],
+        [AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_FUNC_ATTRIBUTE_$1), 1,
+            [Define to 1 if the system has the `$1' function attribute])], [])
+
+    AS_VAR_POPDEF([ac_var])
+])