instrument.h

/**
 * Shared interface for several libraries with manual instrumentation
	- MERIC, compile with -DUSE_MERIC
 	- TIMEPROF, compile with -DUSE_TIMEPROF
	- Score-P, compile with -DUSE_SCOREP_MANUAL or -DUSE_SCOREP (phase region inserted only)
	- TAU, compile with -DUSE_TAU
	- GEOPM, compile with -DUSE_GEOPM
	- SCALASCA, compile with -DUSE_SCOREP_MANUAL
	- mpiP, compile with -DUSE_MPIP
	- Extrae, compile with -DUSE_EXTRAE
	- LIKWID, compile with -DUSE_LIKWID, in case of OpenMP applications, include the header after omp.h

	+ time measurement, compile with -DUSE_TIME_MEASUREMENT, for C applications compile with -DINSTRUMENT_STACK_SIZE=<int value> to specify nesting region level (default 20)
	+ no instrumentation when none of the modes selected
	
 * Only one of the supported libraries can be selected, if none of them is 
 * selected, then no instrumentation is inserted to the application's code.
 *
 * version 4.1
 * 06.12.2022
 * Ondrej Vysocky, ondrej.vysocky [at] vsb.cz
 * IT4Innovations national supercomputing center, Czech Republic
 **/

/******************************************************************************
 * List of the functions:
 * void INSTRUMENT_INIT(nodeId)
	 	library initialization
	 	- nodeId
 * void INSTRUMENT_CLOSE()
	 	end of use of the library 
 * void INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint )
	 	region definition before it can start
	 	- handle
	 	- name
	 	- TAUtype_GEOPMhint
 * void INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint )
	 	definition of a region inside a loop
	 	- handle
	 	- name
	 	- TAUtype_GEOPMhint
 * void INSTRUMENT_REGION_START(handle, name, SCOREPtype) 
	 	region measurement start
	 	- handle
	 	- name
	 	- SCOREPtype
 * double INSTRUMENT_REGION_STOP(handle, name)
	 	region measurement stop
	 	- handle
	 	- name
 * double INSTRUMENT_REGION_STOP_START(stop_handle, stop_name, start_handle, start_name, SCOREPtype)
	 	region measurement stop and at the same time start of another region
	 	- stop_handle
	 	- stop_name
	 	- start_handle
	 	- start_name
	 	- SCOREPrype
 * void INSTRUMENT_PHASE_START(handle, name, SCOREPtype)
	 	start of a region inside a loop
	 	- handle
	 	- name
	 	- SCOREPtype
 * double INSTRUMENT_PHASE_STOP(handle, name)
	 	end of a region inside a loop
	 	- handle
	 	- name
 * void INSTRUMENT_IGNORE_START()
	 	turn off the measurement 
 * void INSTRUMENT_IGNORE_STOP()
		turn the measurement on after it was stopped
 ******************************************************************************/

#ifndef INSTRUMENT_H_
#define INSTRUMENT_H_

#ifdef USE_SCOREP_MANUAL
	#define USE_SCOREP
#endif

#ifdef USE_SCOREP
	#include <scorep/SCOREP_User.h>
	#include <scorep/SCOREP_User_Types.h>
	#ifdef __cplusplus
		#include <cstddef>
	#endif
#elif defined USE_MERIC
	#include <meric.h>
#elif defined USE_TIMEPROF
	#include <timeprof.h>
#elif defined USE_TAU
	#include <TAU.h>
#elif defined USE_GEOPM
	#include <geopm.h>
#elif defined USE_MPIP
	#include <mpiP-API.h>
#elif defined USE_EXTRAE
	#include <extrae.h>
#elif defined USE_LIKWID
	#include <likwid.h>
	inline static void INSTRUMENT_LIKWID_THREAD_INIT_WRAPPER()
	{
		#ifdef _OMP_H
			#pragma omp parallel
				likwid_markerThreadInit();
		#endif
		return;
	};
#elif defined USE_TIME_MEASUREMENT
	#include <time.h>
	static double instrumentAPI_get_time()
	{
		struct timespec time;
		clock_gettime(CLOCK_REALTIME, &time);
		return time.tv_sec + time.tv_nsec / 1e9;
	};

	#ifdef __cplusplus
		static vector <double> instrumentAPItimeStack;

		static void instrumentAPI_time_start()
		{
			instrumentAPItimeStack.push_back(instrumentAPI_get_time());
		};

		static double instrumentAPI_time_stop()
		{
			double time = 0.0;
			if (instrumentAPItimeStack.size() != 0)
			{
				time = instrumentAPI_get_time() - instrumentAPItimeStack.back();
				instrumentAPItimeStack.pop_back();
			}
			return time;
		};
	#else
		#ifndef INSTRUMENT_STACK_SIZE
			#define INSTRUMENT_STACK_SIZE 20
		#endif
		static double[INSTRUMENT_STACK_SIZE] instrumentAPItimeStack;
		static int instrumentAPItimeStackSize = 0;

		static void instrumentAPI_time_start()
		{
			if (instrumentAPItimeStackSize < INSTRUMENT_STACK_SIZE)
			{
				instrumentAPItimeStack[instrumentAPItimeStackSize] = instrumentAPI_get_time();
			}
			else
			{
				fprintf(stderr,"InstrumentAPI WARNING - regions nesting level exceed, define INSTRUMENT_STACK_SIZE higher than %d!\n", INSTRUMENT_STACK_SIZE);
			}
			instrumentAPItimeStackSize++;
		};

		static double instrumentAPI_time_stop()
		{
			double time = 0.0;
			if (instrumentAPItimeStackSize != 0)
			{
				instrumentAPItimeStackSize--;
				if (instrumentAPItimeStackSize < INSTRUMENT_STACK_SIZE)
				{
					time = instrumentAPI_get_time() - instrumentAPItimeStack[instrumentAPItimeStackSize];
				}
			}
			return time;
		};
	#endif

#endif


inline static double INSTRUMENT_RETURN_ZERO()
{
	return 0.0;
}

//INSTRUMENT_INIT(nodeId = 0)
//INSTRUMENT_CLOSE()
#ifdef USE_MERIC
	#define INSTRUMENT_INIT( nodeId ) \
		MERIC_Init();
	#define INSTRUMENT_CLOSE() \
		MERIC_Close();
#elif defined USE_TIMEPROF
	#define INSTRUMENT_INIT( nodeId )
	#define INSTRUMENT_CLOSE() \
		TIMEPROF_evaluate();
#elif defined USE_TAU
/*	#define INSTRUMENT_INIT() \
		TAU_INIT( &argc, &argv ); \
		TAU_PROFILE_SET_NODE(0); */
	#define INSTRUMENT_INIT( nodeId ) \
		TAU_INIT( &argc, &argv ); \
		TAU_PROFILE_SET_NODE( nodeId );
	#define INSTRUMENT_CLOSE() \
		TAU_PROFILE_EXIT("");
#elif defined USE_GEOPM
	#define INSTRUMENT_INIT( nodeId )\
		geopm_prof_init();
	#define INSTRUMENT_CLOSE() \
		geopm_prof_shutdown();
#elif defined USE_MPIP
	#define INSTRUMENT_INIT( nodeId ) \
		mpiP_init_api();
	#define INSTRUMENT_CLOSE()
#elif defined USE_EXTRAE
	#define INSTRUMENT_INIT( nodeId ) \
		Extrae_init();
	#define INSTRUMENT_CLOSE() \
		Extrae_fini();
#elif defined USE_LIKWID
	#define INSTRUMENT_INIT( nodeId ) \
		likwid_markerInit(); \
		INSTRUMENT_LIKWID_THREAD_INIT_WRAPPER();
	#define INSTRUMENT_CLOSE() \
		likwid_markerClose();
#else
	#define INSTRUMENT_INIT( nodeId )
	#define INSTRUMENT_CLOSE()
#endif

//INSTRUMENT_IGNORE_START()
//INSTRUMENT_IGNORE_STOP()
#ifdef USE_MERIC
	#define INSTRUMENT_IGNORE_START() \
		MERIC_IgnoreStart();
	#define INSTRUMENT_IGNORE_STOP() \
		MERIC_IgnoreStop();
#elif defined USE_SCOREP
	#define INSTRUMENT_IGNORE_START() \
		SCOREP_RECORDING_OFF();
	#define INSTRUMENT_IGNORE_STOP() \
		SCOREP_RECORDING_ON();
#elif defined USE_TAU
	#define INSTRUMENT_IGNORE_START() \
		TAU_DISABLE_ALL_GROUPS();
	#define INSTRUMENT_IGNORE_STOP() \
		TAU_ENABLE_ALL_GROUPS();
#elif defined USE_MPIP
	#define INSTRUMENT_IGNORE_START() \
		MPI_Pcontrol(0);
	#define INSTRUMENT_IGNORE_STOP() \
		MPI_Pcontrol(1);
#elif defined USE_EXTRAE
	#define INSTRUMENT_IGNORE_START() \
		Extrae_shutdown();
	#define INSTRUMENT_IGNORE_STOP() \
		Extrae_restart();
#else
	#define INSTRUMENT_IGNORE_START()
	#define INSTRUMENT_IGNORE_STOP()
#endif

//INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) - should be used for PHASE only
//INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint, param=NULL) - cannot be used for PHASE region
#ifdef USE_SCOREP_MANUAL
	//Score-P 3.0
	//SCOREP_USER_REGION_DEFINE(handle)
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		static SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION;
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		static SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION;
/*	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint, param ) \
		static SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION; */
#elif defined USE_SCOREP
	//Score-P 3.0
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		static SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION;
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint )
//	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint, param )
#elif defined USE_TAU
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		TAU_DYNAMIC_PHASE( handle, name, "", TAUtype_GEOPMhint );
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		TAU_PROFILE_TIMER( handle, name, "", TAUtype_GEOPMhint );
/*	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint, param ) \
		TAU_PROFILE_TIMER( handle, name, param, TAUtype_GEOPMhint ); */
#elif defined USE_GEOPM
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint )
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		uint64_t handle; \
		geopm_prof_region( name, geopm_hint, & handle );
/*	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint, param ) \
		uint64_t handle; \
		geopm_prof_region( name, geopm_hint, & handle ); */
#elif defined USE_EXTRAE
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		unsigned int handle = 0;
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0;                               \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (name != NULL)                                                  \
				while(name[INSTRUMENT_EXTRAE_iter] != '\0')                    \
					INSTRUMENT_EXTRAE_type += (unsigned)name[INSTRUMENT_EXTRAE_iter++];\
			int INSTRUMENT_EXTRAE_nvalues = 2;                                 \
			extrae_value_t INSTRUMENT_EXTRAE_values[2] = {0, 1};               \
			char * INSTRUMENT_EXTRAE_description_values[2] = {"End", "Begin" };\
			Extrae_define_event_type (&INSTRUMENT_EXTRAE_type, name, &INSTRUMENT_EXTRAE_nvalues, INSTRUMENT_EXTRAE_values, INSTRUMENT_EXTRAE_description_values); \
		}
#elif defined USE_LIKWID
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		likwid_markerRegisterRegion( name );
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint ) \
		likwid_markerRegisterRegion( name );
#else
	#define INSTRUMENT_PHASE_REGION_DEFINE( handle, name, TAUtype_GEOPMhint )
	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint )
//	#define INSTRUMENT_REGION_DEFINE( handle, name, TAUtype_GEOPMhint, param )
#endif

//INSTRUMENT_REGION_START(handle, name, SCOREPtype)
#ifdef USE_SCOREP_MANUAL
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		SCOREP_USER_REGION_BEGIN( handle, name, SCOREPtype );
#elif defined USE_MERIC
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		MERIC_MeasureStart( name );
#elif defined USE_TIMEPROF
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		TIMEPROF_regionStart ( name );
#elif defined USE_TAU
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		TAU_PROFILE_START( handle );
#elif defined USE_GEOPM
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		geopm_prof_enter( handle );
#elif defined USE_EXTRAE
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0;                               \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (name != NULL)                                                  \
				while(name[INSTRUMENT_EXTRAE_iter] != '\0')                    \
					INSTRUMENT_EXTRAE_type += (unsigned)name[INSTRUMENT_EXTRAE_iter++];\
			Extrae_event( INSTRUMENT_EXTRAE_type, 1 );                         \
		}
#elif defined USE_LIKWID
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		likwid_markerStartRegion( name );
#elif defined USE_TIME_MEASUREMENT
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype ) \
		instrumentAPI_time_start();
#else
	#define INSTRUMENT_REGION_START( handle, name, SCOREPtype )
#endif

//INSTRUMENT_REGION_STOP(handle, name)
#ifdef USE_SCOREP_MANUAL
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		SCOREP_USER_REGION_END( handle );
#elif defined USE_MERIC
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		MERIC_MeasureStop( name );
#elif defined USE_TIMEPROF
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		TIMEPROF_regionStop ( name );
#elif defined USE_TAU
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		TAU_PROFILE_STOP( handle );
#elif defined USE_GEOPM
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		geopm_prof_exit( handle );
#elif defined USE_EXTRAE
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0;                               \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (name != NULL)                                                  \
				while(name[INSTRUMENT_EXTRAE_iter] != '\0')                    \
					INSTRUMENT_EXTRAE_type += (unsigned)name[INSTRUMENT_EXTRAE_iter++];\
			Extrae_event( INSTRUMENT_EXTRAE_type, 0 );                         \
		}
#elif defined USE_LIKWID
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		likwid_markerStopRegion( name );
#elif defined USE_TIME_MEASUREMENT
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		instrumentAPI_time_stop();
#else
	#define INSTRUMENT_REGION_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO();
#endif

//INSTRUMENT_REGION_STOP_START(stop_handle, stop_name, start_handle, start_name, SCOREPtype)
#ifdef USE_SCOREP_MANUAL
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		INSTRUMENT_RETURN_ZERO(); \
		SCOREP_USER_REGION_END( stop_handle ); \
		SCOREP_USER_REGION_BEGIN( start_handle, start_name, SCOREPtype );
#elif defined USE_MERIC
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		MERIC_MeasureStopStart( stop_name, start_name );
#elif defined USE_TIMEPROF
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		TIMEPROF_regionStop ( stop_name ); \
		TIMEPROF_regionStart ( start_name );
#elif defined USE_TAU
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		INSTRUMENT_RETURN_ZERO(); \
		TAU_PROFILE_STOP( stop_handler ); \
		TAU_PROFILE_START( start_handler );
#elif defined USE_GEOPM
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		INSTRUMENT_RETURN_ZERO(); \
		geopm_prof_exit( stop_handle ); \
		geopm_prof_enter( start_handle );
#elif defined USE_EXTRAE
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0                                \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (stop_name != NULL)                                             \
				while(stop_name[INSTRUMENT_EXTRAE_iter] != '\0')               \
					INSTRUMENT_EXTRAE_type += (unsigned)stop_name[INSTRUMENT_EXTRAE_iter++];\
			Extrae_event( INSTRUMENT_EXTRAE_type, 0 );                         \
		} \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0                                \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (start_name != NULL)                                            \
				while(start_name[INSTRUMENT_EXTRAE_iter] != '\0')              \
					INSTRUMENT_EXTRAE_type += (unsigned)start_name[INSTRUMENT_EXTRAE_iter++];\
			Extrae_event( INSTRUMENT_EXTRAE_type, 1 );                         \
		}
#elif defined USE_LIKWID
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		INSTRUMENT_RETURN_ZERO(); \
		likwid_markerStopRegion( stop_name ); \
		likwid_markerStartRegion( start_name );
#elif defined USE_TIME_MEASUREMENT
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		instrumentAPI_time_stop(); \
		instrumentAPI_time_start();
#else
	#define INSTRUMENT_REGION_STOP_START( stop_handle, stop_name, start_handle, start_name, SCOREPtype ) \
		INSTRUMENT_RETURN_ZERO()
#endif

//INSTRUMENT_PHASE_START(handle, name, SCOREPtype)
#ifdef USE_SCOREP
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		SCOREP_USER_OA_PHASE_BEGIN( handle, name, SCOREPtype );
#elif defined USE_MERIC
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		MERIC_MeasureStart( name );
#elif defined USE_TAU
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		TAU_PHASE_START( handle );
#elif defined USE_GEOPM
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		geopm_prof_epoch();
#elif defined USE_EXTRAE
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		handle++; \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0                                \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (name != NULL)                                                  \
				while(name[INSTRUMENT_EXTRAE_iter] != '\0')                    \
					INSTRUMENT_EXTRAE_type += (unsigned)name[INSTRUMENT_EXTRAE_iter++];\
			Extrae_event( INSTRUMENT_EXTRAE_type, handle );                    \
		}
#elif defined USE_LIKWID
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		likwid_markerStartRegion( name );
#elif defined USE_TIME_MEASUREMENT
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype ) \
		instrumentAPI_time_start();
#else
	#define INSTRUMENT_PHASE_START( handle, name, SCOREPtype )
#endif

//INSTRUMENT_PHASE_STOP(handle, name)
#ifdef USE_SCOREP
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		SCOREP_USER_OA_PHASE_END( handle );
#elif defined USE_MERIC
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		MERIC_MeasureStop( name );
#elif defined USE_TAU
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		TAU_PHASE_STOP( handle );
#elif defined USE_EXTRAE
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		{ \
			unsigned INSTRUMENT_EXTRAE_type = 0                                \
			int INSTRUMENT_EXTRAE_iter = 0;                                    \
			if (name != NULL)                                                  \
				while(name[INSTRUMENT_EXTRAE_iter] != '\0')                    \
					INSTRUMENT_EXTRAE_type += (unsigned)name[INSTRUMENT_EXTRAE_iter++];\
			Extrae_event( INSTRUMENT_EXTRAE_type, 0 );                         \
		}
#elif defined USE_LIKWID
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO(); \
		likwid_markerStopRegion( name );
#elif defined USE_TIME_MEASUREMENT
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		instrumentAPI_time_stop();
#else
	#define INSTRUMENT_PHASE_STOP( handle, name ) \
		INSTRUMENT_RETURN_ZERO();
#endif

// Next section defines default functions that must be used because the shared 
// interface does not provide alternative function.
// Following functions will be ignored if the application is not compiled 
// with the appropriet library.

//Score-P API (SCOREP_User.h)
#ifndef USE_SCOREP
	#define SCOREP_USER_REGION( name, type )
	//#define SCOREP_USER_REGION_DEFINE( handle )
	#define SCOREP_USER_REWIND_DEFINE( handle )
	//#define SCOREP_USER_OA_PHASE_BEGIN( handle, name, type )
	//#define SCOREP_USER_OA_PHASE_END( handle )
	#define SCOREP_USER_REWIND_POINT( handle, name )
	//#define SCOREP_USER_REGION_BEGIN( handle, name, type )
	#define SCOREP_USER_REGION_BY_NAME_BEGIN( name, type )
	#define SCOREP_USER_REGION_INIT( handle, name, type )
	//#define SCOREP_USER_REGION_END( handle )
	#define SCOREP_USER_REGION_BY_NAME_END( name )
	#define SCOREP_USER_REWIND_CHECK( handle, value )
	#define SCOREP_USER_REGION_ENTER( handle )
	#define SCOREP_USER_FUNC_BEGIN()
	#define SCOREP_USER_FUNC_END()
	#define SCOREP_USER_GLOBAL_REGION_DEFINE( handle )
	#define SCOREP_USER_GLOBAL_REGION_EXTERNAL( handle )
	#define SCOREP_USER_PARAMETER_INT64( name, value )
	#define SCOREP_USER_PARAMETER_UINT64( name, value )
	#define SCOREP_USER_PARAMETER_STRING( name, value )
	#define SCOREP_USER_METRIC_GLOBAL( metricHandle )
	#define SCOREP_USER_METRIC_EXTERNAL( metricHandle )
	#define SCOREP_USER_METRIC_LOCAL( metricHandle )
	#define SCOREP_USER_METRIC_INIT( metricHandle, name, unit, type, context )
	#define SCOREP_USER_METRIC_INT64( metricHandle, value )
	#define SCOREP_USER_METRIC_UINT64( metricHandle, value )
	#define SCOREP_USER_METRIC_DOUBLE( metricHandle, value )
	//#define SCOREP_RECORDING_ON()
	//#define SCOREP_RECORDING_OFF()
	#define SCOREP_RECORDING_IS_ON() 0
#endif

//TAU-2.28 API (TAU.h.default)
#ifndef USE_TAU
	#define TYPE_STRING(profileString, str)
	#define PROFILED_BLOCK(name, type)
	#define TAU_TYPE_STRING(profileString, str)
	#define TAU_PROFILE(name, type, group)
	#define TAU_PROFILE_TIMER(var, name, type, group)
	//#define TAU_PROFILE_START(var)
	//#define TAU_PROFILE_STOP(var)
	#define TAU_PROFILE_STMT(stmt)
	//#define TAU_PROFILE_EXIT(msg)
	//#define TAU_PROFILE_INIT(argc, argv)
	//#define TAU_PROFILE_SET_NODE(node)
	#define TAU_PROFILE_SET_CONTEXT(context)
	#define TAU_PROFILE_SET_THREAD(thread)
	#define TAU_PROFILE_GET_NODE() -1
	#define TAU_PROFILE_GET_THREAD() -1
	#define TAU_PROFILE_GET_CONTEXT() -1
	#define TAU_PROFILE_SET_GROUP_NAME(newname)
	#define TAU_PROFILE_TIMER_SET_GROUP_NAME(t, newname)
	#define TAU_PROFILE_CALLSTACK()
	#define TAU_DB_DUMP()
	#define TAU_DB_PURGE()
	#define TAU_DB_DUMP_PREFIX(prefix)
	#define TAU_DB_DUMP_INCR()
	#define TAU_GET_FUNC_NAMES(functionList, num)
	#define TAU_DUMP_FUNC_NAMES()
	#define TAU_GET_PROFILE_GROUP(group)
	//#define TAU_INIT(argc, argv)
	#define TAU_REGISTER_CONTEXT_EVENT(event, name)
	#define TAU_CONTEXT_EVENT(event, data)
	#define TAU_DISABLE_CONTEXT_EVENT(event)
	#define TAU_ENABLE_CONTEXT_EVENT(event)
	#define TAU_REGISTER_EVENT(event, name)
	#define TAU_EVENT(event, data)
	#define TAU_EVENT_DISABLE_MIN(event)
	#define TAU_EVENT_DISABLE_MAX(event)
	#define TAU_EVENT_DISABLE_MEAN(event)
	#define TAU_EVENT_DISABLE_STDDEV(event)
	#define TAU_REPORT_STATISTICS()
	#define TAU_REPORT_THREAD_STATISTICS()
	#define TAU_REGISTER_THREAD()
	#define TAU_REGISTER_FORK(id, op)
	#define TAU_ENABLE_INSTRUMENTATION()		
	#define TAU_DISABLE_INSTRUMENTATION()
	#define TAU_ENABLE_GROUP(group)
	#define TAU_DISABLE_GROUP(group)
	#define TAU_ENABLE_GROUP_NAME(group)
	#define TAU_DISABLE_GROUP_NAME(group)
	//#define TAU_ENABLE_ALL_GROUPS()		
	//#define TAU_DISABLE_ALL_GROUPS()
	#define TAU_TRACK_MEMORY()
	#define TAU_TRACK_MEMORY_HERE()
	#define TAU_ENABLE_TRACKING_MEMORY()
	#define TAU_DISABLE_TRACKING_MEMORY()
	#define TAU_TRACK_MEMORY()
	#define TAU_TRACK_MEMORY_HERE()
	#define TAU_TRACK_POWER()
	#define TAU_TRACK_POWER_HERE()
	#define TAU_ENABLE_TRACKING_POWER()          
	#define TAU_DISABLE_TRACKING_POWER()
	#define TAU_SET_INTERRUPT_INTERVAL(value)
	#define CT(obj)
	#define TAU_TRACE_SENDMSG(type, destination, length)
	#define TAU_TRACE_RECVMSG(type, source, length)
	#define TAU_TRACE_RECVMSG_REMOTE(type, source, length, remoteid)
	#define TAU_TRACE_SENDMSG_REMOTE(type, destination, length, remoteid)
	#define TAU_MAPPING(stmt, group) stmt
	#define TAU_MAPPING_OBJECT(FuncInfoVar)
	#define TAU_MAPPING_LINK(FuncInfoVar, Group)
	#define TAU_MAPPING_PROFILE(FuncInfoVar)
	#define TAU_MAPPING_CREATE(name, type, key, groupname, tid)
	#define TAU_MAPPING_PROFILE_TIMER(Timer, FuncInfoVar, tid)
	#define TAU_MAPPING_TIMER_CREATE(t, name, type, gr, group_name)
	#define TAU_MAPPING_PROFILE_START(Timer, tid)
	#define TAU_MAPPING_PROFILE_STOP(tid)
	#define TAU_MAPPING_PROFILE_EXIT(msg, tid)
	#define TAU_MAPPING_DB_DUMP(tid)
	#define TAU_MAPPING_DB_PURGE(tid)
	#define TAU_MAPPING_PROFILE_SET_NODE(node, tid)
	#define TAU_MAPPING_PROFILE_SET_GROUP_NAME(timer, name)
	#define TAU_PROFILE_TIMER_SET_NAME(t, newname)
	#define TAU_PROFILE_TIMER_SET_TYPE(t, newname)
	#define TAU_PROFILE_TIMER_SET_GROUP(t, id)
	#define TAU_MAPPING_PROFILE_SET_NAME(timer, name)
	#define TAU_MAPPING_PROFILE_SET_TYPE(timer, name)
	#define TAU_MAPPING_PROFILE_SET_GROUP(timer, id)
	#define TAU_MAPPING_PROFILE_GET_GROUP_NAME(timer)
	#define TAU_MAPPING_PROFILE_GET_GROUP(timer)
	#define TAU_MAPPING_PROFILE_GET_NAME(timer)
	#define TAU_MAPPING_PROFILE_GET_TYPE(timer)
	#define TAU_PHASE(name, type, group)
	#define TAU_PHASE_CREATE_STATIC(var, name, type, group)
	#define TAU_PHASE_CREATE_DYNAMIC(var, name, type, group)
	//#define TAU_PHASE_START(var)
	//#define TAU_PHASE_STOP(var)
	#define TAU_GLOBAL_PHASE(timer, name, type, group)
	#define TAU_GLOBAL_PHASE_START(timer)
	#define TAU_GLOBAL_PHASE_STOP(timer)
	#define TAU_GLOBAL_PHASE_EXTERNAL(timer)
	#define TAU_GLOBAL_TIMER(timer, name, type, group)
	#define TAU_GLOBAL_TIMER_EXTERNAL(timer)
	#define TAU_GLOBAL_TIMER_START(timer)
	#define TAU_GLOBAL_TIMER_STOP()
	#define TAU_PROFILE_PARAM1L(a,b)
	#define TAU_NEW(expr, size) 		expr
	#define TAU_DELETE(expr, variable) 	expr
	#define TAU_PROFILE_SNAPSHOT(name)
	#define TAU_PROFILE_SNAPSHOT_1L(name, expr)
	#define TAU_METADATA(name, value)
	#define TAU_METADATA_ITERATION(name, iteration, value)
	#define TAU_PHASE_METADATA(name, value)
	#define TAU_CONTEXT_METADATA(name, value)
	/* extensions to the PHASE/TIMER API */
	//#define TAU_DYNAMIC_PHASE(name, type, group)
	#define TAU_DYNAMIC_PROFILE(name, type, group)
	#define TAU_STATIC_PHASE_START(name)
	#define TAU_STATIC_PHASE_STOP(name)
	#define TAU_DYNAMIC_PHASE_START(name)
	#define TAU_DYNAMIC_PHASE_STOP(name)
	#define TAU_DYNAMIC_TIMER_START(name)
	#define TAU_DYNAMIC_TIMER_STOP(name)
	#define TAU_PROFILE_CREATE_DYNAMIC_AUTO(var, name, type, group)
	#define TAU_PHASE_CREATE_DYNAMIC_AUTO(var, name, type, group)
	#define TAU_PROFILER_CREATE(handle, name, type, group)
	#define TAU_PROFILER_START(handle)
	#define TAU_PROFILER_STOP(handle)
	#define TAU_PROFILER_GET_INCLUSIVE_VALUES(handle, data)
	#define TAU_PROFILER_GET_EXCLUSIVE_VALUES(handle, data)
	#define TAU_PROFILER_GET_CALLS(handle, number)
	#define TAU_PROFILER_GET_CHILD_CALLS(handle, number)
	#define TAU_PROFILER_GET_COUNTER_INFO(counters, numcounters)
	//#define TAU_PROFILE_TIMER_DYNAMIC(var,name, type, group)
	#define TAU_GET_FUNC_NAMES(functionList, num)
	#define TAU_GET_COUNTER_NAMES(counterList, num)
	#define TAU_GET_FUNC_VALS(v1,v2,v3,v4,v5,v6,v7,v8)
	#define TAU_DUMP_FUNC_VALS(functionList, num)
	#define TAU_DUMP_FUNC_VALS_INCR(functionList, num)
	#define TAU_GET_EVENT_NAMES(eventList, num)
	#define TAU_GET_EVENT_VALS(v1,v2,v3,v4,v5,v6,v7)
	#define TAU_EVENT_SET_NAME(event, name)
	#define TAU_ENABLE_TRACKING_MEMORY()
	#define TAU_DISABLE_TRACKING_MEMORY()
	#define TAU_TRACK_MEMORY()
	#define TAU_TRACK_MEMORY_HERE()
	#define TAU_TRACK_MEMORY_HEADROOM()
	#define TAU_TRACK_MEMORY_HEADROOM_HERE()
	#define TAU_ENABLE_TRACKING_MEMORY_HEADROOM()
	#define TAU_DISABLE_TRACKING_MEMORY_HEADROOM()
	#define TAU_QUERY_DECLARE_EVENT(event)
	#define TAU_QUERY_GET_CURRENT_EVENT(event)
	#define TAU_QUERY_GET_EVENT_NAME(event, str)
	#define TAU_QUERY_GET_PARENT_EVENT(event)
	#define TAU_SET_USER_CLOCK(value)
	/* Old/Dead API calls */
	#define TAU_ENABLE_TRACKING_MUSE_EVENTS()
	#define TAU_DISABLE_TRACKING_MUSE_EVENTS()
	#define TAU_TRACK_MUSE_EVENTS()
#endif

// GEOPM API
#ifndef USE_GEOPM
	//#define geopm_prof_init()
	//#define geopm_prof_shutdown()
	//#define geopm_prof_epoch()
	//#define geopm_prof_region( name, hint, handle )
	//#define geopm_prof_enter( handle )
	//#define geopm_prof_exit( handle )
	#define geopm_prof_progress( region_id, fraction )
	#define geopm_tprof_init( num_work_unit )
	#define geopm_tprof_init_loop( num_thread, thread_idx, num_iter, chunk_size )
	#define geopm_tprof_post()
#endif

#ifndef USE_MPIP
	//#define mpiP_init_api()
	#define mpiP_record_traceback( pc_array, max_stack ) -1
	#define mpiP_open_executable( filename ) -1
	#define mpiP_close_executable()
	#define mpiP_TIMER mpiP_gettime () 0.0
	#define mpiP_get_executable_name() NULL
	#define mpiP_find_src_loc( i_addr_hex, o_file_str, o_lineno, o_funct_str ) -1
	#define mpiP_format_address ( pval, addr_buf ) NULL
#endif

#ifndef USE_EXTRAE
	enum INSTRUMENT_EXTRAE_OPTIONS
	{
		EXTRAE_CALLER_OPTION = 0,
		EXTRAE_HWC_OPTION = 2,
		EXTRAE_MPI_OPTION = 8,
		EXTRAE_MPI_HWC_OPTION = 4,
		EXTRAE_OMP_OPTION = 16,
		EXTRAE_OMP_HWC_OPTION = 32,
		EXTRAE_UF_HWC_OPTION = 64,
		EXTRAE_SAMPLING_OPTION=128,
		EXTRAE_ENABLE_ALL_OPTIONS=255
	};

	#define Extrae_get_version( major, minor, revision )
	//#define Extrae_init()
	//#define Extrae_fini()
	//#define Extrae_event( type, value )
	//#define Extrae_define_event_type( type, description, nvalues, values, description_values )
	//#define Extrae_shutdown()
	//#define Extrae_restart()
	#define Extrae_previous_hwc_set()
	#define Extrae_next_hwc_set()
	#define Extrae_set_tracing_tasks( from, to )
		//uses INSTRUMENT_EXTRAE_OPTIONS
	#define Extrae_set_options( options )
	#define Extrae_nevent( count, types, values )
	#define Extrae_counters()
	#define Extrae_eventandcounters( event, value )
	#define Extrae_neventandcounters( count, types, values )
	#define Extrae_network_counters()
	#define Extrae_network_routes( task )
	#define Extrae_user_function( enter ) 0
	#define Extrae_flush()
		//EXTRAE_NOT_INITIALIZED = 0
	#define Extrae_is_initialized() 0
#endif

#ifndef USE_LIKWID
	//#define LIKWID_MARKER_INIT
	//#define likwid_markerInit()
	//#define LIKWID_MARKER_THREADINIT
	//#define likwid_markerThreadInit()
	//#define LIKWID_MARKER_CLOSE 
	//#define likwid_markerClose()
	//#define LIKWID_MARKER_REGISTER( regionTag )
	//#define likwid_markerRegisterRegion( regionTag )
	//#define LIKWID_MARKER_START( regionTag )
	//#define likwid_markerStartRegion( regionTag )
	//#define LIKWID_MARKER_STOP( regionTag )
	//#define likwid_markerStopRegion( regionTag )
	#define LIKWID_MARKER_SWITCH 
	#define likwid_markerNextGroup()
	#define LIKWID_MARKER_RESET( regionTag ) 0
	#define likwid_markerResetRegion( regionTag ) 0
	#define LIKWID_MARKER_GET( regionTag, nevents, events, time, count )
	#define likwid_markerGetRegion( regionTag, nevents, events, time, count )
	#define likwid_getProcessorId() 0
	#define likwid_pinProcess( processorId ) 0
	#define likwid_pinThread( processorId ) 0
#endif

#ifndef USE_MERIC
	#define MERIC_captureScope( region )
#endif

#ifndef USE_TIMEPROF
	#define TIMEPROF_captureScope( regionName )
	#define TIMEPROF_getLastRegionDuration() 0.0
#endif

#endif /* INSTRUMENT_H_ */