SCOREP_User.h

Go to the documentation of this file.

/*
 * This file is part of the Score-P software (http://www.score-p.org)
 *
 * Copyright (c) 2009-2011,
 * RWTH Aachen University, Germany
 *
 * Copyright (c) 2009-2011,
 * Gesellschaft fuer numerische Simulation mbH Braunschweig, Germany
 *
 * Copyright (c) 2009-2011, 2014-2015,
 * Technische Universitaet Dresden, Germany
 *
 * Copyright (c) 2009-2011,
 * University of Oregon, Eugene, USA
 *
 * Copyright (c) 2009-2011, 2013-2014, 2016-2017,
 * Forschungszentrum Juelich GmbH, Germany
 *
 * Copyright (c) 2009-2011, 2014-2015,
 * German Research School for Simulation Sciences GmbH, Juelich/Aachen, Germany
 *
 * Copyright (c) 2009-2011,
 * Technische Universitaet Muenchen, Germany
 *
 * This software may be modified and distributed under the terms of
 * a BSD-style license.  See the COPYING file in the package base
 * directory for details.
 *
 */

#ifndef SCOREP_USER_H
#define SCOREP_USER_H

/* Guarded because it declares variables in every file where it is included. */
#ifdef SCOREP_USER_ENABLE
#include <scorep/SCOREP_User_Variables.h>
#include <scorep/SCOREP_User_Functions.h>
#endif

/* Provide macro SCOREP_USER_FUNCTION_NAME that expands to the
 * function name of the enclosing function. */
#ifndef SCOREP_USER_FUNCTION_NAME
    #if defined( __cplusplus ) && defined( __FUJITSU )
        #define SCOREP_USER_FUNCTION_NAME __FUNCTION__
    #else
        #define SCOREP_USER_FUNCTION_NAME __func__
    #endif
#endif

/* **************************************************************************************
 * Documentation for region enclosing macros
 * *************************************************************************************/

/* **************************************************************************************
 * Region enclosing macros
 * *************************************************************************************/
/* Empty define for SCOREP_USER_FUNC_DEFINE to allow documentation of the macro and
   let it disappear in C/C++ codes */
#define SCOREP_USER_FUNC_DEFINE()

#ifdef SCOREP_USER_ENABLE

#define SCOREP_USER_REGION_DEFINE( handle ) \
    static SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION;

#define SCOREP_USER_REGION_ENTER( handle ) SCOREP_User_RegionEnter( handle );

#define SCOREP_USER_REGION_BEGIN( handle, name, type ) SCOREP_User_RegionBegin( \
        &handle, &SCOREP_User_LastFileName, &SCOREP_User_LastFileHandle, name, \
        type, __FILE__, __LINE__ );

#define SCOREP_USER_REGION_INIT( handle, name, type ) SCOREP_User_RegionInit( \
        &handle, &SCOREP_User_LastFileName, &SCOREP_User_LastFileHandle, name, \
        type, __FILE__, __LINE__ );

#define SCOREP_USER_REGION_END( handle ) SCOREP_User_RegionEnd( handle );

/* automatic, name tagged region begin */
#define SCOREP_USER_REGION_BY_NAME_BEGIN( name, type ) SCOREP_User_RegionByNameBegin( \
        name, type, "", 0 );

/* automatic, name tagged region end */
#define SCOREP_USER_REGION_BY_NAME_END( name ) SCOREP_User_RegionByNameEnd( name );

#define SCOREP_USER_REWIND_DEFINE( handle ) \
    static SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION;

#define SCOREP_USER_REWIND_POINT( handle, name ) \
    SCOREP_User_RewindRegionBegin( &handle, &SCOREP_User_LastFileName, \
                                   &SCOREP_User_LastFileHandle, name, \
                                   SCOREP_USER_REGION_TYPE_COMMON, __FILE__, __LINE__ );

#define SCOREP_USER_REWIND_CHECK( handle, value ) \
    SCOREP_User_RewindRegionEnd( handle, value );

#define SCOREP_USER_FUNC_BEGIN() static SCOREP_User_RegionHandle        \
    scorep_user_func_handle =  SCOREP_USER_INVALID_REGION; \
    SCOREP_User_RegionBegin( &scorep_user_func_handle, &SCOREP_User_LastFileName, \
                             &SCOREP_User_LastFileHandle, SCOREP_USER_FUNCTION_NAME, \
                             SCOREP_USER_REGION_TYPE_FUNCTION, __FILE__, __LINE__ );

#define SCOREP_USER_FUNC_END() SCOREP_User_RegionEnd( scorep_user_func_handle );

#define SCOREP_USER_GLOBAL_REGION_DEFINE( handle ) \
    SCOREP_User_RegionHandle handle = SCOREP_USER_INVALID_REGION;

#define SCOREP_USER_GLOBAL_REGION_EXTERNAL( handle ) \
    extern SCOREP_User_RegionHandle handle;

#endif // SCOREP_USER_ENABLE

/* **************************************************************************************
 * Documentation for Parameter macros
 * *************************************************************************************/

/* **************************************************************************************
 * Parameter macros
 * *************************************************************************************/
#ifdef SCOREP_USER_ENABLE

#define SCOREP_USER_PARAMETER_INT64( name, value ) { \
        static SCOREP_User_ParameterHandle scorep_param = SCOREP_USER_INVALID_PARAMETER; \
        SCOREP_User_ParameterInt64( &scorep_param, name, value ); }

#define SCOREP_USER_PARAMETER_UINT64( name, value ) { \
        static SCOREP_User_ParameterHandle scorep_param = SCOREP_USER_INVALID_PARAMETER; \
        SCOREP_User_ParameterUint64( &scorep_param, name, value ); }

#define SCOREP_USER_PARAMETER_STRING( name, value ) { \
        static SCOREP_User_ParameterHandle scorep_param = SCOREP_USER_INVALID_PARAMETER; \
        SCOREP_User_ParameterString( &scorep_param, name, value ); }

#endif // SCOREP_USER_ENABLE

/* **************************************************************************************
 * Documentation for User Metric macros
 * *************************************************************************************/

/* **************************************************************************************
 * User Counter macros
 * *************************************************************************************/
#ifdef SCOREP_USER_ENABLE

#define SCOREP_USER_METRIC_LOCAL( metricHandle ) static SCOREP_SamplingSetHandle \
    metricHandle                                                                \
        = SCOREP_INVALID_SAMPLING_SET;

#define SCOREP_USER_METRIC_GLOBAL( metricHandle ) SCOREP_SamplingSetHandle metricHandle \
        = SCOREP_INVALID_SAMPLING_SET;

#define SCOREP_USER_METRIC_EXTERNAL( metricHandle ) \
    extern SCOREP_SamplingSetHandle metricHandle;

#define SCOREP_USER_METRIC_INIT( metricHandle, name, unit, type, context ) \
    SCOREP_User_InitMetric( &metricHandle, name, unit, type, context );

#define SCOREP_USER_METRIC_INT64( metricHandle, \
                                  value )  SCOREP_User_TriggerMetricInt64( \
        metricHandle, value );

#define SCOREP_USER_METRIC_UINT64( metricHandle, \
                                   value )  SCOREP_User_TriggerMetricUint64( \
        metricHandle, value );

#define SCOREP_USER_METRIC_DOUBLE( metricHandle, \
                                   value ) SCOREP_User_TriggerMetricDouble( \
        metricHandle, value );

#endif // SCOREP_USER_ENABLE

/* ****************************************************************************
* Documentation for Topology macros
* ****************************************************************************/

/* **************************************************************************************
 * User Topology macros
 * *************************************************************************************/
#ifdef SCOREP_USER_ENABLE

#define SCOREP_USER_CARTESIAN_TOPOLOGY_CREATE( userTopology, name, nDims ) \
    SCOREP_User_CartesianTopologyHandle userTopology = SCOREP_USER_INVALID_CARTESIAN_TOPOLOGY; \
    SCOREP_User_CartTopologyCreate( &userTopology, name, nDims );

#define SCOREP_USER_CARTESIAN_TOPOLOGY_ADD_DIM( userTopology, size, periodic, name ) \
    SCOREP_User_CartTopologyAddDim( userTopology, size, periodic, name );

#define SCOREP_USER_CARTESIAN_TOPOLOGY_INIT( userTopology ) \
    SCOREP_User_CartTopologyInit( userTopology );

#define SCOREP_USER_CARTESIAN_TOPOLOGY_SET_COORDS( userTopology, nDims, ... ) \
    SCOREP_User_CartTopologySetCoords( userTopology, nDims, __VA_ARGS__ );

#endif // SCOREP_USER_ENABLE

//just for doxygen completeness in Fortran case.
#define SCOREP_USER_CARTESIAN_TOPOLOGY_DEFINE( userTopology )

/* **************************************************************************************
 * Documentation for C++ specific macros
 * *************************************************************************************/

/* **************************************************************************************
 * C++ specific macros
 * *************************************************************************************/
#ifdef SCOREP_USER_ENABLE

#ifdef __cplusplus

/* We want to initialize the region handle only once and store it in a static variable.
   Thus, if the region is revisited, we do not need to evaluate filters and check double
   definitions. However, we want the region object reconstruct every time to execute
   the enter/exit in the constructor/destructor. The region handle in the class is
   necessary to pass the region handle from the constructor to the destructor. */
#define SCOREP_USER_REGION( name, type ) static SCOREP_User_RegionHandle \
    scorep_user_region_handle = SCOREP_USER_INVALID_REGION; \
    SCOREP_User_RegionClass \
    scorep_user_region_inst( &scorep_user_region_handle, \
                             name, \
                             type, \
                             &SCOREP_User_LastFileName, \
                             &SCOREP_User_LastFileHandle, \
                             __FILE__, __LINE__ );

#else // __cplusplus

#define SCOREP_USER_REGION( name, type )

#endif // __cplusplus

#endif // SCOREP_USER_ENABLE

/* **************************************************************************************
 * Documentation for Control macros
 * *************************************************************************************/

/* **************************************************************************************
 * Control macros
 * *************************************************************************************/

#ifdef SCOREP_USER_ENABLE

#define SCOREP_RECORDING_ON() SCOREP_User_EnableRecording();

#define SCOREP_RECORDING_OFF() SCOREP_User_DisableRecording();

#define SCOREP_RECORDING_IS_ON() SCOREP_User_RecordingEnabled()

#else // SCOREP_USER_ENABLE

/* **************************************************************************************
 * Empty macros, if user instrumentation is disabled
 * *************************************************************************************/

#define SCOREP_USER_REGION( name, type )
#define SCOREP_USER_REGION_DEFINE( handle )
#define SCOREP_USER_REWIND_DEFINE( 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
#define SCOREP_USER_CARTESIAN_TOPOLOGY_CREATE( userTopology, name, ndims )
#define SCOREP_USER_CARTESIAN_TOPOLOGY_ADD_DIM( userTopology, size, periodic, name )
#define SCOREP_USER_CARTESIAN_TOPOLOGY_INIT( userTopology )
#define SCOREP_USER_CARTESIAN_TOPOLOGY_SET_COORDS( userTopology, nDims, ... )

#endif // SCOREP_USER_ENABLE

#endif /* SCOREP_USER_H */