SCOREP_PublicTypes.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, 2018,
 *    Technische Universitaet Dresden, Germany
 *
 * Copyright (c) 2009-2011,
 *    University of Oregon, Eugene, USA
 *
 * Copyright (c) 2009-2011, 2018,
 *    Forschungszentrum Juelich GmbH, Germany
 *
 * Copyright (c) 2009-2011,
 *    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_PUBLICTYPES_H
#define SCOREP_PUBLICTYPES_H

#include <stdint.h>


typedef int64_t SCOREP_ExitStatus;


#define SCOREP_INVALID_EXIT_STATUS ( ( int64_t )( ~( ( ~( ( uint64_t )0u ) ) >> 1 ) ) )


typedef uint32_t SCOREP_LineNo;



#define SCOREP_INVALID_LINE_NO 0

typedef uint32_t SCOREP_Allocator_MovableMemory;

#define SCOREP_MOVABLE_NULL 0

typedef SCOREP_Allocator_MovableMemory SCOREP_AnyHandle;

typedef SCOREP_AnyHandle SCOREP_SourceFileHandle;

#define SCOREP_INVALID_SOURCE_FILE SCOREP_MOVABLE_NULL

typedef SCOREP_AnyHandle SCOREP_MetricHandle;

#define SCOREP_INVALID_METRIC SCOREP_MOVABLE_NULL


typedef SCOREP_AnyHandle SCOREP_SamplingSetHandle;

#define SCOREP_INVALID_SAMPLING_SET SCOREP_MOVABLE_NULL


typedef SCOREP_AnyHandle SCOREP_RegionHandle;

#define SCOREP_INVALID_REGION SCOREP_MOVABLE_NULL


typedef SCOREP_AnyHandle SCOREP_ParadigmHandle;

#define SCOREP_INVALID_PARADIGM SCOREP_MOVABLE_NULL



typedef struct SCOREP_Task* SCOREP_TaskHandle;

typedef enum SCOREP_CollectiveType
{
    SCOREP_COLLECTIVE_BARRIER,                      
    SCOREP_COLLECTIVE_BROADCAST,                    
    SCOREP_COLLECTIVE_GATHER,                       
    SCOREP_COLLECTIVE_GATHERV,                      
    SCOREP_COLLECTIVE_SCATTER,                      
    SCOREP_COLLECTIVE_SCATTERV,                     
    SCOREP_COLLECTIVE_ALLGATHER,                    
    SCOREP_COLLECTIVE_ALLGATHERV,                   
    SCOREP_COLLECTIVE_ALLTOALL,                     
    SCOREP_COLLECTIVE_ALLTOALLV,                    
    SCOREP_COLLECTIVE_ALLTOALLW,                    
    SCOREP_COLLECTIVE_ALLREDUCE,                    
    SCOREP_COLLECTIVE_REDUCE,                       
    SCOREP_COLLECTIVE_REDUCE_SCATTER,               
    SCOREP_COLLECTIVE_REDUCE_SCATTER_BLOCK,         
    SCOREP_COLLECTIVE_SCAN,                         
    SCOREP_COLLECTIVE_EXSCAN,                       
    SCOREP_COLLECTIVE_CREATE_HANDLE,                
    SCOREP_COLLECTIVE_DESTROY_HANDLE,               
    SCOREP_COLLECTIVE_ALLOCATE,                     
    SCOREP_COLLECTIVE_DEALLOCATE,                   
    SCOREP_COLLECTIVE_CREATE_HANDLE_AND_ALLOCATE,   
    SCOREP_COLLECTIVE_DESTROY_HANDLE_AND_DEALLOCATE 
} SCOREP_CollectiveType;



#define SCOREP_LOCATION_TYPES \
    SCOREP_LOCATION_TYPE( CPU_THREAD, "CPU thread" ) \
    SCOREP_LOCATION_TYPE( GPU,        "GPU" ) \
    SCOREP_LOCATION_TYPE( METRIC,     "metric location" ) \


typedef enum SCOREP_LocationType
{
    #define SCOREP_LOCATION_TYPE( NAME, name_string ) SCOREP_LOCATION_TYPE_ ## NAME,
    SCOREP_LOCATION_TYPES
    #undef SCOREP_LOCATION_TYPE

    SCOREP_NUMBER_OF_LOCATION_TYPES,
    SCOREP_INVALID_LOCATION_TYPE 
} SCOREP_LocationType;

typedef enum SCOREP_LockType
{
    SCOREP_LOCK_EXCLUSIVE,
    SCOREP_LOCK_SHARED,

    SCOREP_INVALID_LOCK_TYPE 
} SCOREP_LockType;

typedef int SCOREP_MpiRank;


typedef uint64_t SCOREP_MpiRequestId;


#define SCOREP_ALL_TARGET_RANKS -1

#define SCOREP_INVALID_ROOT_RANK -1


#define SCOREP_PARADIGM_CLASSES \
    SCOREP_PARADIGM_CLASS( MPP,                "multi-process", PROCESS ) \
    SCOREP_PARADIGM_CLASS( THREAD_FORK_JOIN,   "fork/join",     THREAD_FORK_JOIN ) \
    SCOREP_PARADIGM_CLASS( THREAD_CREATE_WAIT, "create/wait",   THREAD_CREATE_WAIT ) \
    SCOREP_PARADIGM_CLASS( ACCELERATOR,        "accelerator",   ACCELERATOR )


typedef enum SCOREP_ParadigmClass
{
#define SCOREP_PARADIGM_CLASS( NAME, name, OTF2_NAME ) \
    SCOREP_PARADIGM_CLASS_ ## NAME,
    SCOREP_PARADIGM_CLASSES

#undef SCOREP_PARADIGM_CLASS

    SCOREP_INVALID_PARADIGM_CLASS 
} SCOREP_ParadigmClass;


#define SCOREP_PARADIGMS \
    SCOREP_PARADIGM( MEASUREMENT,        "measurement",        MEASUREMENT_SYSTEM ) \
    SCOREP_PARADIGM( USER,               "user",               USER ) \
    SCOREP_PARADIGM( COMPILER,           "compiler",           COMPILER ) \
    SCOREP_PARADIGM( SAMPLING,           "sampling",           SAMPLING ) \
    SCOREP_PARADIGM( MEMORY,             "memory",             NONE ) \
    SCOREP_PARADIGM( LIBWRAP,            "libwrap",            NONE ) \
    SCOREP_PARADIGM( MPI,                "mpi",                MPI ) \
    SCOREP_PARADIGM( SHMEM,              "shmem",              SHMEM ) \
    SCOREP_PARADIGM( OPENMP,             "openmp",             OPENMP ) \
    SCOREP_PARADIGM( PTHREAD,            "pthread",            PTHREAD ) \
    SCOREP_PARADIGM( ORPHAN_THREAD,      "orphan thread",      UNKNOWN ) \
    SCOREP_PARADIGM( CUDA,               "cuda",               CUDA ) \
    SCOREP_PARADIGM( OPENCL,             "opencl",             OPENCL ) \
    SCOREP_PARADIGM( OPENACC,            "openacc",            OPENACC ) \
    SCOREP_PARADIGM( IO,                 "io",                 NONE )


typedef enum SCOREP_ParadigmType
{
#define SCOREP_PARADIGM( NAME, name_str, OTF2_NAME ) \
    SCOREP_PARADIGM_ ## NAME,
    SCOREP_PARADIGMS

#undef SCOREP_PARADIGM

    SCOREP_INVALID_PARADIGM_TYPE 
} SCOREP_ParadigmType;

typedef enum SCOREP_ParameterType
{
    SCOREP_PARAMETER_INT64,       
    SCOREP_PARAMETER_UINT64,      
    SCOREP_PARAMETER_STRING,      
    SCOREP_INVALID_PARAMETER_TYPE 
} SCOREP_ParameterType;


#define SCOREP_REGION_TYPES \
    SCOREP_REGION_TYPE( COLL_ONE2ALL, "one2all" ) \
    SCOREP_REGION_TYPE( COLL_ALL2ONE, "all2one" ) \
    SCOREP_REGION_TYPE( COLL_ALL2ALL, "all2all" ) \
    SCOREP_REGION_TYPE( COLL_OTHER,   "other collective" ) \
    SCOREP_REGION_TYPE( POINT2POINT,  "point2point" ) \
    SCOREP_REGION_TYPE( PARALLEL,     "parallel" ) \
    SCOREP_REGION_TYPE( SECTIONS,     "sections" ) \
    SCOREP_REGION_TYPE( SECTION,      "section" ) \
    SCOREP_REGION_TYPE( WORKSHARE,    "workshare" ) \
    SCOREP_REGION_TYPE( SINGLE,       "single" ) \
    SCOREP_REGION_TYPE( MASTER,       "master" ) \
    SCOREP_REGION_TYPE( CRITICAL,     "critical" ) \
    SCOREP_REGION_TYPE( ATOMIC,       "atomic" ) \
    SCOREP_REGION_TYPE( BARRIER,      "barrier" ) \
    SCOREP_REGION_TYPE( IMPLICIT_BARRIER, "implicit barrier" ) \
    SCOREP_REGION_TYPE( FLUSH,        "flush" ) \
    SCOREP_REGION_TYPE( CRITICAL_SBLOCK, "critical sblock" ) \
    SCOREP_REGION_TYPE( SINGLE_SBLOCK, "single sblock" ) \
    SCOREP_REGION_TYPE( WRAPPER,      "wrapper" ) \
    SCOREP_REGION_TYPE( TASK,         "task" ) \
    SCOREP_REGION_TYPE( TASK_UNTIED,  "untied task" ) \
    SCOREP_REGION_TYPE( TASK_WAIT,    "taskwait" ) \
    SCOREP_REGION_TYPE( TASK_CREATE,  "task create" ) \
    SCOREP_REGION_TYPE( ORDERED,      "ordered" ) \
    SCOREP_REGION_TYPE( ORDERED_SBLOCK, "ordered sblock" ) \
    SCOREP_REGION_TYPE( ARTIFICIAL,   "artificial" ) \
    SCOREP_REGION_TYPE( RMA,          "rma" ) \
    SCOREP_REGION_TYPE( THREAD_CREATE, "thread create" ) \
    SCOREP_REGION_TYPE( THREAD_WAIT,  "thread wait" ) \
    SCOREP_REGION_TYPE( ALLOCATE,     "allocate" ) \
    SCOREP_REGION_TYPE( DEALLOCATE,   "deallocate" ) \
    SCOREP_REGION_TYPE( REALLOCATE,   "reallocate" ) \
    SCOREP_REGION_TYPE( FILE_IO,      "file_io" ) \
    SCOREP_REGION_TYPE( FILE_IO_METADATA,  "file_io metadata" )


#define SCOREP_REGION_TYPE( NAME, name_str ) \
    SCOREP_REGION_ ## NAME,

typedef enum SCOREP_RegionType
{
    SCOREP_REGION_UNKNOWN = 0,
    SCOREP_REGION_FUNCTION,
    SCOREP_REGION_LOOP,
    SCOREP_REGION_USER,
    SCOREP_REGION_CODE,

    SCOREP_REGION_PHASE,
    SCOREP_REGION_DYNAMIC,
    SCOREP_REGION_DYNAMIC_PHASE,
    SCOREP_REGION_DYNAMIC_LOOP,
    SCOREP_REGION_DYNAMIC_FUNCTION,
    SCOREP_REGION_DYNAMIC_LOOP_PHASE,

    SCOREP_REGION_TASKLOOP,     /* move to SCOREP_REGION_TYPES once OTF2_REGION_ROLE_TASKLOOP exists */

    SCOREP_REGION_TYPES

    SCOREP_INVALID_REGION_TYPE 
} SCOREP_RegionType;

#undef SCOREP_REGION_TYPE



#define SCOREP_RMA_SYNC_TYPES \
    SCOREP_RMA_SYNC_TYPE( MEMORY, memory, "memory" )             \
    SCOREP_RMA_SYNC_TYPE( NOTIFY_IN, notify_in, "notify in" )    \
    SCOREP_RMA_SYNC_TYPE( NOTIFY_OUT, notify_out, "notify out" )

typedef enum SCOREP_RmaSyncType
{
#define SCOREP_RMA_SYNC_TYPE( upper, lower, name )  SCOREP_RMA_SYNC_TYPE_ ## upper,
    SCOREP_RMA_SYNC_TYPES
    #undef SCOREP_RMA_SYNC_TYPE

    SCOREP_INVALID_RMA_SYNC_TYPE 
} SCOREP_RmaSyncType;



#define SCOREP_RMA_SYNC_LEVELS \
    SCOREP_RMA_SYNC_LEVEL( NONE, none, "none", 0 ) \
    SCOREP_RMA_SYNC_LEVEL( PROCESS, process, "process", 1 << 0 ) \
    SCOREP_RMA_SYNC_LEVEL( MEMORY, memory, "memory", 1 << 1 )

typedef enum SCOREP_RmaSyncLevel
{
#define SCOREP_RMA_SYNC_LEVEL( upper, lower, name, value ) \
    SCOREP_RMA_SYNC_LEVEL_ ## upper = value,

    SCOREP_RMA_SYNC_LEVELS
#undef SCOREP_RMA_SYNC_LEVEL
} SCOREP_RmaSyncLevel;


#define SCOREP_RMA_ATOMIC_TYPES \
    SCOREP_RMA_ATOMIC_TYPE( ACCUMULATE, accumulate,      "accumulate" )   \
    SCOREP_RMA_ATOMIC_TYPE( INCREMENT, increment,       "increment" )     \
    SCOREP_RMA_ATOMIC_TYPE( TEST_AND_SET, test_and_set,    "test and set" ) \
    SCOREP_RMA_ATOMIC_TYPE( COMPARE_AND_SWAP, compare_and_swap, "compare and swap" ) \
    SCOREP_RMA_ATOMIC_TYPE( SWAP, swap, "swap" ) \
    SCOREP_RMA_ATOMIC_TYPE( FETCH_AND_ADD, fetch_and_add, "fetch and add" ) \
    SCOREP_RMA_ATOMIC_TYPE( FETCH_AND_INCREMENT, fetch_and_increment, "fetch and increment" ) \
    SCOREP_RMA_ATOMIC_TYPE( ADD, add, "add" ) \
    SCOREP_RMA_ATOMIC_TYPE( FETCH_AND_ACCUMULATE, fetch_and_op, "fetch and accumulate with user-specified operator" )

typedef enum SCOREP_RmaAtomicType
{
#define SCOREP_RMA_ATOMIC_TYPE( upper, lower, name ) SCOREP_RMA_ATOMIC_TYPE_ ## upper,
    SCOREP_RMA_ATOMIC_TYPES
    #undef SCOREP_RMA_ATOMIC_TYPE

    SCOREP_INVALID_RMA_ATOMIC_TYPE
} SCOREP_RmaAtomicType;


typedef enum SCOREP_SamplingSetClass
{
    SCOREP_SAMPLING_SET_ABSTRACT, 
    SCOREP_SAMPLING_SET_CPU,      
    SCOREP_SAMPLING_SET_GPU       
} SCOREP_SamplingSetClass;

typedef enum SCOREP_MetricScope
{
    SCOREP_METRIC_SCOPE_LOCATION         = 0,
    SCOREP_METRIC_SCOPE_LOCATION_GROUP   = 1,
    SCOREP_METRIC_SCOPE_SYSTEM_TREE_NODE = 2,
    SCOREP_METRIC_SCOPE_GROUP            = 3,

    SCOREP_INVALID_METRIC_SCOPE 
} SCOREP_MetricScope;

typedef enum SCOREP_MetricOccurrence
{
    SCOREP_METRIC_OCCURRENCE_SYNCHRONOUS_STRICT = 0,
    SCOREP_METRIC_OCCURRENCE_SYNCHRONOUS        = 1,
    SCOREP_METRIC_OCCURRENCE_ASYNCHRONOUS       = 2,

    SCOREP_INVALID_METRIC_OCCURRENCE 
} SCOREP_MetricOccurrence;

#define SCOREP_IO_PARADIGMS \
    SCOREP_IO_PARADIGM( POSIX,           posix,           "POSIX" ) \
    SCOREP_IO_PARADIGM( ISOC,            isoc,            "ISOC" ) \
    SCOREP_IO_PARADIGM( MPI,             mpi,             "MPI-IO" )

typedef enum SCOREP_IoParadigmType
{
#define SCOREP_IO_PARADIGM( upper, lower, id_name ) SCOREP_IO_PARADIGM_ ## upper,
    SCOREP_IO_PARADIGMS
    #undef SCOREP_IO_PARADIGM
    SCOREP_INVALID_IO_PARADIGM_TYPE
} SCOREP_IoParadigmType;

/* The compile time static number of known parallel paradigms */
#define SCOREP_NUM_IO_PARADIGMS SCOREP_INVALID_IO_PARADIGM_TYPE

typedef enum SCOREP_IoAccessMode
{
    SCOREP_IO_ACCESS_MODE_NONE = 0,
    SCOREP_IO_ACCESS_MODE_READ_ONLY,
    SCOREP_IO_ACCESS_MODE_WRITE_ONLY,
    SCOREP_IO_ACCESS_MODE_READ_WRITE,
    SCOREP_IO_ACCESS_MODE_EXECUTE_ONLY,
    SCOREP_IO_ACCESS_MODE_SEARCH_ONLY,
} SCOREP_IoAccessMode;

typedef enum SCOREP_IoCreationFlag
{
    SCOREP_IO_CREATION_FLAG_NONE                    = 0,
    SCOREP_IO_CREATION_FLAG_CREATE                  = ( 1 << 0 ),
    SCOREP_IO_CREATION_FLAG_TRUNCATE                = ( 1 << 1 ),
    SCOREP_IO_CREATION_FLAG_DIRECTORY               = ( 1 << 2 ),
    SCOREP_IO_CREATION_FLAG_EXCLUSIVE               = ( 1 << 3 ),
    SCOREP_IO_CREATION_FLAG_NO_CONTROLLING_TERMINAL = ( 1 << 4 ),
    SCOREP_IO_CREATION_FLAG_NO_FOLLOW               = ( 1 << 5 ),
    SCOREP_IO_CREATION_FLAG_PATH                    = ( 1 << 6 ),
    SCOREP_IO_CREATION_FLAG_TEMPORARY_FILE          = ( 1 << 7 ),
    SCOREP_IO_CREATION_FLAG_LARGEFILE               = ( 1 << 8 ),
    SCOREP_IO_CREATION_FLAG_NO_SEEK                 = ( 1 << 9 ),
    SCOREP_IO_CREATION_FLAG_UNIQUE                  = ( 1 << 10 )
} SCOREP_IoCreationFlag;

typedef enum SCOREP_IoStatusFlag
{
    SCOREP_IO_STATUS_FLAG_NONE            = 0,
    SCOREP_IO_STATUS_FLAG_CLOSE_ON_EXEC   = ( 1 << 0 ),
    SCOREP_IO_STATUS_FLAG_APPEND          = ( 1 << 1 ),
    SCOREP_IO_STATUS_FLAG_NON_BLOCKING    = ( 1 << 2 ),
    SCOREP_IO_STATUS_FLAG_ASYNC           = ( 1 << 3 ),
    SCOREP_IO_STATUS_FLAG_SYNC            = ( 1 << 4 ),
    SCOREP_IO_STATUS_FLAG_DATA_SYNC       = ( 1 << 5 ),
    SCOREP_IO_STATUS_FLAG_AVOID_CACHING   = ( 1 << 6 ),
    SCOREP_IO_STATUS_FLAG_NO_ACCESS_TIME  = ( 1 << 7 ),
    SCOREP_IO_STATUS_FLAG_DELETE_ON_CLOSE = ( 1 << 8 )
} SCOREP_IoStatusFlag;

typedef enum SCOREP_IoSeekOption
{
    SCOREP_IO_SEEK_FROM_START = 0,
    SCOREP_IO_SEEK_FROM_CURRENT,
    SCOREP_IO_SEEK_FROM_END,
    SCOREP_IO_SEEK_DATA,
    SCOREP_IO_SEEK_HOLE,

    SCOREP_IO_SEEK_INVALID 
} SCOREP_IoSeekOption;

typedef enum SCOREP_IoOperationMode
{
    SCOREP_IO_OPERATION_MODE_READ = 0,
    SCOREP_IO_OPERATION_MODE_WRITE,
    SCOREP_IO_OPERATION_MODE_FLUSH
} SCOREP_IoOperationMode;

typedef enum SCOREP_IoOperationFlag
{
    SCOREP_IO_OPERATION_FLAG_NONE           = 0,
    SCOREP_IO_OPERATION_FLAG_BLOCKING       = 0,
    SCOREP_IO_OPERATION_FLAG_NON_BLOCKING   = ( 1 << 0 ),
    SCOREP_IO_OPERATION_FLAG_COLLECTIVE     = ( 1 << 1 ),
    SCOREP_IO_OPERATION_FLAG_NON_COLLECTIVE = 0
} SCOREP_IoOperationFlag;


#define SCOREP_IPC_DATATYPES \
    SCOREP_IPC_DATATYPE( BYTE ) \
    SCOREP_IPC_DATATYPE( CHAR ) \
    SCOREP_IPC_DATATYPE( UNSIGNED_CHAR ) \
    SCOREP_IPC_DATATYPE( INT ) \
    SCOREP_IPC_DATATYPE( UNSIGNED ) \
    SCOREP_IPC_DATATYPE( INT32_T ) \
    SCOREP_IPC_DATATYPE( UINT32_T ) \
    SCOREP_IPC_DATATYPE( INT64_T ) \
    SCOREP_IPC_DATATYPE( UINT64_T ) \
    SCOREP_IPC_DATATYPE( DOUBLE )

typedef enum SCOREP_Ipc_Datatype
{
#define SCOREP_IPC_DATATYPE( datatype ) \
    SCOREP_IPC_ ## datatype,
    SCOREP_IPC_DATATYPES
#undef SCOREP_IPC_DATATYPE
    SCOREP_IPC_NUMBER_OF_DATATYPES
} SCOREP_Ipc_Datatype;

#define SCOREP_IPC_OPERATIONS \
    SCOREP_IPC_OPERATION( BAND ) \
    SCOREP_IPC_OPERATION( BOR ) \
    SCOREP_IPC_OPERATION( MIN ) \
    SCOREP_IPC_OPERATION( MAX ) \
    SCOREP_IPC_OPERATION( SUM )

typedef enum SCOREP_Ipc_Operation
{
#define SCOREP_IPC_OPERATION( op ) \
    SCOREP_IPC_ ## op,
    SCOREP_IPC_OPERATIONS
#undef SCOREP_IPC_OPERATION
    SCOREP_IPC_NUMBER_OF_OPERATIONS
} SCOREP_Ipc_Operation;


typedef enum SCOREP_Substrates_RequirementFlag
{
    SCOREP_SUBSTRATES_REQUIREMENT_CREATE_EXPERIMENT_DIRECTORY,       
    SCOREP_SUBSTRATES_REQUIREMENT_PREVENT_ASYNC_METRICS,             
    SCOREP_SUBSTRATES_REQUIREMENT_PREVENT_PER_HOST_AND_ONCE_METRICS, 
    SCOREP_SUBSTRATES_NUM_REQUIREMENTS                               
} SCOREP_Substrates_RequirementFlag;

#endif /* SCOREP_PUBLICTYPES_H */