ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Updated integrated VT to version 5.11.1

Просмотр исходного кода 
(waiting for successful sanity checks (MTT) before moving to v1.5)

This commit was SVN r24803.
Этот коммит содержится в:
Matthias Jurenz 2011-06-22 13:58:00 +00:00
родитель 103044d3b7
Коммит 0ecce8e3dd
493 изменённых файлов: 73896 добавлений и 21287 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
ompi/contrib/vt/vt/AUTHORS
Просмотреть файл

@ -10,6 +10,8 @@ Jens Doleschal
Joachim Protze
Holger Mickler
Michael Heyde
Robert Dietrich
Robert Schoene
Matthias Mueller
Staff at HLRS:

27
ompi/contrib/vt/vt/CONFIG-EXAMPLES
Просмотреть файл

@ -1,27 +0,0 @@
+++ SGI Altix 4700 (TU Dresden, ZIH)
./configure CC=icc CXX=icpc F77=ifort FC=ifort --with-local-tmp-dir=/scratch --with-papi-dir=/opt/papi/3.2.1 --with-papi-lib="-lpapi /opt/papi/3.2.1/lib/libpfm.a" --with-dyninst-dir=/licsoft/tools/dyninst/5.0.1
+++ IBM Power6 575 (Research Centre Juelich)
./configure AR="ar -X32_64" NM="nm -X32_64 -B" CC=xlc_r CFLAGS="-O2 -g -q64" CXX=xlC_r CXXFLAGS="-O2 -g -q64" F77=xlf_r FFLAGS="-O2 -g -q64" FC=xlf90_r FCFLAGS="-O2 -g -q64" MPICC=mpcc_r MPIF77=mpxlf_r --disable-shared --with-mpi-dir=/usr/lpp/ppe.poe --with-papi-dir=/usr/local/beta/papi --with-papi-lib=-lpapi64
+++ BlueGene/P (Research Centre Juelich)
./configure --build=powerpc64-unknown-linux-gnu --host=powerpc64-ibm-linux CC=bgxlc_r CXX=bgxlC_r F77=bgxlf_r FC=bgxlf95_r MPICC=mpixlc_r CC_FOR_BUILD=xlc_r --disable-shared CXX_FOR_BUILD=xlC_r --with-cross-prefix=bg --with-mpi-dir=/bgsys/drivers/V1R2M0_200_2008-080513P/ppc/comm/default --with-mpibgp --with-zlib-dir=/usr/local/bg_soft/zlib
+++ BlueGene/L (University of Edinburgh)
./configure CC=blrts_xlc CFLAGS="-O2 -g" CXX=blrts_xlC CXXFLAGS="-O2 -g" F77=blrts_xlf90 FC=blrts_xlf90 CC_FOR_BUILD=xlc_r CXX_FOR_BUILD=xlC_r MPICC=mpixlc --build=powerpc64-unknown-linux-gnu --host=powerpc64-ibm-linux --disable-shared --with-otf-lib=-lotf --with-mpi-dir=/bgl/BlueLight/ppcfloor/bglsys --with-mpi-lib=-lmpich.rts --with-pmpi-lib=-lmpich.rts --with-fmpi-lib=-lfmpich.rts
+++ NEC SX-8 (High Performance Computing Center Stuttgart)
./configure CC=sxcc CXX=sxc++ F77=sxf90 FC=sxf90 AR=sxar MPICC=sxmpicc CC_FOR_BUILD=cc CXX_FOR_BUILD=c++ RANLIB="sxar st" OMPFLAG=-Popenmp --build=ia64-unknown-linux-gnu --host=sx8-nec-superux15.1 --with-otf-lib=-lotf
+++ Sun Fire E6900 (RWTH Aachen)
./configure CC=cc CXX=CC F77=f90 F90=f90 CFLAGS="-xtarget=ultra4 -fast -xarch=v9a" CXXFLAGS="-xtarget=ultra4 -fast -xarch=v9a" FCFLAGS="-xtarget=ultra4 -fast -xarch=v9a" FFLAGS="-xtarget=ultra4 -fast -xarch=v9a" --with-mpi-lib=-lmpi_mt --with-pmpi-lib=-lmpi_mt --enable-fmpi-lib
+++ Cray XT4 (NCCS)
PGI: ./configure CC="cc" CXX="CC" F77="ftn" FC="ftn" CFLAGS="-fastsse -Mipa=fast,inline -g" CXXFLAGS="-fastsse -Mipa=fast,inline -g" FFLAGS="-fastsse -Mipa=fast,inline -g" FCFLAGS="-fastsse -Mipa=fast,inline -g" --enable-compinst=pgi --enable-fmpi-lib --disable-iotrace --disable-libctrace --with-local-tmp-dir="."
GNU: ./configure CC="cc" CXX="CC" F77="ftn" FC="ftn" CFLAGS="-O3 -g" CXXFLAGS="-O3 -g" FFLAGS="-O3 -g" FCFLAGS="-O3 -g" --enable-compinst=gnu --enable-fmpi-lib --disable-iotrace --disable-libctrace --with-local-tmp-dir="."

2
ompi/contrib/vt/vt/COPYING
Просмотреть файл

@ -1,4 +1,4 @@
Copyright (c) 2005-2010, ZIH, TU Dresden, Federal Republic of Germany
Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
Copyright (c) 1998-2005, Forschungszentrum Juelich, Juelich Supercomputing
Centre, Federal Republic of Germany

156
ompi/contrib/vt/vt/ChangeLog
Просмотреть файл

@ -1,27 +1,149 @@
5.8.4openmpi
5.11.1openmpi
- updated version of internal OTF to 1.9.1openmpi
(see extlib/otf/ChangeLog)
- improved filtering of CUDA kernels
- fixed unification of local process group definitions
5.11
- updated version of internal OTF to 1.9sawfish
(see extlib/otf/ChangeLog)
- added support for Cray XE6
- added tool 'vtsetup' which provides a GUI to prepare measurement runs
with VampirTrace
- added application execution wrapper script 'vtrun' which performs MPI
and/or binary instrumentation at runtime
- extended Dyninst mutator tool 'vtdyn' to rewrite instrumented
application executables
- replaced basic blacklist functionality of vtdyn by the VT runtime
filter
- extended trace unification to match p2p message event records
- enhanced unification of local traces from very large runs in respect
of parallelism and memory usage
- extended user API to perform user defined communication
- extended user API for regions to support dynamically generated region
names
- added support for asynchronous plugin counters
- added support for CUDA 4.0
- removed support for CUDA 2.x
- added CUDA performance counter support via CUPTI event API
- added option '-vt:noopari' to compiler wrapper commands to disable
instrumentation of OpenMP constructs by OPARI
- added configure option
'--with-wrapper-<cc|cxx|f77|fc|nvcc>-default-partype=TYPE' to set
default application parallelization type for compiler wrappers
- fixed thread-safety issue in Fortran bindings of user API
- fixed handling NULL value of pathname given to certain I/O calls
(e.g. fopen, open, unlink)
- fixed a bug in the compiler wrappers: don't try to rename the
compiler output of an OPARI modified source file if it's
specified by '-o'
- fixed base of cycle counter timer on PPC with MacOS
- fixed default grouping of user functions whose name appears in
predefined groups (e.g. VT-API)
- fixed error when using the compiler wrappers with PDT/TAU + manual
instrumentation
- bugfix to OPARI (see tools/opari/ChangeLog:18)
5.8.3openmpi
5.10.1
- updated version of internal OTF to 1.8.1sturgeon
(see extlib/otf/ChangeLog)
- added configure option '--<en|dis>able-mpiunify-lib' to control
building of the MPI trace unification library (libvt-mpi-unify)
- added GPU memory tracing for CUDA runtime API
- fixed configure tests for conversion of Fortran MPI handles
- fixed collecting symbol information of shared libraries which are
instrumented by the GNU, Intel, PathScale, or PGI 9 compiler
- fixed an error in memory management of CUDA devices
- fixed CUDA device management (CUDA runtime)
- fixed finalize problem in CUDA runtime wrapper, which in cases
produced an unspecific driver error
- added an additional check to avoid a possible deadlock in vt_open(),
which might occur, if something during opening invokes vt_open()
- fixed not-increasing timestamps error which occurred if an interval
for writing statistics (env. VT_STAT_INTV) is set
- fixed wrong UNIMCI language bindings for Fortran applications
(enforces building of the Fortran MPI wrapper library 'libvt-fmpi')
- fixed handling of command line options in vtjava
5.10
- updated version of internal OTF to 1.8sturgeon
(see extlib/otf/ChangeLog)
- added support for automatic source code instrumentation by PDT/TAU
- added MPI-parallel version of vtfilter (vtfilter-mpi) with support
for rank specific filtering
- enhanced termination of MPI-parallel trace unifier in case of an error
- changed byte counts of collective communication records
(see FAQ entry D.8 in the user manual)
- added changes of CUDA 3.2 runtime API
- extended vtjava to set the trace file prefix to the jar/class file
- fixed compile error on Red Hat 5.x which occurred if using GNU
compiler with -D_FORTIFY_SOURCE=2
- fixed faulty library dependencies to MPI which caused in a
segmentation fault on AIX
(on AIX libvt-fmpi needs additional dependencies to the Fortran
runtime libraries; for now building of shared libraries is disabled)
- fixed a potential segmentation fault in CUDA runtime API tracing
(for disabled CUDA kernel tracing and CUDA synchronization level 3)
- usage of CUDA and PAPI does not result in an error any more
- fixed measurement of GPU idle time
- corrected number of used CUDA events for disabled kernel tracing
- fixed corrupt call stack after an intermediate buffer flush if
VT_MAX_FLUSHES is set to 0(=unlimited)
- fixed detection of executable's pathname on UnionFS
- fixed detection of OpenMP flags in the compiler wrappers
- fixed memory source/destination overlap in a MPI_Gatherv call which
caused MPICH2 to abort
- fixed potential segmentation fault during collecting symbol
information for instrumentation with the GNU, Intel, PathScale,
and PGI 9 compiler
- fixed segmentation fault which occurred if using PAPI 4 together with
libc I/O tracing
- fixed pathname of the JVMTI agent library in vtjava
- fixed assertion in vtunify which occurred if enhanced time sync. is
enabled
- fixed segmentation fault in vtunify-mpi which occurred if using more
MPI tasks than necessary
5.8.2openmpi
- fixed buffer overflow which occurred if marker or event comment
records generated
- fixed bug in MPI-I/O tracing: tracking MPI file handles even if
MPI_File_open isn't recorded
- enforced creating of event/summary files even process/thread doesn't
produce trace data
5.9
- updated version of internal OTF to 1.7.1catfish
(see extlib/otf/ChangeLog)
- added support for tracing NVIDIA CUDA runtime API
- improved automatic trace unification for MPI applications:
use application allocated MPI processes for unification
- extended user API: added "buffer rewind" as an alternative to "on/off"
- extended the MPI-rank specific filtering to disable ranks completely
- added environment variable VT_OMPTRACE to enable/disable tracing of
OpenMP events instrumented by OPARI
- added writing of collective begin/end records for MPI Collective
operations
- reduced amount of resulting files:
- write only one unify control file (*.uctl) for the whole trace
- do not write *.filt files anymore
- added environment variables VT_MAX_MPI_COMMS and VT_MAX_MPI_WINS for
adjusting internal default limits of used MPI communicators/windows
- corrected finalize behavior for C++ applications with static objects
(e.g. MPI_Finalize in the destructor of a singleton)
- fixed potential buffer overflow on determining pathname of the
application executable
- fixed loading of dynamic libraries on AIX
- fixed bugs in the compiler wrappers:
- don't try to rename the compiler output of an OPARI modified
source file if it's specified by the compiler flag '-o'
- changed order of linking libraries to record also MPI function
calls which come from user libraries
- corrected parsing of separated arguments of the compiler
options -I, -L, and -l (e.g. -I <dir>)
- fixed bug in vtunify: do only write active stream/process ids to the
OTF master control file (*.otf)
- if configuring inside Open MPI, install header files into
<includedir>/vampirtrace even the configure option '--includedir' is
specified
5.8.1openmpi
- updated version of internal OTF to 1.6.5openmpi
5.8.2
- fixed buffer overflow which occurred if marker or event comment
records generated
- fixed bug in MPI-I/O tracing: tracking MPI file handles even if
MPI_File_open isn't recorded
5.8.1
- updated version of internal OTF to 1.6.5stingray
(see extlib/otf/ChangeLog)
- added support for tracing functions in shared libraries instrumented
by the GNU, Intel, PathScale, or PGI 9 compiler
@ -56,8 +178,8 @@
on 32bit platforms
- patched libtool to avoid a bug in detection of the PGI 10 compilers
5.8openmpi
- updated version of internal OTF to 1.6.4openmpi
5.8
- updated version of internal OTF to 1.6.4stingray
(see extlib/otf/ChangeLog)
- added support for tracing calls to arbitrary third party libraries
The new tool 'vtlibwrapgen' can be used to generate a wrapper library.
@ -139,7 +261,7 @@
- fixed a bug in vtfilter: strip the '.otf'-suffix from input/output
trace file names, if necessary
- fixed a bug in the Fortran compiler wrappers: don't remove generated
- OPARI header files (*.opari.inc) before compiling the table source
OPARI header files (*.opari.inc) before compiling the table source
- file (opari.tab.c)
- enhancement to OPARI (see tools/opari/ChangeLog:16,17)
- use handle from dlopen(<libc>) for dlsym() calls instead of RTLD_NEXT

40
ompi/contrib/vt/vt/INSTALL
Просмотреть файл

@ -197,6 +197,33 @@ How to install and configure VampirTrace
--with-dyninst-dir=DYNIDIR
give the path for DYNINST, default: /usr
--with-dyninst-inc-dir=DYNIINCDIR
give the path for Dyninst-include files,
default: DYNIDIR/include
--with-dyninst-lib-dir=DYNILIBDIR
give the path for Dyninst-libraries,
default: DYNIDIR/lib
--with-dyninst-lib=DYNILIB
use given Dyninst lib, default: -ldyninstAPI
--with-tau-instrumentor=TAUINSTUMENTOR
give the command for the TAU instrumentor,
default: tau_instrumentor
--with-pdt-cparse=PDTCPARSE
give the command for PDT C source code parser,
default: cparse
--with-pdt-cxxparse=PDTCXXPARSE
give the command for PDT C++ source code parser,
default: cxxparse
--with-pdt-fparse=PDTFPARSE
give the command for PDT Fortran source code parser,
default: f95parse, f90parse, or gfparse
--with-papi-dir=PAPIDIR
give the path for PAPI, default: /usr
@ -299,15 +326,14 @@ How to install and configure VampirTrace
-----------------
Building VampirTrace on cross compilation platforms needs some special attention.
The compiler wrappers and OPARI are built for the front-end (build system) whereas
the VampirTrace libraries, vtdyn, vtunify, and vtfilter are built for the back-end
(host system). Some configure options which are of interest for cross compilation
are shown below:
The compiler wrappers, OPARI, and the Library Wrapper Generator are built for the
front-end (build system) whereas the VampirTrace libraries, vtdyn, vtunify, and
vtfilter are built for the back-end (host system). Some configure options which are
of interest for cross compilation are shown below:
* Set CC, CXX, F77, and FC to the cross compilers installed on the front-end.
* Set CXX_FOR_BUILD to the native compiler of the front-end
(used to compile compiler wrappers and OPARI only).
* Set CC_FOR_BUILD and CXX_FOR_BUILD to the native compilers of the front-end.
* Set --host= to the output of config.guess on the back-end.
@ -321,7 +347,7 @@ How to install and configure VampirTrace
based front-end:
./configure CC=sxcc CXX=sxc++ F77=sxf90 FC=sxf90 MPICC=sxmpicc
AR=sxar RANLIB="sxar st" CXX_FOR_BUILD=c++
AR=sxar RANLIB="sxar st" CC_FOR_BUILD=cc CXX_FOR_BUILD=c++
--host=sx6-nec-superux14.1
--with-cross-prefix=sx
--with-otf-lib=-lotf

2
ompi/contrib/vt/vt/LICENSE
Просмотреть файл

@ -1,4 +1,4 @@
Copyright (c) 2005-2010, ZIH, TU Dresden, Federal Republic of Germany
Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
Copyright (c) 1998-2005, Forschungszentrum Juelich, Juelich Supercomputing
Centre, Federal Republic of Germany

6
ompi/contrib/vt/vt/Makefile.am
Просмотреть файл

@ -1,10 +1,12 @@
ACLOCAL_AMFLAGS = -I config/m4
SUBDIRS = \
util \
extlib \
util \
rfg \
vtlib \
tools \
include \
doc \
etc
@ -13,11 +15,11 @@ vtdatadir = $(datadir)
EXTRA_DIST = \
config_bottom.h \
CONFIG-EXAMPLES \
VERSION \
config/defaults/bgl \
config/defaults/bgp \
config/defaults/crayxt \
config/defaults/crayxe \
config/defaults/ibm \
config/defaults/ibm-64 \
config/defaults/sicortex \

2
ompi/contrib/vt/vt/VERSION
Просмотреть файл

@ -1 +1 @@
5.8.4openmpi
5.11.1openmpi

9
ompi/contrib/vt/vt/acinclude.m4
Просмотреть файл

@ -6,6 +6,9 @@ m4_include(config/m4/acinclude.cpc.m4)
m4_include(config/m4/acinclude.cross.m4)
m4_include(config/m4/acinclude.csfs.m4)
m4_include(config/m4/acinclude.ctool.m4)
m4_include(config/m4/acinclude.cudawrap.m4)
m4_include(config/m4/acinclude.cupti.m4)
m4_include(config/m4/acinclude.cxxrtlib.m4)
m4_include(config/m4/acinclude.dl.m4)
m4_include(config/m4/acinclude.dyninst.m4)
m4_include(config/m4/acinclude.etimesync.m4)
@ -21,16 +24,20 @@ m4_include(config/m4/acinclude.math.m4)
m4_include(config/m4/acinclude.memhooks.m4)
m4_include(config/m4/acinclude.metrics.m4)
m4_include(config/m4/acinclude.mpi.m4)
m4_include(config/m4/acinclude.nm.m4)
m4_include(config/m4/acinclude.omp.m4)
m4_include(config/m4/acinclude.otf.m4)
m4_include(config/m4/acinclude.papi.m4)
m4_include(config/m4/acinclude.pform.m4)
m4_include(config/m4/acinclude.plugincntr.m4)
m4_include(config/m4/acinclude.pthread.m4)
m4_include(config/m4/acinclude.rusage.m4)
m4_include(config/m4/acinclude.tauinst.m4)
m4_include(config/m4/acinclude.threads.m4)
m4_include(config/m4/acinclude.timer.m4)
m4_include(config/m4/acinclude.mpiunifylib.m4)
m4_include(config/m4/acinclude.unimci.m4)
m4_include(config/m4/acinclude.vtrun.m4)
m4_include(config/m4/acinclude.vtsetup.m4)
m4_include(config/m4/acinclude.zlib.m4)
m4_include(config/m4/acarchive/ax_openmp.m4)
m4_include(config/m4/acarchive/acx_pthread.m4)

5
ompi/contrib/vt/vt/config/defaults/bgp
Просмотреть файл

@ -4,9 +4,14 @@ F77="bgxlf_r"
FC="bgxlf95_r"
MPICC="mpixlc_r"
MPICXX="mpixlcxx_r"
CFLAGS="-qtune=450 -qarch=450 -O3 -qstrict"
CXXFLAGS="-qtune=450 -qarch=450 -O3 -qstrict"
CC_FOR_BUILD="xlc_r"
CXX_FOR_BUILD="xlC_r"
CFLAGS_FOR_BUILD="-O3 -qstrict"
CXXFLAGS_FOR_BUILD="-O3 -qstrict"
enable_shared="no"
enable_cpuidtrace="no"
with_cross_prefix="bg"
with_mpibgp="yes"
with_cxxrtlib="-L/opt/ibmcmp/lib/bg/bglib -libmc++ -lstdc++"

10
ompi/contrib/vt/vt/config/defaults/crayxe Обычный файл
Просмотреть файл

@ -0,0 +1,10 @@
CC="cc"
CXX="CC"
F77="ftn"
FC="ftn"
CFLAGS="-target=$XTPE_COMPILE_TARGET"
CXXFLAGS="-target=$XTPE_COMPILE_TARGET"
FFLAGS="-target=$XTPE_COMPILE_TARGET"
FCFLAGS="-target=$XTPE_COMPILE_TARGET"
enable_shared="no"
with_mpich2="yes"

1
ompi/contrib/vt/vt/config/defaults/crayxt
Просмотреть файл

@ -6,4 +6,5 @@ CFLAGS="-target=$XTPE_COMPILE_TARGET"
CXXFLAGS="-target=$XTPE_COMPILE_TARGET"
FFLAGS="-target=$XTPE_COMPILE_TARGET"
FCFLAGS="-target=$XTPE_COMPILE_TARGET"
enable_shared="no"
with_mpich2="yes"

1
ompi/contrib/vt/vt/config/defaults/ibm-64
Просмотреть файл

@ -1,4 +1,5 @@
AR="ar -X64"
NM="nm -B -X64"
CC="xlc_r"
CXX="xlC_r"
F77="xlf_r"

4
ompi/contrib/vt/vt/config/defaults/necsx
Просмотреть файл

@ -9,17 +9,19 @@ MPICXX="sxmpic++"
MPIF77="sxmpif90"
CC_FOR_BUILD="cc"
CXX_FOR_BUILD="c++"
RANLIB="echo"
CFLAGS="-Csopt"
CXXFLAGS="-Csopt"
FFLAGS="-Csopt"
FCFLAGS="-Csopt"
CFLAGS_FOR_BUILD="-O2"
CXXFLAGS_FOR_BUILD="-O2"
OPENMP_CFLAGS="-Popenmp"
PTHREAD_LIBS="-lpthread"
enable_shared="no"
enable_memtrace="no"
enable_libtrace="no"
enable_cpuidtrace="no"
enable_mpi2_io="no"
enable_metrics="necsx"
with_cross_prefix="sx"
with_mpisx="yes"

42
ompi/contrib/vt/vt/config/m4/acinclude.compinst.m4
Просмотреть файл

@ -3,6 +3,7 @@ AC_DEFUN([ACVT_COMPINST],
compinst_error="no"
check_compinst="yes"
force_compinst="no"
have_compinst="no"
compinst_type=
compinst_cflags=
@ -35,10 +36,10 @@ AC_DEFUN([ACVT_COMPINST],
compinst_xl_fflags="$compinst_xl_cflags"
compinst_xl_fcflags="$compinst_xl_cflags"
compinst_nec_cflags="-ftrace"
compinst_nec_cxxflags="$compinst_nec_cflags"
compinst_nec_fflags="$compinst_nec_cflags"
compinst_nec_fcflags="$compinst_nec_cflags"
compinst_necsx_cflags="-ftrace"
compinst_necsx_cxxflags="$compinst_necsx_cflags"
compinst_necsx_fflags="$compinst_necsx_cflags"
compinst_necsx_fcflags="$compinst_necsx_cflags"
compinst_openuh_cflags="-fb_create inst -fb_type=1 -fb_phase=0 -epilog -OPT:instr_proc"
compinst_openuh_cxxflags="$compinst_openuh_cflags"
@ -49,7 +50,7 @@ AC_DEFUN([ACVT_COMPINST],
AC_ARG_ENABLE(compinst,
AC_HELP_STRING([--enable-compinst=TYPE],
[enable support for compiler instrumentation (gnu,intel,pathscale,pgi,pgi9,sun,xl,nec,openuh), default: automatically by configure]),
[enable support for compiler instrumentation (gnu,intel,pathscale,pgi,pgi9,sun,xl,necsx,openuh), default: automatically by configure]),
[AS_IF([test x"$enableval" = "xno"], [check_compinst="no"], [enable_compinst="$enableval"])])
AS_IF([test x"$check_compinst" = "xyes"],
@ -79,8 +80,8 @@ AC_DEFUN([ACVT_COMPINST],
xl)
compinst_type="xl"
;;
nec)
compinst_type="nec"
necsx)
compinst_type="necsx"
;;
openuh)
compinst_type="openuh"
@ -106,7 +107,7 @@ AC_DEFUN([ACVT_COMPINST],
],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: the version of the Intel compiler ($compver) doesn't support instrumentation!])
AC_MSG_NOTICE([error: the version of the Intel compiler ($compver) doesn't support instrumentation])
compinst_error="yes"
])
;;
@ -121,7 +122,7 @@ AC_DEFUN([ACVT_COMPINST],
],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: the version of the Pathscale compiler ($compver) doesn't support instrumentation!])
AC_MSG_NOTICE([error: the version of the PathScale compiler ($compver) doesn't support instrumentation])
compinst_error="yes"
])
;;
@ -152,7 +153,7 @@ AC_DEFUN([ACVT_COMPINST],
AC_MSG_RESULT([sun])
;;
cc*)
AS_IF([test "$PLATFORM" = "crayxt"],
AS_IF([test "$PLATFORM" = "crayxt" -o "$PLATFORM" = "crayxe"],
[
for f in -V --version; do
case `$CC $f 2>&1` in
@ -199,13 +200,13 @@ AC_DEFUN([ACVT_COMPINST],
],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: the version of the OpenUH compiler ($compver) doesn't support instrumentation!])
AC_MSG_NOTICE([error: the version of the OpenUH compiler ($compver) doesn't support instrumentation])
compinst_error="yes"
])
;;
sxcc*)
compinst_type="nec"
AC_MSG_RESULT([nec])
compinst_type="necsx"
AC_MSG_RESULT([necsx])
;;
*)
;;
@ -214,7 +215,7 @@ AC_DEFUN([ACVT_COMPINST],
AS_IF([test x"$compinst_error" = "xno" -a x"$compinst_type" = x],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: the compiler '$base_CC' doesn't support instrumentation!])
AC_MSG_NOTICE([error: the compiler '$base_CC' doesn't support instrumentation])
compinst_error="yes"
])
])
@ -223,13 +224,14 @@ AC_DEFUN([ACVT_COMPINST],
[
AS_IF([test x"$compinst_type" = "xgnu" -o x"$compinst_type" = "xpgi9"],
[
ACVT_NM
ACVT_DL
])
])
AS_IF([test x"$compinst_error" = "xno" -a x"$compinst_type" != x],
[
have_compinst="yes"
case $compinst_type in
gnu)
compinst_cflags=$compinst_gnu_cflags
@ -261,11 +263,11 @@ AC_DEFUN([ACVT_COMPINST],
compinst_fflags=$compinst_xl_fflags
compinst_fcflags=$compinst_xl_fcflags
;;
nec)
compinst_cflags=$compinst_nec_cflags
compinst_cxxflags=$compinst_nec_cxxflags
compinst_fflags=$compinst_nec_fflags
compinst_fcflags=$compinst_nec_fcflags
necsx)
compinst_cflags=$compinst_necsx_cflags
compinst_cxxflags=$compinst_necsx_cxxflags
compinst_fflags=$compinst_necsx_fflags
compinst_fcflags=$compinst_necsx_fcflags
;;
openuh)
compinst_cflags=$compinst_openuh_cflags

432
ompi/contrib/vt/vt/config/m4/acinclude.compwrap.m4
Просмотреть файл

@ -1,94 +1,256 @@
AC_DEFUN([ACVT_COMPWRAP],
[
VT_WRAPPER_CC=
VT_WRAPPER_CXX=
VT_WRAPPER_F77=
VT_WRAPPER_FC=
VT_WRAPPER_EXTRA_CFLAGS=
VT_WRAPPER_EXTRA_CXXFLAGS=
VT_WRAPPER_EXTRA_FFLAGS=
VT_WRAPPER_EXTRA_FCFLAGS=
VT_WRAPPER_EXTRA_LDFLAGS=
VT_WRAPPER_EXTRA_LIBS=
VT_WRAPPER_VTLIB=
VT_WRAPPER_VTMPILIB=
VT_WRAPPER_VTMTLIB=
VT_WRAPPER_VTHYBLIB=
VT_WRAPPER_CC_COMPILER=$CC
VT_WRAPPER_CC_EXTRA_COMPILER_FLAGS=
VT_WRAPPER_CC_EXTRA_LINKER_FLAGS=
VT_WRAPPER_CC_EXTRA_LIBS=
VT_WRAPPER_CC_DYNINST_COMPILER_FLAGS=
VT_WRAPPER_CC_TAUINST_OPTS=
VT_WRAPPER_CC_TAUINST_PARSE_BIN=
VT_WRAPPER_CC_TAUINST_PARSE_OPTS=
VT_WRAPPER_CC_COMPINST_COMPILER_FLAGS=
VT_WRAPPER_CC_DEFAULT_PARTYPE="seq"
VT_WRAPPER_CXX_COMPILER=$CXX
VT_WRAPPER_CXX_EXTRA_COMPILER_FLAGS=
VT_WRAPPER_CXX_EXTRA_LINKER_FLAGS=
VT_WRAPPER_CXX_EXTRA_LIBS=
VT_WRAPPER_CXX_DYNINST_COMPILER_FLAGS=
VT_WRAPPER_CXX_TAUINST_OPTS=
VT_WRAPPER_CXX_TAUINST_PARSE_BIN=
VT_WRAPPER_CXX_TAUINST_PARSE_OPTS=
VT_WRAPPER_CXX_COMPINST_COMPILER_FLAGS=
VT_WRAPPER_CXX_DEFAULT_PARTYPE="seq"
VT_WRAPPER_F77_COMPILER=$F77
VT_WRAPPER_F77_EXTRA_COMPILER_FLAGS=
VT_WRAPPER_F77_EXTRA_LINKER_FLAGS=
VT_WRAPPER_F77_EXTRA_LIBS=
VT_WRAPPER_F77_DYNINST_COMPILER_FLAGS=
VT_WRAPPER_F77_TAUINST_OPTS=
VT_WRAPPER_F77_TAUINST_PARSE_BIN=
VT_WRAPPER_F77_TAUINST_PARSE_OPTS=
VT_WRAPPER_F77_COMPINST_COMPILER_FLAGS=
VT_WRAPPER_F77_DEFAULT_PARTYPE="seq"
VT_WRAPPER_FC_COMPILER=$FC
VT_WRAPPER_FC_EXTRA_COMPILER_FLAGS=
VT_WRAPPER_FC_EXTRA_LINKER_FLAGS=
VT_WRAPPER_FC_EXTRA_LIBS=
VT_WRAPPER_FC_DYNINST_COMPILER_FLAGS=
VT_WRAPPER_FC_TAUINST_OPTS=
VT_WRAPPER_FC_TAUINST_PARSE_BIN=
VT_WRAPPER_FC_TAUINST_PARSE_OPTS=
VT_WRAPPER_FC_COMPINST_COMPILER_FLAGS=
VT_WRAPPER_FC_DEFAULT_PARTYPE="seq"
VT_WRAPPER_NVCC_COMPILER=$NVCC
VT_WRAPPER_NVCC_EXTRA_COMPILER_FLAGS=
VT_WRAPPER_NVCC_EXTRA_LINKER_FLAGS=
VT_WRAPPER_NVCC_EXTRA_LIBS=
VT_WRAPPER_NVCC_DYNINST_COMPILER_FLAGS=
VT_WRAPPER_NVCC_TAUINST_OPTS=
VT_WRAPPER_NVCC_TAUINST_PARSE_BIN=
VT_WRAPPER_NVCC_TAUINST_PARSE_OPTS=
VT_WRAPPER_NVCC_COMPINST_COMPILER_FLAGS=
VT_WRAPPER_NVCC_DEFAULT_PARTYPE="seq"
VT_WRAPPER_VTLIB="-lvt"
VT_WRAPPER_VTMPILIB="-lvt-mpi"
VT_WRAPPER_VTMTLIB="-lvt-mt"
VT_WRAPPER_VTHYBLIB="-lvt-hyb"
VT_WRAPPER_OPARI_BIN=
VT_WRAPPER_OPARI_TAB_CC=
VT_WRAPPER_OPARI_TAB_CFLAGS=
VT_WRAPPER_COMPINST_CFLAGS=
VT_WRAPPER_COMPINST_CXXFLAGS=
VT_WRAPPER_COMPINST_FFLAGS=
VT_WRAPPER_COMPINST_FCFLAGS=
VT_WRAPPER_OPARI_OPTS=
VT_WRAPPER_OPARI_TAB_COMPILER=
VT_WRAPPER_OPARI_TAB_COMPILER_FLAGS=
VT_WRAPPER_TAUINST_BIN=
VT_WRAPPER_AVAIL_INST="manual"
VT_WRAPPER_DEFAULT_INST=manual
VT_WRAPPER_DEFAULT_INST="manual"
AC_REQUIRE([ACVT_PLATFORM])
AC_REQUIRE([ACVT_COMPINST])
AC_REQUIRE([ACVT_DYNINST])
AC_REQUIRE([ACVT_THREADS])
AC_ARG_WITH(wrapper-cc,
AC_HELP_STRING([--with-wrapper-cc],
AC_ARG_WITH(wrapper-cc-compiler,
AC_HELP_STRING([--with-wrapper-cc-compiler=WRAPPERCC],
[underlying C compiler command for vtcc, default: CC]),
[VT_WRAPPER_CC=$withval], [VT_WRAPPER_CC=$CC])
[VT_WRAPPER_CC_COMPILER=$withval])
AC_ARG_WITH(wrapper-cflags,
AC_HELP_STRING([--with-wrapper-cflags],
[extra flags to add to CFLAGS when using vtcc]),
[VT_WRAPPER_EXTRA_CFLAGS=$withval])
AC_ARG_WITH(wrapper-cc-compiler-flags,
AC_HELP_STRING([--with-wrapper-cc-compiler-flags=WRAPPERCCCFLAGS],
[extra compiler flags to add when using vtcc]),
[VT_WRAPPER_CC_EXTRA_COMPILER_FLAGS=$withval])
AC_ARG_WITH(wrapper-cxx,
AC_HELP_STRING([--with-wrapper-cxx],
AC_ARG_WITH(wrapper-cc-linker-flags,
AC_HELP_STRING([--with-wrapper-cc-linker-flags=WRAPPERCCLDFLAGS],
[extra linker flags to add when using vtcc]),
[VT_WRAPPER_CC_EXTRA_LINKER_FLAGS=$withval])
AC_ARG_WITH(wrapper-cc-libs,
AC_HELP_STRING([--with-wrapper-cc-libs=WRAPPERCCLIBS],
[extra libraries to link when using vtcc]),
[VT_WRAPPER_CC_EXTRA_LIBS=$withval])
AC_ARG_WITH(wrapper-cc-default-partype,
AC_HELP_STRING([--with-wrapper-cc-default-partype=TYPE],
[default parallelization type for vtcc (seq,mt,mpi,hyb), default: $VT_WRAPPER_CC_DEFAULT_PARTYPE]),
[
case $withval in
seq | mt | mpi | hyb)
VT_WRAPPER_CC_DEFAULT_PARTYPE=$withval
;;
*)
AC_MSG_ERROR([value of '--with-wrapper-cc-default-partype' not properly set])
;;
esac
])
AC_ARG_WITH(wrapper-cxx-compiler,
AC_HELP_STRING([--with-wrapper-cxx-compiler=WRAPPERCXX],
[underlying C++ compiler command for vtcxx, default: CXX]),
[VT_WRAPPER_CXX=$withval], [VT_WRAPPER_CXX=$CXX])
[VT_WRAPPER_CXX_COMPILER=$withval])
AC_ARG_WITH(wrapper-cxxflags,
AC_HELP_STRING([--with-wrapper-cxxflags],
[extra flags to add to CXXFLAGS when using vtcxx]),
[VT_WRAPPER_EXTRA_CXXFLAGS=$withval])
AC_ARG_WITH(wrapper-cxx-compiler-flags,
AC_HELP_STRING([--with-wrapper-cxx-compiler-flags=WRAPPERCXXCFLAGS],
[extra compiler flags to add when using vtcxx]),
[VT_WRAPPER_CXX_EXTRA_COMPILER_FLAGS=$withval])
AC_ARG_WITH(wrapper-f77,
AC_HELP_STRING([--with-wrapper-f77],
AC_ARG_WITH(wrapper-cxx-linker-flags,
AC_HELP_STRING([--with-wrapper-cxx-linker-flags=WRAPPERCXXLDFLAGS],
[extra linker flags to add when using vtcxx]),
[VT_WRAPPER_CXX_EXTRA_LINKER_FLAGS=$withval])
AC_ARG_WITH(wrapper-cxx-libs,
AC_HELP_STRING([--with-wrapper-cxx-libs=WRAPPERCXXLIBS],
[extra libraries to link when using vtcxx]),
[VT_WRAPPER_CXX_EXTRA_LIBS=$withval])
AC_ARG_WITH(wrapper-cxx-default-partype,
AC_HELP_STRING([--with-wrapper-cxx-default-partype=TYPE],
[default parallelization type for vtcxx (seq,mt,mpi,hyb), default: $VT_WRAPPER_CXX_DEFAULT_PARTYPE]),
[
case $withval in
seq | mt | mpi | hyb)
VT_WRAPPER_CXX_DEFAULT_PARTYPE=$withval
;;
*)
AC_MSG_ERROR([value of '--with-wrapper-cxx-default-partype' not properly set])
;;
esac
])
AC_ARG_WITH(wrapper-f77-compiler,
AC_HELP_STRING([--with-wrapper-f77-compiler=WRAPPERF77],
[underlying Fortran 77 compiler command for vtf77, default: F77]),
[VT_WRAPPER_F77=$withval], [VT_WRAPPER_F77=$F77])
[VT_WRAPPER_F77_COMPILER=$withval])
AC_ARG_WITH(wrapper-fflags,
AC_HELP_STRING([--with-wrapper-fflags],
[extra flags to add to FFLAGS when using vtf77]),
[VT_WRAPPER_EXTRA_FFLAGS=$withval])
AC_ARG_WITH(wrapper-f77-compiler-flags,
AC_HELP_STRING([--with-wrapper-f77-compiler-flags=WRAPPERF77CFLAGS],
[extra compiler flags to add when using vtf77]),
[VT_WRAPPER_F77_EXTRA_COMPILER_FLAGS=$withval])
AC_ARG_WITH(wrapper-fc,
AC_HELP_STRING([--with-wrapper-fc],
AC_ARG_WITH(wrapper-f77-linker-flags,
AC_HELP_STRING([--with-wrapper-f77-linker-flags=WRAPPERF77LDFLAGS],
[extra linker flags to add when using vtf77]),
[VT_WRAPPER_F77_EXTRA_LINKER_FLAGS=$withval])
AC_ARG_WITH(wrapper-f77-libs,
AC_HELP_STRING([--with-wrapper-f77-libs=WRAPPERF77LIBS],
[extra libraries to link when using vtf77]),
[VT_WRAPPER_F77_EXTRA_LIBS=$withval])
AC_ARG_WITH(wrapper-f77-default-partype,
AC_HELP_STRING([--with-wrapper-f77-default-partype=TYPE],
[default parallelization type for vtf77 (seq,mt,mpi,hyb), default: $VT_WRAPPER_F77_DEFAULT_PARTYPE]),
[
case $withval in
seq | mt | mpi | hyb)
VT_WRAPPER_F77_DEFAULT_PARTYPE=$withval
;;
*)
AC_MSG_ERROR([value of '--with-wrapper-f77-default-partype' not properly set])
;;
esac
])
AC_ARG_WITH(wrapper-fc-compiler,
AC_HELP_STRING([--with-wrapper-fc-compiler=WRAPPERFC],
[underlying Fortran compiler command for vtf90, default: FC]),
[VT_WRAPPER_FC=$withval], [VT_WRAPPER_FC=$FC])
[VT_WRAPPER_FC_COMPILER=$withval])
AC_ARG_WITH(wrapper-fcflags,
AC_HELP_STRING([--with-wrapper-fcflags],
[extra flags to add to FCFLAGS when using vtf90]),
[VT_WRAPPER_EXTRA_FCFLAGS=$withval])
AC_ARG_WITH(wrapper-fc-compiler-flags,
AC_HELP_STRING([--with-wrapper-fc-compiler-flags=WRAPPERFCCFLAGS],
[extra compiler flags to add when using vtf90]),
[VT_WRAPPER_FC_EXTRA_COMPILER_FLAGS=$withval])
AC_ARG_WITH(wrapper-ldflags,
AC_HELP_STRING([--with-wrapper-ldflags],
[extra flags to add to LDFLAGS when using wrapper compilers]),
[VT_WRAPPER_EXTRA_LDFLAGS=$withval])
AC_ARG_WITH(wrapper-fc-linker-flags,
AC_HELP_STRING([--with-wrapper-fc-linker-flags=WRAPPERFCLDFLAGS],
[extra linker flags to add when using vtf90]),
[VT_WRAPPER_FC_EXTRA_LINKER_FLAGS=$withval])
AC_ARG_WITH(wrapper-libs,
AC_HELP_STRING([--with-wrapper-libs],
[extra flags to add to LIBS when using wrapper compilers]),
[VT_WRAPPER_EXTRA_LIBS=$withval])
AC_ARG_WITH(wrapper-fc-libs,
AC_HELP_STRING([--with-wrapper-fc-libs=WRAPPERFCLIBS],
[extra libraries to link when using vtf90]),
[VT_WRAPPER_FC_EXTRA_LIBS=$withval])
AC_ARG_WITH(wrapper-fc-default-partype,
AC_HELP_STRING([--with-wrapper-fc-default-partype=TYPE],
[default parallelization type for vtf90 (seq,mt,mpi,hyb), default: $VT_WRAPPER_FC_DEFAULT_PARTYPE]),
[
case $withval in
seq | mt | mpi | hyb)
VT_WRAPPER_FC_DEFAULT_PARTYPE=$withval
;;
*)
AC_MSG_ERROR([value of '--with-wrapper-fc-default-partype' not properly set])
;;
esac
])
AC_ARG_WITH(wrapper-nvcc-compiler,
AC_HELP_STRING([--with-wrapper-nvcc-compiler=WRAPPERNVCC],
[underlying NVIDIA CUDA compiler command for vtnvcc, default: NVCC]),
[VT_WRAPPER_NVCC_COMPILER=$withval])
AC_ARG_WITH(wrapper-nvcc-compiler-flags,
AC_HELP_STRING([--with-wrapper-nvcc-compiler-flags=WRAPPERNVCCCFLAGS],
[extra compiler flags to add when using vtnvcc]),
[VT_WRAPPER_NVCC_EXTRA_COMPILER_FLAGS=$withval])
AC_ARG_WITH(wrapper-nvcc-linker-flags,
AC_HELP_STRING([--with-wrapper-nvcc-linker-flags=WRAPPERNVCCLDFLAGS],
[extra linker flags to add when using vtnvcc]),
[VT_WRAPPER_NVCC_EXTRA_LINKER_FLAGS=$withval])
AC_ARG_WITH(wrapper-nvcc-libs,
AC_HELP_STRING([--with-wrapper-nvcc-libs=WRAPPERNVCCLIBS],
[extra libraries to link when using vtnvcc]),
[VT_WRAPPER_NVCC_EXTRA_LIBS=$withval])
AC_ARG_WITH(wrapper-nvcc-default-partype,
AC_HELP_STRING([--with-wrapper-nvcc-default-partype=TYPE],
[default parallelization type for vtnvcc (seq,mt,mpi,hyb), default: $VT_WRAPPER_NVCC_DEFAULT_PARTYPE]),
[
case $withval in
seq | mt | mpi | hyb)
VT_WRAPPER_NVCC_DEFAULT_PARTYPE=$withval
;;
*)
AC_MSG_ERROR([value of '--with-wrapper-nvcc-default-partype' not properly set])
;;
esac
])
AS_IF([test "$PLATFORM" = "bgp" -a x"$enable_shared" = "xyes"],
[
VT_WRAPPER_EXTRA_LDFLAGS="$VT_WRAPPER_EXTRA_LDFLAGS -Wl,-dy"
VT_WRAPPER_CC_EXTRA_LINKER_FLAGS="$VT_WRAPPER_CC_EXTRA_LINKER_FLAGS -Wl,-dy"
VT_WRAPPER_CXX_EXTRA_LINKER_FLAGS="$VT_WRAPPER_CXX_EXTRA_LINKER_FLAGS -Wl,-dy"
VT_WRAPPER_F77_EXTRA_LINKER_FLAGS="$VT_WRAPPER_F77_EXTRA_LINKER_FLAGS -Wl,-dy"
VT_WRAPPER_FC_EXTRA_LINKER_FLAGS="$VT_WRAPPER_FC_EXTRA_LINKER_FLAGS -Wl,-dy"
VT_WRAPPER_NVCC_EXTRA_LINKER_FLAGS="$VT_WRAPPER_NVCC_EXTRA_LINKER_FLAGS -Wl,-dy"
])
VT_WRAPPER_VTLIB="-lvt"
VT_WRAPPER_VTMPILIB="-lvt-mpi"
VT_WRAPPER_VTMTLIB="-lvt-mt"
VT_WRAPPER_VTHYBLIB="-lvt-hyb"
AS_IF([test x"$compinst_type" = "xpgi9"],
[
VT_WRAPPER_VTLIB="-Wl,--whole-archive $VT_WRAPPER_VTLIB -Wl,--no-whole-archive"
@ -99,47 +261,143 @@ AC_DEFUN([ACVT_COMPWRAP],
AS_IF([test x"$build_opari" = "xyes"],
[
ACVT_CONF_EXPAND_VARS([$bindir/opari], [VT_WRAPPER_OPARI_BIN])
VT_WRAPPER_OPARI_TAB_CC="$CC"
VT_WRAPPER_OPARI_TAB_CFLAGS="$CFLAGS"
VT_WRAPPER_OPARI_BIN="\${bindir}/opari"
for f in -V --version; do
case `$CC $f 2>&1` in
*pgcc\ [[1-8]].* | *PathScale*)
VT_WRAPPER_OPARI_OPTS="-nodecl"
break
;;
esac
done
VT_WRAPPER_OPARI_TAB_COMPILER="$CC"
VT_WRAPPER_OPARI_TAB_COMPILER_FLAGS="$CFLAGS"
])
AS_IF([test x"$compinst_type" != x],
AS_IF([test x"$have_compinst" = "xyes"],
[
VT_WRAPPER_COMPINST_CFLAGS="$compinst_cflags"
VT_WRAPPER_COMPINST_CXXFLAGS="$compinst_cxxflags"
VT_WRAPPER_COMPINST_FFLAGS="$compinst_fflags"
VT_WRAPPER_COMPINST_FCFLAGS="$compinst_fcflags"
VT_WRAPPER_CC_COMPINST_COMPILER_FLAGS="$compinst_cflags"
VT_WRAPPER_CXX_COMPINST_COMPILER_FLAGS="$compinst_cxxflags"
VT_WRAPPER_F77_COMPINST_COMPILER_FLAGS="$compinst_fflags"
VT_WRAPPER_FC_COMPINST_COMPILER_FLAGS="$compinst_fcflags"
VT_WRAPPER_NVCC_COMPINST_COMPILER_FLAGS="-Xcompiler=\"$compinst_cflags\""
VT_WRAPPER_AVAIL_INST="$VT_WRAPPER_AVAIL_INST compinst"
VT_WRAPPER_DEFAULT_INST="compinst"
])
AS_IF([test x"$have_dyninst" = "xyes"],
[
VT_WRAPPER_CC_DYNINST_COMPILER_FLAGS="-g"
VT_WRAPPER_CXX_DYNINST_COMPILER_FLAGS="-g"
VT_WRAPPER_F77_DYNINST_COMPILER_FLAGS="-g"
VT_WRAPPER_FC_DYNINST_COMPILER_FLAGS="-g"
VT_WRAPPER_NVCC_DYNINST_COMPILER_FLAGS="-Xcompiler=\"-g\""
VT_WRAPPER_AVAIL_INST="$VT_WRAPPER_AVAIL_INST dyninst"
])
AC_SUBST(VT_WRAPPER_CC)
AC_SUBST(VT_WRAPPER_CXX)
AC_SUBST(VT_WRAPPER_F77)
AC_SUBST(VT_WRAPPER_FC)
AC_SUBST(VT_WRAPPER_EXTRA_CFLAGS)
AC_SUBST(VT_WRAPPER_EXTRA_CXXFLAGS)
AC_SUBST(VT_WRAPPER_EXTRA_FFLAGS)
AC_SUBST(VT_WRAPPER_EXTRA_FCFLAGS)
AC_SUBST(VT_WRAPPER_EXTRA_LDFLAGS)
AC_SUBST(VT_WRAPPER_EXTRA_LIBS)
AS_IF([test x"$have_tauinst" = "xyes"],
[
pdt_mpiincdir=
pdt_fmpiincdir=
AS_IF([test x"$have_mpi" = "xyes"],
[
AS_IF([test x"$inside_openmpi" = "xyes"],
[pdt_mpiincdir="-I\${includedir}/.."],
[pdt_mpiincdir="$MPIINCDIR"])
AS_IF([test x"$have_fmpi" = "xyes"],
[
AS_IF([test x"$inside_openmpi" = "xyes"],
[pdt_fmpiincdir="$pdt_mpiincdir"],
[pdt_fmpiincdir="$FMPIINCDIR"])
])
])
VT_WRAPPER_TAUINST_BIN="$tauinst_cmd"
VT_WRAPPER_CC_TAUINST_OPTS="-c -spec \${datadir}/TAUINST.SPEC"
VT_WRAPPER_CC_TAUINST_PARSE_BIN="$tauinst_cparse_cmd"
VT_WRAPPER_CC_TAUINST_PARSE_OPTS="$pdt_mpiincdir"
VT_WRAPPER_CXX_TAUINST_OPTS="-c++ -spec \${datadir}/TAUINST.SPEC"
VT_WRAPPER_CXX_TAUINST_PARSE_BIN="$tauinst_cxxparse_cmd"
VT_WRAPPER_CXX_TAUINST_PARSE_OPTS="$VT_WRAPPER_CC_TAUINST_PARSE_OPTS"
VT_WRAPPER_F77_TAUINST_OPTS="-fortran -spec \${datadir}/TAUINST.SPEC"
VT_WRAPPER_F77_TAUINST_PARSE_BIN="$tauinst_fparse_cmd"
VT_WRAPPER_F77_TAUINST_PARSE_OPTS="$pdt_fmpiincdir"
VT_WRAPPER_FC_TAUINST_OPTS="$VT_WRAPPER_F77_TAUINST_OPTS"
VT_WRAPPER_FC_TAUINST_PARSE_BIN="$VT_WRAPPER_F77_TAUINST_PARSE_BIN"
VT_WRAPPER_FC_TAUINST_PARSE_OPTS="$VT_WRAPPER_F77_TAUINST_PARSE_OPTS"
VT_WRAPPER_NVCC_TAUINST_OPTS="$VT_WRAPPER_CC_TAUINST_OPTS"
VT_WRAPPER_NVCC_TAUINST_PARSE_BIN="$VT_WRAPPER_CC_TAUINST_PARSE_BIN"
VT_WRAPPER_NVCC_TAUINST_PARSE_OPTS="$VT_WRAPPER_CC_TAUINST_PARSE_OPTS"
VT_WRAPPER_AVAIL_INST="$VT_WRAPPER_AVAIL_INST tauinst"
])
AC_SUBST(VT_WRAPPER_CC_COMPILER)
AC_SUBST(VT_WRAPPER_CC_EXTRA_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_CC_EXTRA_LINKER_FLAGS)
AC_SUBST(VT_WRAPPER_CC_EXTRA_LIBS)
AC_SUBST(VT_WRAPPER_CC_DYNINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_CC_TAUINST_OPTS)
AC_SUBST(VT_WRAPPER_CC_TAUINST_PARSE_BIN)
AC_SUBST(VT_WRAPPER_CC_TAUINST_PARSE_OPTS)
AC_SUBST(VT_WRAPPER_CC_COMPINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_CC_DEFAULT_PARTYPE)
AC_SUBST(VT_WRAPPER_CXX_COMPILER)
AC_SUBST(VT_WRAPPER_CXX_EXTRA_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_CXX_EXTRA_LINKER_FLAGS)
AC_SUBST(VT_WRAPPER_CXX_EXTRA_LIBS)
AC_SUBST(VT_WRAPPER_CXX_DYNINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_CXX_TAUINST_OPTS)
AC_SUBST(VT_WRAPPER_CXX_TAUINST_PARSE_BIN)
AC_SUBST(VT_WRAPPER_CXX_TAUINST_PARSE_OPTS)
AC_SUBST(VT_WRAPPER_CXX_COMPINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_CXX_DEFAULT_PARTYPE)
AC_SUBST(VT_WRAPPER_F77_COMPILER)
AC_SUBST(VT_WRAPPER_F77_EXTRA_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_F77_EXTRA_LINKER_FLAGS)
AC_SUBST(VT_WRAPPER_F77_EXTRA_LIBS)
AC_SUBST(VT_WRAPPER_F77_DYNINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_F77_TAUINST_OPTS)
AC_SUBST(VT_WRAPPER_F77_TAUINST_PARSE_BIN)
AC_SUBST(VT_WRAPPER_F77_TAUINST_PARSE_OPTS)
AC_SUBST(VT_WRAPPER_F77_COMPINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_F77_DEFAULT_PARTYPE)
AC_SUBST(VT_WRAPPER_FC_COMPILER)
AC_SUBST(VT_WRAPPER_FC_EXTRA_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_FC_EXTRA_LINKER_FLAGS)
AC_SUBST(VT_WRAPPER_FC_EXTRA_LIBS)
AC_SUBST(VT_WRAPPER_FC_DYNINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_FC_TAUINST_OPTS)
AC_SUBST(VT_WRAPPER_FC_TAUINST_PARSE_BIN)
AC_SUBST(VT_WRAPPER_FC_TAUINST_PARSE_OPTS)
AC_SUBST(VT_WRAPPER_FC_COMPINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_FC_DEFAULT_PARTYPE)
AC_SUBST(VT_WRAPPER_NVCC_COMPILER)
AC_SUBST(VT_WRAPPER_NVCC_EXTRA_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_NVCC_EXTRA_LINKER_FLAGS)
AC_SUBST(VT_WRAPPER_NVCC_EXTRA_LIBS)
AC_SUBST(VT_WRAPPER_NVCC_DYNINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_NVCC_TAUINST_OPTS)
AC_SUBST(VT_WRAPPER_NVCC_TAUINST_PARSE_BIN)
AC_SUBST(VT_WRAPPER_NVCC_TAUINST_PARSE_OPTS)
AC_SUBST(VT_WRAPPER_NVCC_COMPINST_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_NVCC_DEFAULT_PARTYPE)
AC_SUBST(VT_WRAPPER_VTLIB)
AC_SUBST(VT_WRAPPER_VTMPILIB)
AC_SUBST(VT_WRAPPER_VTMTLIB)
AC_SUBST(VT_WRAPPER_VTHYBLIB)
AC_SUBST(VT_WRAPPER_OPARI_BIN)
AC_SUBST(VT_WRAPPER_OPARI_TAB_CC)
AC_SUBST(VT_WRAPPER_OPARI_TAB_CFLAGS)
AC_SUBST(VT_WRAPPER_COMPINST_CFLAGS)
AC_SUBST(VT_WRAPPER_COMPINST_CXXFLAGS)
AC_SUBST(VT_WRAPPER_COMPINST_FFLAGS)
AC_SUBST(VT_WRAPPER_COMPINST_FCFLAGS)
AC_SUBST(VT_WRAPPER_OPARI_OPTS)
AC_SUBST(VT_WRAPPER_OPARI_TAB_COMPILER)
AC_SUBST(VT_WRAPPER_OPARI_TAB_COMPILER_FLAGS)
AC_SUBST(VT_WRAPPER_TAUINST_BIN)
AC_SUBST(VT_WRAPPER_AVAIL_INST)
AC_SUBST(VT_WRAPPER_DEFAULT_INST)
])

50
ompi/contrib/vt/vt/config/m4/acinclude.conf.m4
Просмотреть файл

@ -230,7 +230,7 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
[answer="yes"], [answer="no"])
echo " I/O: $answer"
AS_IF([test x"$have_etimesync" = "xyes"],
AS_IF([test x"$build_etimesync" = "xyes"],
[answer="yes"], [answer="no"])
echo " Build enhanced time sync. support: $answer"
@ -238,6 +238,10 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
[answer="yes ($unimci_checker_name $unimci_checker_version)"],
[answer="no"])
echo " Build MPI correctness checking support: $answer"
AS_IF([test x"$build_mpiunifylib" = "xyes"],
[answer="yes"], [answer="no"])
echo " Build MPI trace unification library: $answer"
])
AS_IF([test x"$have_threads" = "xyes"],
@ -267,6 +271,10 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
[answer="yes (NEC SX)"], [answer="no"])])])
echo " Build Hardware Perf. Counter support: $answer"
AS_IF([test x"$have_plugin_cntr" = "xyes"],
[answer="yes"], [answer="no"])
echo " Build Plugin Counter support: $answer"
AS_IF([test x"$have_rusage" = "xyes"],
[answer="yes"], [answer="no"])
echo " Build Resource usage trace support: $answer"
@ -281,18 +289,20 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
AS_IF([test x"$have_libwrap" = "xyes"],
[
answer="yes"
AS_IF([test x"$have_libcwrap" = "xyes" -o x"$have_iowrap" = "xyes"],
[
answer=
answer=
AS_IF([test x"$have_libcwrap" = "xyes"],
[answer="LIBC"])
[AS_IF([test x"$answer" != x],
[answer="$answer, LIBC"],
[answer="LIBC"])])
AS_IF([test x"$have_iowrap" = "xyes"],
[AS_IF([test x"$answer" != x],
[answer="$answer, LIBC-I/O"],
[answer="LIBC-I/O"])])
answer="yes ($answer)"
])
AS_IF([test x"$have_cudawrap" = "xyes"],
[AS_IF([test x"$answer" != x],
[answer="$answer, CUDA"],
[answer="CUDA"])])
answer="yes ($answer)"
], [answer="no"])
echo " Build Library trace support: $answer"
@ -303,7 +313,7 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
echo " Build Library wrapper generator: $answer"
])
AS_IF([test x"$compinst_type" != x],
AS_IF([test x"$have_compinst" != x],
[answer=`echo $compinst_type | sed s/gnu/gnu*/g`],
[answer="no"])
echo ""
@ -311,9 +321,7 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
AS_IF([test x"$compinst_type" = "xgnu"],
[
echo ""
echo " * The instrumentation type 'gnu' also"
echo " works for Intel and Pathscale compilers."
echo " *The instrumentation type 'gnu' also works for Intel and PathScale compilers."
])
AS_IF([test x"$have_dyninst" = "xyes"],
@ -326,6 +334,24 @@ AC_DEFUN([ACVT_CONF_SUMMARY],
[answer="yes"], [answer="no"])
echo " Build Dyninst attach library: $answer"
AS_IF([test x"$have_tauinst" = "xyes"],
[answer="yes"], [answer="no"])
echo ""
echo " Build automatic source code"
echo " instrumentation support by using TAU: $answer"
AS_IF([test x"$build_vtsetup" = "xyes"],
[answer="yes"], [answer="no"])
echo ""
echo " Build vtsetup - a GUI to prepare"
echo " measurement runs with VampirTrace $answer"
AS_IF([test x"$build_vtrun" = "xyes"],
[answer="yes"], [answer="no"])
echo ""
echo " Build vtrun - an application execution"
echo " wrapper script $answer"
echo ""
echo " See config.h for further configuration information."
echo "-----------------------------------------------------------------------------"

258
ompi/contrib/vt/vt/config/m4/acinclude.cudawrap.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,258 @@
AC_DEFUN([ACVT_CUDAWRAP],
[
cudawrap_error="no"
cudartwrap_error="no"
have_cudawrap="no"
have_cudartwrap="no"
CUDATKDIR=
CUDATKINCDIR=
CUDATKLIBDIR=
CUDALIB=
CUDARTLIB=
cudalib_pathname=
cudartlib_pathname=
AC_ARG_VAR(NVCC, [NVIDIA CUDA compiler command])
AC_ARG_WITH(cuda-dir,
AC_HELP_STRING([--with-cuda-dir=CUDATKDIR],
[give the path for CUDA Toolkit, default: /usr/local/cuda]),
[CUDATKDIR="$withval/"], [CUDATKDIR="/usr/local/cuda/"])
AC_ARG_WITH(cuda-inc-dir,
AC_HELP_STRING([--with-cuda-inc-dir=CUDATKINCDIR],
[give the path for CUDA-Toolkit-include files, default: CUDATKDIR/include]),
[CUDATKINCDIR="-I$withval/"],
[AS_IF([test x"$CUDATKDIR" != x], [CUDATKINCDIR="-I$CUDATKDIR"include/])])
AC_ARG_WITH(cuda-lib-dir,
AC_HELP_STRING([--with-cuda-lib-dir=CUDATKLIBDIR],
[give the path for CUDA-Toolkit-libraries, default: CUDATKDIR/lib64]),
[CUDATKLIBDIR="-L$withval/"],
[AS_IF([test x"$CUDATKDIR" != x], [CUDATKLIBDIR="-L$CUDATKDIR"lib64/])])
AC_ARG_WITH(cuda-lib,
AC_HELP_STRING([--with-cuda-lib=CUDALIB], [use given CUDA driver library, default: -lcuda]),
[CUDALIB="$withval"])
AC_ARG_WITH(cudart-lib,
AC_HELP_STRING([--with-cudart-lib=CUDARTLIB], [use given CUDA runtime library, default: -lcudart]),
[CUDARTLIB="$withval"])
AC_ARG_WITH(cuda-shlib,
AC_HELP_STRING([--with-cuda-shlib=CUDASHLIB], [give the pathname for the shared CUDA driver library, default: automatically by configure]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-cuda-shlib' not properly set])])
cudalib_pathname=$withval
])
AC_ARG_WITH(cudart-shlib,
AC_HELP_STRING([--with-cudart-shlib=CUDARTSHLIB], [give the pathname for the shared CUDA runtime library, default: automatically by configure]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-cudart-shlib' not properly set])])
cudartlib_pathname=$withval
])
AS_IF([test x"$cudawrap_error" = "xno"],
[
sav_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $CUDATKINCDIR"
AC_CHECK_HEADER([cuda.h], [],
[
AC_MSG_NOTICE([error: no cuda.h found; check path for CUDA Toolkit first...])
cudawrap_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
])
AS_IF([test x"$CUDALIB" = x -a x"$cudawrap_error" = "xno"],
[
sav_LIBS=$LIBS
LIBS="$LIBS $CUDATKLIBDIR -lcuda"
AC_MSG_CHECKING([whether linking with -lcuda works])
AC_TRY_LINK([],[],
[AC_MSG_RESULT([yes]); CUDALIB=-lcuda],[AC_MSG_RESULT([no])])
LIBS=$sav_LIBS
])
AS_IF([test x"$CUDALIB" = x -a x"$cudawrap_error" = "xno"],
[
AC_MSG_NOTICE([error: no libcuda found; check path for CUDA Toolkit first...])
cudawrap_error="yes"
])
AS_IF([test x"$cudawrap_error" = "xno"],
[
AC_MSG_CHECKING([whether CUDA driver version >= 3.0])
sav_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $CUDATKINCDIR"
AC_TRY_COMPILE([#include "cuda.h"],
[
#ifndef CUDA_VERSION
# error "CUDA_VERSION not defined"
#elif CUDA_VERSION < 3000
# error "CUDA_VERSION < 3000"
#endif
],
[AC_MSG_RESULT([yes])],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: CUDA driver version could not be determined and/or is incompatible (< 3.0)
See \`config.log' for more details.])
cudawrap_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
])
AS_IF([test x"$cudawrap_error" = "xno"],
[
AC_MSG_CHECKING([for pathname of CUDA driver library])
AS_IF([test x"$cudalib_pathname" != x],
[
AC_MSG_RESULT([skipped (--with-cuda-shlib=$cudalib_pathname)])
],
[
AS_IF([test x"$have_rtld_next" = "xyes"],
[
AC_MSG_RESULT([not needed])
],
[
AS_IF([test x"$CUDATKLIBDIR" != x],
[cudalib_dir=`echo $CUDATKLIBDIR | sed s/\-L//`])
cudalib_pathname=$cudalib_dir`echo $CUDALIB | sed s/\-l/lib/`".so"
AS_IF([! test -f $cudalib_pathname],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: could not determine pathname of CUDA driver library])
cudawrap_error="yes"
],
[
AC_MSG_RESULT([$cudalib_pathname])
])
])
])
])
AS_IF([test x"$cudawrap_error" = "xno"],
[
AS_IF([test x"$cudalib_pathname" != x],
[
AC_DEFINE_UNQUOTED([DEFAULT_CUDALIB_PATHNAME],
["$cudalib_pathname"], [pathname of CUDA driver library])
])
have_cudawrap="yes"
])
AS_IF([test x"$cudartwrap_error" = "xno"],
[
sav_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $CUDATKINCDIR"
AC_CHECK_HEADER([cuda_runtime_api.h], [],
[
AC_MSG_NOTICE([error: no cuda_runtime_api.h found; check path for CUDA Toolkit first...])
cudartwrap_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
])
AS_IF([test x"$CUDARTLIB" = x -a x"$cudartwrap_error" = "xno"],
[
sav_LIBS=$LIBS
LIBS="$LIBS $CUDATKLIBDIR -lcudart"
AC_MSG_CHECKING([whether linking with -lcudart works])
AC_TRY_LINK([],[],
[AC_MSG_RESULT([yes]); CUDARTLIB=-lcudart],[AC_MSG_RESULT([no])])
LIBS=$sav_LIBS
])
AS_IF([test x"$CUDARTLIB" = x -a x"$cudartwrap_error" = "xno"],
[
AC_MSG_NOTICE([error: no libcudart found; check path for CUDA Toolkit first...])
cudartwrap_error="yes"
])
AS_IF([test x"$cudartwrap_error" = "xno"],
[
AC_MSG_CHECKING([whether CUDA runtime version >= 3.0])
sav_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $CUDATKINCDIR"
AC_TRY_COMPILE([#include "cuda_runtime_api.h"],
[
#ifndef CUDART_VERSION
# error "CUDART_VERSION not defined"
#elif CUDART_VERSION < 3000
# error "CUDART_VERSION < 3000"
#endif
],
[AC_MSG_RESULT([yes])],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: CUDA runtime version could not be determined and/or is incompatible (< 3.0)
See \`config.log' for more details.])
cudartwrap_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
])
AS_IF([test x"$cudartwrap_error" = "xno"],
[
AC_MSG_CHECKING([for pathname of CUDA runtime library])
AS_IF([test x"$cudartlib_pathname" != x],
[
AC_MSG_RESULT([skipped (--with-cudart-shlib=$cudartlib_pathname)])
],
[
AS_IF([test x"$have_rtld_next" = "xyes"],
[
AC_MSG_RESULT([not needed])
],
[
AS_IF([test x"$CUDATKLIBDIR" != x],
[cudartlib_dir=`echo $CUDATKLIBDIR | sed s/\-L//`])
cudartlib_pathname=$cudartlib_dir`echo $CUDARTLIB | sed s/\-l/lib/`".so"
AS_IF([! test -f $cudartlib_pathname],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: could not determine pathname of CUDA runtime library])
cudartwrap_error="yes"
],
[
AC_MSG_RESULT([$cudartlib_pathname])
])
])
])
])
AS_IF([test x"$cudartwrap_error" = "xno"],
[
AC_CHECK_PROG(NVCC, nvcc, nvcc, , [$PATH$PATH_SEPARATOR$CUDATKDIR"bin/"])
AS_IF([test x"$cudartlib_pathname" != x],
[
AC_DEFINE_UNQUOTED([DEFAULT_CUDARTLIB_PATHNAME],
["$cudartlib_pathname"], [pathname of CUDA runtime library])
])
have_cudartwrap="yes"
])
AS_IF([test x"$cudawrap_error" = "xno" -a x"$cudartwrap_error" = "xno"],
[
ACVT_CUPTI
])
AC_SUBST(CUDATKINCDIR)
AC_SUBST(CUDATKLIBDIR)
AC_SUBST(CUDATKLIB)
])

84
ompi/contrib/vt/vt/config/m4/acinclude.cupti.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,84 @@
AC_DEFUN([ACVT_CUPTI],
[
cupti_error="no"
have_cupti="no"
CUPTIDIR=
CUPTIINCDIR=
CUPTILIBDIR=
CUPTILIB=
AC_ARG_WITH(cupti-dir,
AC_HELP_STRING([--with-cupti-dir=CUPTIDIR],
[give the path for CUPTI, default: /usr]),
[CUPTIDIR="$withval/"])
AC_ARG_WITH(cupti-inc-dir,
AC_HELP_STRING([--with-cupti-inc-dir=CUPTIINCDIR],
[give the path for CUPTI-include files, default: CUPTIDIR/include]),
[CUPTIINCDIR="-I$withval/"],
[AS_IF([test x"$CUPTIDIR" != x], [CUPTIINCDIR="-I$CUPTIDIR"include/])])
AC_ARG_WITH(cupti-lib-dir,
AC_HELP_STRING([--with-cupti-lib-dir=CUPTILIBDIR],
[give the path for CUPTI-libraries, default: CUPTIDIR/lib]),
[CUPTILIBDIR="-L$withval/"],
[AS_IF([test x"$CUPTIDIR" != x], [CUPTILIBDIR="-L$CUPTIDIR"lib/])])
AC_ARG_WITH(cupti-lib,
AC_HELP_STRING([--with-cupti-lib=CUPTILIB], [use given cupti lib, default: -lcupti CUDALIB]),
[CUPTILIB="$withval"])
sav_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $CUPTIINCDIR $CUDATKINCDIR"
AC_CHECK_HEADER([cupti_events.h], [],
[
AC_MSG_NOTICE([error: no cupti_events.h found; check path for CUPTI package first...])
cupti_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
AS_IF([test x"$CUPTILIB" = x -a x"$cupti_error" = "xno"],
[
sav_LIBS=$LIBS
LIBS="$LIBS $CUPTILIBDIR -lcupti $CUDATKLIBDIR $CUDALIB"
AC_MSG_CHECKING([whether linking with -lcupti works])
AC_TRY_LINK([],[],
[AC_MSG_RESULT([yes]); CUPTILIB="-lcupti $CUDATKLIBDIR $CUDALIB"],[AC_MSG_RESULT([no])])
LIBS=$sav_LIBS
])
AS_IF([test x"$CUPTILIB" = x -a x"$cupti_error" = "xno"],
[
AC_MSG_NOTICE([error: no libcupti found; check path for CUPTI package first...])
cupti_error="yes"
])
AC_MSG_CHECKING([whether CUDA runtime version >= 4.0])
sav_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $CUDATKINCDIR"
AC_TRY_COMPILE([#include "cuda_runtime_api.h"],
[
#ifndef CUDART_VERSION
# error "CUDART_VERSION not defined"
#elif CUDART_VERSION < 4000
# error "CUDART_VERSION < 4000"
#endif
],
[AC_MSG_RESULT([yes])],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: CUDA runtime version could not be determined and/or is incompatible (< 4.0)
See \`config.log' for more details.])
cupti_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
AS_IF([test x"$cupti_error" = "xno"], [have_cupti="yes"])
AC_SUBST(CUPTIINCDIR)
AC_SUBST(CUPTILIBDIR)
AC_SUBST(CUPTILIB)
])

64
ompi/contrib/vt/vt/config/m4/acinclude.cxxrtlib.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,64 @@
AC_DEFUN([ACVT_CXXRTLIB],
[
cxxrtlib_error="no"
cxxrtlib=
AC_ARG_WITH(cxxrtlib,
AC_HELP_STRING([--with-cxxrtlib=CXXRTLIB],
[use given C++ runtime library, default: automatically by configure]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-cxxrtlib' not properly set])])
cxxrtlib=$withval
])
AC_MSG_CHECKING([for C++ runtime library])
AS_IF([test x"$cxxrtlib" = x],
[
AC_LANG([C++])
AC_TRY_COMPILE([#include <list>],
[
std::list<int> l;
l.push_back(100);
],
[cp -f conftest.$ac_objext conftest_cxxrtlib.$ac_objext],
[cxxrtlib_error="yes"])
AC_LANG([C])
libs_to_check="-lstdc++ \
-lCrun -lCstd \
-lstlport \
-libmc++;-lstdc++;-lm;-lc \
-lxlopt;-lxl;-libmc++;-lstdc++;-lm;-lc \
-lC \
-lstd;-lC \
-lstd;-lC;-lzceh \
-lstdc++;-lm;-lc \
-limf;-lm;-lipgo;-lstdc++;-lirc;-lipr;-lirc;-lc;-lirc_s;-ldl;-lc \
-lC++"
AS_IF([test x"$cxxrtlib_error" = "xno"],
[
for lib in $libs_to_check
do
lib=`echo $lib | sed s/\;/\ /g`
eval "$CC -o conftest_cxxrtlib$ac_exeext $CFLAGS $LDFLAGS conftest_cxxrtlib.$ac_objext $LIBS $lib >/dev/null 2>&1"
AS_IF([test x"$?" = "x0"],
[
cxxrtlib="$lib"
break
])
done
rm -f conftest_cxxrtlib*
AS_IF([test x"$cxxrtlib" = x], [cxxrtlib_error="yes"])
])
])
AS_IF([test x"$cxxrtlib_error" = "xno"],
[AC_MSG_RESULT([$cxxrtlib])], [AC_MSG_RESULT([failed])])
])

8
ompi/contrib/vt/vt/config/m4/acinclude.dyninst.m4
Просмотреть файл

@ -80,20 +80,20 @@ AC_DEFUN([ACVT_DYNINST],
AS_IF([test x"$dyninst_error" = "xno"],
[
AC_MSG_CHECKING([whether Dyninst version >= 5.1])
AC_MSG_CHECKING([whether Dyninst version >= 6.1])
sav_CXXFLAGS=$CXXFLAGS
CXXFLAGS="$CXXFLAGS $DYNIINCDIR"
AC_TRY_COMPILE([#include <BPatch.h>],
[
#ifndef DYNINST_5_1
# error "DYNINST_5_1 not defined"
#ifndef DYNINST_6_1
# error "DYNINST_6_1 not defined"
#endif
],
[AC_MSG_RESULT([yes])],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: Dyninst version could not be determined and/or is incompatible (< 5.1)
AC_MSG_NOTICE([error: Dyninst version could not be determined and/or is incompatible (< 6.1)
See \`config.log' for more details.])
dyninst_error="yes"
])

4
ompi/contrib/vt/vt/config/m4/acinclude.etimesync.m4
Просмотреть файл

@ -3,7 +3,7 @@ AC_DEFUN([ACVT_ETIMESYNC],
etimesync_error="no"
check_etimesync="yes"
force_etimesync="no"
have_etimesync="no"
build_etimesync="no"
AC_ARG_ENABLE(etimesync,
AC_HELP_STRING([--enable-etimesync],
@ -19,7 +19,7 @@ AC_DEFUN([ACVT_ETIMESYNC],
[
ACVT_CLAPACK
AS_IF([test x"$have_clapack" = "xyes"],
[have_etimesync="yes"], [etimesync_error="yes"])
[build_etimesync="yes"], [etimesync_error="yes"])
])
])
])

12
ompi/contrib/vt/vt/config/m4/acinclude.iowrap.m4
Просмотреть файл

@ -21,10 +21,14 @@ AC_DEFUN([ACVT_IOWRAP],
open64 \
pread64 \
pwrite64 \
flockfile \
ftrylockfile \
funlockfile \
lockf])
flockfile \
ftrylockfile \
funlockfile \
sync \
fflush \
fsync \
fdatasync \
lockf])
CPPFLAGS=$sav_CPPFLAGS
have_iowrap="yes"

21
ompi/contrib/vt/vt/config/m4/acinclude.java.m4
Просмотреть файл

@ -5,6 +5,8 @@ AC_DEFUN([ACVT_JAVA],
force_java="no"
have_java="no"
VTJAVALIB=
AC_REQUIRE([ACVT_PLATFORM])
AC_ARG_ENABLE(java,
@ -30,9 +32,24 @@ AC_DEFUN([ACVT_JAVA],
AS_IF([test x"$java_error" = "xno"],
[
ACVT_JVMTI
AS_IF([test x"$have_jvmti" = "xyes"],
[have_java="yes"], [java_error="yes"])
AS_IF([test x"$jvmti_error" = "xyes"],
[java_error="yes"])
])
AS_IF([test x"$java_error" = "xno"],
[
AS_IF([test "$PLATFORM" = "macos"],
[
VTJAVALIB="libvt-java.jnilib"
],
[
VTJAVALIB="libvt-java$SHREXT"
])
have_java="yes"
])
])
AC_SUBST(VTJAVALIB)
])

2
ompi/contrib/vt/vt/config/m4/acinclude.jvmti.m4
Просмотреть файл

@ -22,7 +22,7 @@ AC_DEFUN([ACVT_JVMTI],
extra_inc_dir=
case $PLATFORM in
linux)
altix | linux)
extra_inc_dir=linux
;;
sun)

7
ompi/contrib/vt/vt/config/m4/acinclude.libc.m4
Просмотреть файл

@ -31,9 +31,8 @@ AC_DEFUN([ACVT_LIBC],
[
libc_pathname=`ldd conftest 2>/dev/null | grep "libc\." | \
sed -e "s/.*=>//" \
-e "s/[[\(].*[\)]]//" \
-e "s/[[ ]]//g" \
-e "s%^[[^/]].*%%" | \
-e "s/[ [\(].*[\)]]//" \
-e "s/[[[:space:]]]//g" | \
head -n1`
],
[
@ -54,7 +53,7 @@ AC_DEFUN([ACVT_LIBC],
],
[
AC_MSG_RESULT([unknown])
AC_MSG_NOTICE([error: could not determine pathname of LIBC!])
AC_MSG_NOTICE([error: could not determine pathname of LIBC])
libc_error="yes"
])
])

17
ompi/contrib/vt/vt/config/m4/acinclude.libwrap.m4
Просмотреть файл

@ -1,7 +1,7 @@
AC_DEFUN([ACVT_LIBWRAP],
[
libwrap_error="no"
check_libwrap="gen libc io"
check_libwrap="gen libc io cuda"
force_libwrap="no"
have_libwrap="no"
@ -9,12 +9,13 @@ AC_DEFUN([ACVT_LIBWRAP],
build_libwrapgen="no"
force_libcwrap="no"
force_iowrap="no"
force_cudawrap="no"
AC_REQUIRE([ACVT_PLATFORM])
AC_ARG_ENABLE(libtrace,
AC_HELP_STRING([--enable-libtrace=LIST],
[enable library tracing support (gen,libc,io), default: automatically by configure]),
[enable library tracing support (gen,libc,io,cuda), default: automatically by configure]),
[
AS_IF([test x"$enableval" = "xno"], [check_libwrap="no"])
AS_IF([test x"$enableval" = "xyes"], [force_libwrap="yes"])
@ -33,6 +34,9 @@ AC_DEFUN([ACVT_LIBWRAP],
io)
force_iowrap="yes"
;;
cuda)
force_cudawrap="yes"
;;
*)
AC_MSG_ERROR([value of '--enable-libtrace' not properly set])
;;
@ -89,6 +93,15 @@ AC_DEFUN([ACVT_LIBWRAP],
[libwrap_error="yes"; break])
])
;;
cuda)
ACVT_CONF_SUBTITLE([CUDA])
ACVT_CUDAWRAP
AS_IF([test x"$have_cudawrap" = "xyes"], [have_libwrap="yes"],
[
AS_IF([test x"$force_cudawrap" = "xyes"],
[libwrap_error="yes"; break])
])
;;
esac
done
])

345
ompi/contrib/vt/vt/config/m4/acinclude.mpi.m4
Просмотреть файл

@ -11,7 +11,6 @@ AC_DEFUN([ACVT_MPI],
check_mpi2_extcoll="yes"; force_mpi2_extcoll="no"; have_mpi2_extcoll="no"
check_mpi2_io="yes"; force_mpi2_io="no"; have_mpi2_io="no"
fmpiwraplib_error="no"
check_fmpiwraplib="yes"
force_fmpiwraplib="no"
build_fmpiwraplib="no"
@ -32,18 +31,6 @@ AC_DEFUN([ACVT_MPI],
VT_MPIGEN_HAVE_MPI2_EXTCOLL=0
VT_MPIGEN_HAVE_MPI2_IO=0
VT_MPIGEN_HAVE_FC_CONV_COMM=0
VT_MPIGEN_HAVE_FC_CONV_ERRH=0
VT_MPIGEN_HAVE_FC_CONV_FILE=0
VT_MPIGEN_HAVE_FC_CONV_GROUP=0
VT_MPIGEN_HAVE_FC_CONV_INFO=0
VT_MPIGEN_HAVE_FC_CONV_OP=0
VT_MPIGEN_HAVE_FC_CONV_REQUEST=0
VT_MPIGEN_HAVE_FC_CONV_STATUS=0
VT_MPIGEN_HAVE_FC_CONV_TYPE=0
VT_MPIGEN_HAVE_FC_CONV_WIN=0
VT_MPIGEN_HAVE_FC_CONV_MPI2CONST=0
AC_ARG_VAR(MPICC, [MPI C compiler command])
AC_ARG_VAR(MPICXX, [MPI C++ compiler command])
AC_ARG_VAR(MPIF77, [MPI Fortran 77 compiler command])
@ -90,7 +77,11 @@ AC_DEFUN([ACVT_MPI],
AC_ARG_WITH(fmpi-inc-dir,
AC_HELP_STRING([--with-fmpi-inc-dir=FMPIINCDIR],
[give the path for Fortran MPI-include files, default: MPIINCDIR]),
[FMPIINCDIR="-I$withval/"], [FMPIINCDIR=$MPIINCDIR])
[FMPIINCDIR="-I$withval/"],
[
FMPIINCDIR=$MPIINCDIR
AS_IF([test x"$FMPIINCDIR" = x], [FMPIINCDIR="-I/usr/include"])
])
AC_ARG_WITH(mpi-lib-dir,
AC_HELP_STRING([--with-mpi-lib-dir=MPILIBDIR],
@ -257,11 +248,11 @@ AC_DEFUN([ACVT_MPI],
[
MPILIB="-lmpi"
PMPILIB="-lpmpi"
FMPILIB="-lvt-fmpi"
FMPILIB="-lfmpi"
check_mpi2_thread="no"; have_mpi2_thread="yes"
check_mpi2_1sided="no"; have_mpi2_1sided="yes"
check_mpi2_extcoll="no"; have_mpi2_extcoll="yes"
check_mpi2_io="no"; have_mpi2_io="no"
check_mpi2_io="no"; have_mpi2_io="yes"
ac_cv_have_decl_MPI_IN_PLACE="yes"
])
])
@ -273,12 +264,13 @@ AC_DEFUN([ACVT_MPI],
[
MPILIB="-lmpiw"
PMPILIB="-lpmpiw"
FMPILIB="-lvt-fmpi"
FMPILIB="-lfmpiw"
MPICFLAGS="$MPICFLAGS -D_W8"
MPICXXFLAGS="$MPICXXFLAGS -D_W8"
check_mpi2_thread="no"; have_mpi2_thread="yes"
check_mpi2_1sided="no"; have_mpi2_1sided="yes"
check_mpi2_extcoll="no"; have_mpi2_extcoll="yes"
check_mpi2_io="no"; have_mpi2_io="no"
check_mpi2_io="no"; have_mpi2_io="yes"
ac_cv_have_decl_MPI_IN_PLACE="yes"
])
])
@ -294,11 +286,25 @@ AC_DEFUN([ACVT_MPI],
check_mpi2_thread="no"; have_mpi2_thread="yes"
check_mpi2_1sided="no"; have_mpi2_1sided="yes"
check_mpi2_extcoll="no"; have_mpi2_extcoll="yes"
ac_cv_func_MPI_Add_error_class="yes"
ac_cv_func_MPI_Add_error_code="yes"
ac_cv_func_MPI_Add_error_string="yes"
ac_cv_func_MPI_Finalized="yes"
ac_cv_func_MPI_Type_create_f90_complex="yes"
ac_cv_func_MPI_Type_create_f90_integer="yes"
ac_cv_func_MPI_Type_create_f90_real="yes"
ac_cv_func_MPI_Type_match_size="yes"
ac_cv_func_PMPI_Win_test="yes"
ac_cv_func_PMPI_Win_lock="yes"
ac_cv_func_PMPI_Win_unlock="yes"
AS_IF([test x"$inside_openmpi" = "xyes" -a x"$have_mpi2_io" = "xyes"],
[ac_cv_func_MPI_Register_datarep="yes"])
[
ac_cv_func_PMPI_File_read_ordered="yes"
ac_cv_func_PMPI_File_read_ordered_begin="yes"
ac_cv_func_PMPI_File_write_ordered="yes"
ac_cv_func_PMPI_File_write_ordered_begin="yes"
ac_cv_func_MPI_Register_datarep="yes"
])
ac_cv_have_decl_MPI_IN_PLACE="yes"
])
])
@ -422,7 +428,7 @@ AC_DEFUN([ACVT_MPI],
AS_IF([test x"$check_mpi" = "xyes"],
[
AC_CHECK_PROGS(MPICC, mpicc hcc mpcc mpcc_r mpxlc mpixlc cmpicc mpiicc)
AC_CHECK_PROGS(MPICC, mpicc hcc mpcc_r mpcc mpxlc_r mpxlc mpixlc_r mpixlc cmpicc mpiicc)
AS_IF([test x"$MPICC" != x],
[
mpicc=`echo $MPICC | cut -d ' ' -f 1`
@ -430,12 +436,14 @@ AC_DEFUN([ACVT_MPI],
AS_IF([test x"$which_mpicc" = x], [AC_MSG_ERROR([$mpicc not found])])
mpi_bin_dir=`dirname $which_mpicc`
AS_IF([test "$mpi_bin_dir" != "/usr/bin"],
AS_IF([test "$mpi_bin_dir" != "/usr/bin" -a "$mpi_bin_dir" != "/SX/usr/bin"],
[
AS_IF([test x"$MPIDIR" = x],
[MPIDIR=`echo $mpi_bin_dir | sed -e 's/bin//'`])
AS_IF([test x"$MPIINCDIR" = x],
[MPIINCDIR=-I`echo $mpi_bin_dir | sed -e 's/bin/include/'`])
AS_IF([test x"$FMPIINCDIR" = x],
[FMPIINCDIR=$MPIINCDIR])
AS_IF([test x"$MPILIBDIR" = x],
[MPILIBDIR=-L`echo $mpi_bin_dir | sed -e 's/bin/lib/'`])
])
@ -454,12 +462,24 @@ AC_DEFUN([ACVT_MPI],
AS_IF([test x"$mpi_error" = "xno"],
[
AC_CHECK_PROGS(MPICXX, mpicxx mpic++ mpiCC hcp mpxlC_r mpxlC mpCC cmpic++)
AC_CHECK_PROGS(MPICXX, mpicxx mpic++ mpiCC hcp mpxlC_r mpxlC mpCC_r mpCC cmpic++)
AS_IF([test x"$MPICXX" = x], [MPICXX="$CXX"])
MPICXXFLAGS="$MPICXXFLAGS -DMPICH_SKIP_MPICXX -DOMPI_SKIP_MPICXX -DMPI_NO_CPPBIND"
])
dnl check for MPILIB
AS_IF([test x"$MPILIB" = x -a x"$mpi_error" = "xno"],
[
sav_LIBS=$LIBS
LIBS="$LIBS $MPILIBDIR -lmpi_r"
AC_MSG_CHECKING([whether linking with -lmpi_r works])
AC_TRY_LINK([],[],
[AC_MSG_RESULT([yes]); MPILIB=-lmpi_r],[AC_MSG_RESULT([no])])
LIBS=$sav_LIBS
])
AS_IF([test x"$MPILIB" = x -a x"$mpi_error" = "xno"],
[
sav_LIBS=$LIBS
@ -539,7 +559,7 @@ dnl check for MPILIB
AS_IF([test x"$MPILIB" = x -a x"$mpi_error" = "xno"],
[
AC_MSG_NOTICE([error: no libmpi, liblam, libmpich, or libhpmpi found; check path for MPI package first...])
AC_MSG_NOTICE([error: no libmpi_r, libmpi, liblam, libmpich, or libhpmpi found; check path for MPI package first...])
mpi_error="yes"
])
@ -674,11 +694,24 @@ dnl check for MPI-2
sav_LIBS=$LIBS
CC=$MPICC
CPPFLAGS="$CPPFLAGS $MPICFLAGS $MPIINCDIR"
LIBS="$LIBS $MPILIBDIR $MPILIB"
LIBS="$LIBS $MPILIBDIR $MPILIB $PMPILIB"
dnl check for MPI-2 functions
ACVT_CONF_SUBTITLE([MPI-2 functions])
AC_CHECK_FUNCS([MPI_Add_error_class \
MPI_Add_error_code \
MPI_Add_error_string \
MPI_Finalized \
MPI_Type_create_f90_complex \
MPI_Type_create_f90_integer \
MPI_Type_create_f90_real \
MPI_Type_match_size])
dnl check for MPI-2 Thread support
ACVT_CONF_SUBTITLE([MPI-2 Thread support])
ACVT_CONF_SUBSUBTITLE([MPI-2 Thread support])
AS_IF([test x"$check_mpi2_thread" = "xyes"],
[
AC_CHECK_FUNC([MPI_Init_thread], [have_mpi2_thread="yes"])
@ -695,7 +728,7 @@ dnl check for MPI-2 Thread support
dnl check for MPI-2 One-Sided Communications
ACVT_CONF_SUBTITLE([MPI-2 One-Sided Communications])
ACVT_CONF_SUBSUBTITLE([MPI-2 One-Sided Communications])
AS_IF([test x"$check_mpi2_1sided" = "xyes"],
[
AC_CHECK_FUNC([MPI_Get],
@ -712,12 +745,14 @@ dnl check for MPI-2 One-Sided Communications
])
AS_IF([test x"$have_mpi2_1sided" = "xyes"],
[
AC_CHECK_FUNCS([PMPI_Win_test PMPI_Win_lock PMPI_Win_unlock])
AC_CHECK_FUNCS([PMPI_Win_test \
PMPI_Win_lock \
PMPI_Win_unlock])
])
dnl check for MPI-2 Extended Collective Operations
ACVT_CONF_SUBTITLE([MPI-2 Extended Collective Operations])
ACVT_CONF_SUBSUBTITLE([MPI-2 Extended Collective Operations])
AS_IF([test x"$check_mpi2_extcoll" = "xyes"],
[
AC_CHECK_FUNC([MPI_Alltoallw],
@ -735,7 +770,7 @@ dnl check for MPI-2 Extended Collective Operations
dnl check for MPI-2 I/O
ACVT_CONF_SUBTITLE([MPI-2 I/O])
ACVT_CONF_SUBSUBTITLE([MPI-2 I/O])
AS_IF([test x"$check_mpi2_io" = "xyes"],
[
AC_CHECK_DECL([LAM_MPI],
@ -758,7 +793,11 @@ dnl check for MPI-2 I/O
])
AS_IF([test x"$have_mpi2_io" = "xyes"],
[
AC_CHECK_FUNCS([MPI_Register_datarep])
AC_CHECK_FUNCS([MPI_Register_datarep \
PMPI_File_read_ordered \
PMPI_File_read_ordered_begin \
PMPI_File_write_ordered \
PMPI_File_write_ordered_begin])
])
CC=$sav_CC
@ -771,110 +810,7 @@ dnl check for Fortran interoperability
AS_IF([test x"$check_fmpiwraplib" = "xyes" -a x"$mpi_error" = "xno"],
[
ACVT_CONF_SUBTITLE([Fortran interoperability])
AS_IF([test x"$F77" != x],
[
AC_CHECK_PROGS(MPIF77, mpif77 hf77 mpxlf_r mpxlf mpf77 cmpifc mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c)
AS_IF([test x"$MPIF77" != x],
[
mpif77=`echo $MPIF77 | cut -d ' ' -f 1`
which_mpif77=`which $mpif77 2>/dev/null`
AS_IF([test x"$which_mpif77" = x], [AC_MSG_ERROR([$mpif77 not found])])
mpi_bin_dir=`dirname $which_mpif77`
AS_IF([test "$mpi_bin_dir" != "/usr/bin"],
[
AS_IF([test x"$FMPIINCDIR" = x],
[FMPIINCDIR=-I`echo $mpi_bin_dir | sed -e 's/bin/include/'`])
])
],
[
MPIF77="$F77"
AC_MSG_CHECKING([for mpif.h])
AS_IF([test x"$FMPIINCDIR" = x], [FMPIINCDIR="$MPIINCDIR"])
rm -f conftest.f conftest.o
cat > conftest.f << EOF
PROGRAM conftest
INCLUDE 'mpif.h'
END
EOF
eval "$F77 $FFLAGS $MPIFFLAGS $FMPIINCDIR -c conftest.f" >/dev/null 2>&1
AS_IF([test "$?" = "0" -a -s conftest.o], [AC_MSG_RESULT([yes])],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: no mpif.h found; check path for MPI package first...])
fmpiwraplib_error="yes"
])
rm -f conftest.f conftest.o
])
],
[
AC_MSG_NOTICE([error: no Fortran 77 compiler command given!])
fmpiwraplib_error="yes"
])
AS_IF([test x"$check_fc_conv" = "xyes" -a x"$fmpiwraplib_error" = "xno"],
[
sav_CC=$CC
sav_CPPFLAGS=$CPPFLAGS
sav_LIBS=$LIBS
CC=$MPICC
CPPFLAGS="$CPPFLAGS $MPICFLAGS $MPIINCDIR"
LIBS="$LIBS $MPILIBDIR $MPILIB"
dnl check for handle conversion: MPI_Comm
AC_CHECK_FUNC([MPI_Comm_f2c],
[AC_CHECK_FUNC([MPI_Comm_c2f], [VT_MPIGEN_HAVE_FC_CONV_COMM=1])])
dnl check for handle conversion: MPI_Errhandler
AC_CHECK_FUNC([MPI_Errhandler_f2c],
[AC_CHECK_FUNC([MPI_Errhandler_c2f], [VT_MPIGEN_HAVE_FC_CONV_ERRH=1])])
dnl check for handle conversion: MPI_File
AC_CHECK_FUNC([MPI_File_f2c],
[AC_CHECK_FUNC([MPI_File_c2f], [VT_MPIGEN_HAVE_FC_CONV_FILE=1])])
dnl check for handle conversion: MPI_Group
AC_CHECK_FUNC([MPI_Group_f2c],
[AC_CHECK_FUNC([MPI_Group_c2f], [VT_MPIGEN_HAVE_FC_CONV_GROUP=1])])
dnl check for handle conversion: MPI_Info
AC_CHECK_FUNC([MPI_Info_f2c],
[AC_CHECK_FUNC([MPI_Info_c2f], [VT_MPIGEN_HAVE_FC_CONV_INFO=1])])
dnl check for handle conversion: MPI_Op
AC_CHECK_FUNC([MPI_Op_f2c],
[AC_CHECK_FUNC([MPI_Op_c2f], [VT_MPIGEN_HAVE_FC_CONV_OP=1])])
dnl check for handle conversion: MPI_Request
AC_CHECK_FUNC([MPI_Request_f2c],
[AC_CHECK_FUNC([MPI_Request_c2f], [VT_MPIGEN_HAVE_FC_CONV_REQUEST=1])])
dnl check for handle conversion: MPI_Status
AC_CHECK_FUNC([MPI_Status_f2c],
[AC_CHECK_FUNC([MPI_Status_c2f], [VT_MPIGEN_HAVE_FC_CONV_STATUS=1])])
dnl check for handle conversion: MPI_Datatype
AC_CHECK_FUNC([MPI_Type_f2c],
[AC_CHECK_FUNC([MPI_Type_c2f], [VT_MPIGEN_HAVE_FC_CONV_TYPE=1])])
dnl check for handle conversion: MPI_Win
AC_CHECK_FUNC([MPI_Win_f2c],
[AC_CHECK_FUNC([MPI_Win_c2f], [VT_MPIGEN_HAVE_FC_CONV_WIN=1])])
dnl check for MPI-2 constants
AC_CHECK_DECLS([MPI_IN_PLACE],
[VT_MPIGEN_HAVE_FC_CONV_MPI2CONST=1; have_mpi2_const="yes"], [], [#include "mpi.h"])
dnl check for MPI_STATUS_SIZE
AC_CHECK_DECLS([MPI_STATUS_SIZE], [have_mpi_status_size="yes"], [], [#include "mpi.h"])
CC=$sav_CC
CPPFLAGS=$sav_CPPFLAGS
LIBS=$sav_LIBS
])
ACVT_FMPIWRAPLIB
AS_IF([test x"$fmpiwraplib_error" = "xno"],
[build_fmpiwraplib="yes"], [MPIF77="$F77"; FMPILIB=])
])
@ -882,7 +818,6 @@ dnl check for MPI_STATUS_SIZE
AS_IF([test x"$mpi_error" = "xno"], [have_mpi="yes"],
[MPICC="$CC"; MPICXX="$CXX"; MPIF77="$F77"])
AS_IF([test x"$FMPILIB" != x], [have_fmpi="yes"])
AS_IF([test x"$PMPILIB" = x"$MPILIB"], [PMPILIB=])
AS_IF([test x"$have_mpi2_thread" = "xyes"], [VT_MPIGEN_HAVE_MPI2_THREAD=1])
AS_IF([test x"$have_mpi2_1sided" = "xyes"], [VT_MPIGEN_HAVE_MPI2_1SIDED=1])
AS_IF([test x"$have_mpi2_extcoll" = "xyes"], [VT_MPIGEN_HAVE_MPI2_EXTCOLL=1])
@ -919,6 +854,146 @@ dnl check for MPI_STATUS_SIZE
AC_SUBST(VT_MPIGEN_HAVE_MPI2_1SIDED)
AC_SUBST(VT_MPIGEN_HAVE_MPI2_EXTCOLL)
AC_SUBST(VT_MPIGEN_HAVE_MPI2_IO)
])
AC_DEFUN([ACVT_FMPIWRAPLIB],
[
fmpiwraplib_error="no"
VT_MPIGEN_HAVE_FC_CONV_COMM=0
VT_MPIGEN_HAVE_FC_CONV_ERRH=0
VT_MPIGEN_HAVE_FC_CONV_FILE=0
VT_MPIGEN_HAVE_FC_CONV_GROUP=0
VT_MPIGEN_HAVE_FC_CONV_INFO=0
VT_MPIGEN_HAVE_FC_CONV_OP=0
VT_MPIGEN_HAVE_FC_CONV_REQUEST=0
VT_MPIGEN_HAVE_FC_CONV_STATUS=0
VT_MPIGEN_HAVE_FC_CONV_TYPE=0
VT_MPIGEN_HAVE_FC_CONV_WIN=0
VT_MPIGEN_HAVE_FC_CONV_MPI2CONST=0
AS_IF([test x"$F77" != x],
[
AC_CHECK_PROGS(MPIF77, mpif77 hf77 mpxlf_r mpxlf mpf77 cmpifc mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c)
AS_IF([test x"$MPIF77" != x],
[
mpif77=`echo $MPIF77 | cut -d ' ' -f 1`
which_mpif77=`which $mpif77 2>/dev/null`
AS_IF([test x"$which_mpif77" = x], [AC_MSG_ERROR([$mpif77 not found])])
mpi_bin_dir=`dirname $which_mpif77`
AS_IF([test "$mpi_bin_dir" != "/usr/bin" -a "$mpi_bin_dir" != "/SX/usr/bin" -a x"$FMPIINCDIR" != x-I"$mpi_inc_dir"],
[
mpi_inc_dir=-I`echo $mpi_bin_dir | sed -e 's/bin/include/'`
AS_IF([test x"$FMPIINCDIR" != x"$mpi_inc_dir"],
[FMPIINCDIR="$FMPIINCDIR -I`echo $mpi_bin_dir | sed -e 's/bin/include/'`"])
])
],
[
MPIF77="$F77"
AC_MSG_CHECKING([for mpif.h])
rm -f conftest.f conftest.o
cat > conftest.f << EOF
PROGRAM conftest
INCLUDE 'mpif.h'
END
EOF
eval "$F77 $FFLAGS $MPIFFLAGS $FMPIINCDIR -c conftest.f" >/dev/null 2>&1
AS_IF([test "$?" = "0" -a -s conftest.o], [AC_MSG_RESULT([yes])],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: no mpif.h found; check path for MPI package first...])
fmpiwraplib_error="yes"
])
rm -f conftest.f conftest.o
])
],
[
AC_MSG_NOTICE([error: no Fortran 77 compiler command given])
fmpiwraplib_error="yes"
])
AS_IF([test x"$check_fc_conv" = "xyes" -a x"$fmpiwraplib_error" = "xno"],
[
sav_CC=$CC
sav_CPPFLAGS=$CPPFLAGS
sav_LIBS=$LIBS
CC=$MPICC
CPPFLAGS="$CPPFLAGS $MPICFLAGS $MPIINCDIR"
LIBS="$LIBS $MPILIBDIR $MPILIB"
dnl check for handle conversion: MPI_Comm
AC_CHECK_DECL([MPI_Comm_f2c],
[AC_CHECK_DECL([MPI_Comm_c2f],
[VT_MPIGEN_HAVE_FC_CONV_COMM=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Errhandler
AC_CHECK_DECL([MPI_Errhandler_f2c],
[AC_CHECK_DECL([MPI_Errhandler_c2f],
[VT_MPIGEN_HAVE_FC_CONV_ERRH=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_File
AC_CHECK_DECL([MPI_File_f2c],
[AC_CHECK_DECL([MPI_File_c2f],
[VT_MPIGEN_HAVE_FC_CONV_FILE=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Group
AC_CHECK_DECL([MPI_Group_f2c],
[AC_CHECK_DECL([MPI_Group_c2f],
[VT_MPIGEN_HAVE_FC_CONV_GROUP=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Info
AC_CHECK_DECL([MPI_Info_f2c],
[AC_CHECK_DECL([MPI_Info_c2f],
[VT_MPIGEN_HAVE_FC_CONV_INFO=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Op
AC_CHECK_DECL([MPI_Op_f2c],
[AC_CHECK_DECL([MPI_Op_c2f],
[VT_MPIGEN_HAVE_FC_CONV_OP=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Request
AC_CHECK_DECL([MPI_Request_f2c],
[AC_CHECK_DECL([MPI_Request_c2f],
[VT_MPIGEN_HAVE_FC_CONV_REQUEST=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Status
AC_CHECK_DECL([MPI_Status_f2c],
[AC_CHECK_DECL([MPI_Status_c2f],
[VT_MPIGEN_HAVE_FC_CONV_STATUS=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Datatype
AC_CHECK_DECL([MPI_Type_f2c],
[AC_CHECK_DECL([MPI_Type_c2f],
[VT_MPIGEN_HAVE_FC_CONV_TYPE=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for handle conversion: MPI_Win
AC_CHECK_DECL([MPI_Win_f2c],
[AC_CHECK_DECL([MPI_Win_c2f],
[VT_MPIGEN_HAVE_FC_CONV_WIN=1], [], [#include "mpi.h"])],
[], [#include "mpi.h"])
dnl check for MPI-2 constants
AC_CHECK_DECLS([MPI_IN_PLACE],
[VT_MPIGEN_HAVE_FC_CONV_MPI2CONST=1; have_mpi2_const="yes"], [], [#include "mpi.h"])
dnl check for MPI_STATUS_SIZE
AC_CHECK_DECLS([MPI_STATUS_SIZE], [have_mpi_status_size="yes"], [], [#include "mpi.h"])
CC=$sav_CC
CPPFLAGS=$sav_CPPFLAGS
LIBS=$sav_LIBS
])
AC_SUBST(VT_MPIGEN_HAVE_FC_CONV_COMM)
AC_SUBST(VT_MPIGEN_HAVE_FC_CONV_ERRH)

50
ompi/contrib/vt/vt/config/m4/acinclude.mpiunifylib.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,50 @@
AC_DEFUN([ACVT_MPIUNIFYLIB],
[
mpiunifylib_error="no"
check_mpiunifylib="yes"
force_mpiunifylib="no"
build_mpiunifylib="no"
VTMPIUNIFYLIB=
AC_REQUIRE([ACVT_PLATFORM])
AC_REQUIRE([ACVT_ETIMESYNC])
AC_REQUIRE([ACVT_UNIMCI])
AC_ARG_ENABLE(mpiunify-lib,
AC_HELP_STRING([--enable-mpiunify-lib],
[build MPI trace unification library, default: enable if C++ runtime library found]),
[AS_IF([test x"$enableval" = "xyes"], [force_mpiunifylib="yes"], [check_mpiunifylib="no"])])
AS_IF([test x"$check_mpiunifylib" = "xyes"],
[
AS_IF([test "$PLATFORM" = "ibm" -o "$PLATFORM" = "necsx"],
[
AC_MSG_NOTICE([error: The MPI trace unification library cannot be built on this platform])
mpiunifylib_error="yes"
])
AS_IF([test x"$mpiunifylib_error" = "xno"],
[
AS_IF([test x"$have_unimci" = "xyes" -a x"$unimci_checker_name" = "xMARMOT"],
[
VTMPIUNIFYLIB="-lvt-mpi-unify -lotfaux $CLAPACKLIBDIR $CLAPACKLIB"
build_mpiunifylib="yes"
],
[
ACVT_CXXRTLIB
AS_IF([test x"$cxxrtlib_error" = "xno"],
[
VTMPIUNIFYLIB="-lvt-mpi-unify -lotfaux $CLAPACKLIBDIR $CLAPACKLIB $cxxrtlib"
build_mpiunifylib="yes"
],
[
mpiunifylib_error="yes"
])
])
])
])
AC_SUBST(VTMPIUNIFYLIB)
])

49
ompi/contrib/vt/vt/config/m4/acinclude.nm.m4
Просмотреть файл

@ -1,49 +0,0 @@
AC_DEFUN([ACVT_NM],
[
AC_REQUIRE([AC_PROG_CC])
AC_REQUIRE([AC_PROG_NM])
AS_IF([test x"$NM" != x -a x"$lt_cv_nm_interface" = "xBSD nm"],
[
default_nm="$NM"
AC_TRY_COMPILE([], [],
[
opts_to_check="--demangle"
for opt in $opts_to_check
do
AC_MSG_CHECKING([if $NM demangle option $opt works])
eval "$NM $opt conftest.$ac_objext" >/dev/null 2>&1
AS_IF([test "$?" = "0"],
[
AC_MSG_RESULT([yes])
default_nm="$default_nm $opt"
break
],
[
AC_MSG_RESULT([no])
])
done
opts_to_check="--line-numbers"
for opt in $opts_to_check
do
AC_MSG_CHECKING([if $NM line numbers option $opt works])
eval "$NM $opt conftest.$ac_objext" >/dev/null 2>&1
AS_IF([test "$?" = "0"],
[
AC_MSG_RESULT([yes])
default_nm="$default_nm $opt"
break
],
[
AC_MSG_RESULT([no])
])
done
])
AC_DEFINE_UNQUOTED([DEFAULT_NM], ["$default_nm"],
[Command to list symbols from object files.])
])
])

42
ompi/contrib/vt/vt/config/m4/acinclude.otf.m4
Просмотреть файл

@ -6,6 +6,7 @@ AC_DEFUN([ACVT_OTF],
OTFINCDIR=
OTFLIBDIR=
AC_REQUIRE([ACVT_MPI])
AC_REQUIRE([ACVT_ZLIB])
AC_ARG_WITH(extern-otf,
@ -91,6 +92,9 @@ AC_DEFUN([ACVT_OTF],
otf_conf_cmd="$otf_srcdir/configure"
otf_conf_args="--enable-static=$enable_static --enable-shared=$enable_shared"
sav_CPPFLAGS=$CPPFLAGS
AS_IF([test x"$enable_binaries" != "xyes"],
[
otf_conf_args="$otf_conf_args --disable-binaries"
@ -100,16 +104,40 @@ AC_DEFUN([ACVT_OTF],
AS_IF([test ! -z $build], [otf_conf_args="$otf_conf_args --build=$build"])
AS_IF([test ! -z $host], [otf_conf_args="$otf_conf_args --host=$host"])
])
AS_IF([test x"$have_mpi" = "xyes"],
[
export MPICC
export MPICXX
AS_IF([test x"$force_mpi" = "xyes"],
[otf_conf_args="$otf_conf_args --with-mpi"])
AS_IF([test $MPICC = $CC],
[
AS_IF([test x"$MPIDIR" != x],
[otf_conf_args="$otf_conf_args --with-mpi-dir=$MPIDIR"])
dnl if we are inside Open MPI package MPIINCDIR contains multiple paths
dnl so it cannot be used for --with-mpi-inc-dir; use CPPFLAGS instead
AS_IF([test x"$MPIINCDIR" != x],
[CPPFLAGS="$CPPFLAGS $MPIINCDIR"])
dnl [otf_conf_args="$otf_conf_args --with-mpi-inc-dir=`echo $MPIINCDIR | sed s/-I//`"])
AS_IF([test x"$MPILIBDIR" != x],
[otf_conf_args="$otf_conf_args --with-mpi-lib-dir=`echo $MPILIBDIR | sed s/-L//`"])
AS_IF([test x"$MPILIB" != x],
[otf_conf_args="$otf_conf_args --with-mpi-lib=$MPILIB"])
])
],
[
otf_conf_args="$otf_conf_args --without-mpi"
])
AS_IF([test x"$have_zlib" = "xyes"],
[
AS_IF([test x"$force_zlib" = "xyes"],
[otf_conf_args="$otf_conf_args --with-zlib"])
AS_IF([test x"$zlib_dir_withval" != x],
[otf_conf_args="$otf_conf_args --with-zlib-dir=$zlib_dir_withval"])
AS_IF([test x"$zlib_incdir_withval" != x],
[otf_conf_args="$otf_conf_args --with-zlib-inc-dir=$zlib_incdir_withval"])
AS_IF([test x"$zlib_libdir_withval" != x],
[otf_conf_args="$otf_conf_args --with-zlib-lib-dir=$zlib_libdir_withval"])
AS_IF([test x"$ZLIBDIR" != x],
[otf_conf_args="$otf_conf_args --with-zlib-dir=$ZLIBDIR"])
AS_IF([test x"$ZLIBINCDIR" != x],
[otf_conf_args="$otf_conf_args --with-zlib-inc-dir=`echo $ZLIBINCDIR | sed s/-I//`"])
AS_IF([test x"$ZLIBLIBDIR" != x],
[otf_conf_args="$otf_conf_args --with-zlib-lib-dir=`echo $ZLIBLIBDIR | sed s/-L//`"])
AS_IF([test x"$ZLIBLIB" != x],
[otf_conf_args="$otf_conf_args --with-zlib-lib=$ZLIBLIB"])
],
@ -123,6 +151,8 @@ AC_DEFUN([ACVT_OTF],
eval "$SHELL '$otf_conf_cmd' $otf_conf_args"
AS_IF([test $? != "0"], [AC_MSG_ERROR([$otf_conf_cmd failed for $otf_dir])])
CPPFLAGS=$sav_CPPFLAGS
cd $otf_parent_dir
OTFINCDIR=

16
ompi/contrib/vt/vt/config/m4/acinclude.pform.m4
Просмотреть файл

@ -9,11 +9,11 @@ AC_DEFUN([ACVT_PLATFORM],
AC_ARG_WITH(platform,
AC_HELP_STRING([--with-platform=PLATFORM],
[configure for given platform (altix,bgl,bgp,crayt3e,crayx1,crayxt,ibm,linux,macos,necsx,origin,sicortex,sun,generic), default: automatically by configure]),
[configure for given platform (altix,bgl,bgp,crayt3e,crayx1,crayxt,crayxe,ibm,linux,macos,necsx,origin,sicortex,sun,generic), default: automatically by configure]),
[
AC_MSG_RESULT([skipped (--with-platform=$withval)])
pform_list="altix bgl bgp crayt3e crayx1 crayxt ibm linux macos necsx origin sicortex sun generic"
pform_list="altix bgl bgp crayt3e crayx1 crayxt crayxe ibm linux macos necsx origin sicortex sun generic"
pform_found="no"
for p in $pform_list
do
@ -34,11 +34,13 @@ AC_DEFUN([ACVT_PLATFORM],
[PLATFORM=bgl],
[AS_IF([test "$host_cpu" = "powerpc64" -a -d /bgsys],
[PLATFORM=bgp],
[AS_IF([test "$host_cpu" = "x86_64" -a -d /opt/xt-boot],
[PLATFORM=crayxt],
[AS_IF([test "$host_cpu" = "mips64" -a -d /opt/sicortex],
[PLATFORM=sicortex],
[PLATFORM=linux])])])])])
[AS_IF([test "$host_cpu" = "x86_64" -a "x`uname -r | grep -q cray_gem && echo TRUE`" = "xTRUE"],
[PLATFORM=crayxe],
[AS_IF([test "$host_cpu" = "x86_64" -a -d /opt/xt-boot],
[PLATFORM=crayxt],
[AS_IF([test "$host_cpu" = "mips64" -a -d /opt/sicortex],
[PLATFORM=sicortex],
[PLATFORM=linux])])])])])])
;;
sunos* | solaris*)
PLATFORM=sun

30
ompi/contrib/vt/vt/config/m4/acinclude.plugincntr.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,30 @@
AC_DEFUN([ACVT_PLUGINCNTR],
[
plugin_cntr_error="no"
check_plugin_cntr="yes"
force_plugin_cntr="no"
have_plugin_cntr="no"
AC_REQUIRE([ACVT_PLATFORM])
AC_ARG_ENABLE(plugincntr,
AC_HELP_STRING([--enable-plugincntr], [enable plugin counter support, default: enable if found by configure]),
[AS_IF([test x"$enableval" = "xyes"], [force_plugin_cntr="yes"], [check_plugin_cntr="no"])])
AS_IF([test x"$check_plugin_cntr" = "xyes"],
[
AS_IF([test "$PLATFORM" = "bgp" -a x"$enable_shared" = "xno"],
[
AC_MSG_NOTICE([error: the plugin counter support requires building of shared libraries on this platform; re-configure with \`--enable-shared'])
plugin_cntr_error="yes"
])
AS_IF([test x"$plugin_cntr_error" = "xno"],
[
ACVT_DL
AS_IF([test x"$have_dl" = "xyes"],
[have_plugin_cntr="yes"], [plugin_cntr_error="yes"])
])
])
])

86
ompi/contrib/vt/vt/config/m4/acinclude.tauinst.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,86 @@
AC_DEFUN([ACVT_TAUINST],
[
tauinst_error="no"
check_tauinst="yes"
force_tauinst="no"
have_tauinst="no"
tauinst_cmd=
tauinst_cparse_cmd=
tauinst_cxxparse_cmd=
tauinst_fparse_cmd=
AC_ARG_ENABLE(tauinst,
AC_HELP_STRING([--enable-tauinst],
[enable support for automatic source code instrumentation by using TAU, default: enable if found by configure]),
[AS_IF([test x"$enableval" = "xyes"], [force_tauinst="yes"], [check_tauinst="no"])])
AC_ARG_WITH(tau-instrumentor,
AC_HELP_STRING([--with-tau-instrumentor=TAUINSTUMENTOR],
[give the command for the TAU instrumentor, default: tau_instrumentor]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-tau-instrumentor' not properly set!])])
tauinst_cmd=$withval
])
AC_ARG_WITH(pdt-cparse,
AC_HELP_STRING([--with-pdt-cparse=PDTCPARSE],
[give the command for PDT C source code parser, default: cparse]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-pdt-cparse' not properly set!])])
tauinst_cparse_cmd=$withval
])
AC_ARG_WITH(pdt-cxxparse,
AC_HELP_STRING([--with-pdt-cxxparse=PDTCXXPARSE],
[give the command for PDT C++ source code parser, default: cxxparse]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-pdt-cxxparse' not properly set!])])
tauinst_cxxparse_cmd=$withval
])
AC_ARG_WITH(pdt-fparse,
AC_HELP_STRING([--with-pdt-fparse=PDTFPARSE],
[give the command for PDT Fortran source code parser, default: f95parse, f90parse, or gfparse]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-pdt-fparse' not properly set!])])
tauinst_fparse_cmd=$withval
])
AS_IF([test "$check_tauinst" = "yes"],
[
AC_CHECK_PROG(tauinst_cmd, tau_instrumentor, tau_instrumentor)
AS_IF([test x"$tauinst_cmd" = x],
[
AC_MSG_NOTICE([error: no tau_instrumentor found; check path for PDToolkit first...])
tauinst_error="yes"
])
AS_IF([test x"$tauinst_error" = "xno"],
[
AC_CHECK_PROG(tauinst_cparse_cmd, cparse, cparse)
AS_IF([test x"$tauinst_cparse_cmd" = x],
[AC_MSG_WARN([no cparse found; C source code cannot be instrumented by TAU])])
AC_CHECK_PROG(tauinst_cxxparse_cmd, cxxparse, cxxparse)
AS_IF([test x"$tauinst_cxxparse_cmd" = x],
[AC_MSG_WARN([no cxxparse found; C++ source code cannot be instrumented by TAU])])
AC_CHECK_PROGS(tauinst_fparse_cmd, f95parse f90parse gfparse)
AS_IF([test x"$tauinst_fparse_cmd" = x],
[AC_MSG_WARN([no f95parse, f90parse, or gfparse found; Fortran source code cannot be instrumented by TAU])])
AS_IF([test x"$tauinst_cparse_cmd$tauinst_cxxparse_cmd$tauinst_fparse_cmd" = x],
[
AC_MSG_NOTICE([error: no PDT source code parser command found; check path for PDToolkit first...])
tauinst_error="yes"
])
])
AS_IF([test x"$tauinst_error" = "xno"],
[have_tauinst="yes"])
])
])

6
ompi/contrib/vt/vt/config/m4/acinclude.timer.m4
Просмотреть файл

@ -105,6 +105,12 @@ AC_DEFUN([ACVT_TIMER],
timer=TIMER_DCLOCK
])])])
;;
crayxe)
AC_DEFINE([TIMER_CLOCK_GETTIME], [1], [Use `clock_gettime' function])
AC_DEFINE([TIMER_CYCLE_COUNTER], [2], [Cycle counter (e.g. TSC)])
AC_DEFINE([TIMER_GETTIMEOFDAY], [3], [Use `gettimeofday' function])
timer=TIMER_CYCLE_COUNTER
;;
origin)
AC_DEFINE([TIMER_CLOCK_GETTIME], [1], [Use `clock_gettime' function])
timer=TIMER_CLOCK_GETTIME

24
ompi/contrib/vt/vt/config/m4/acinclude.unimci.m4
Просмотреть файл

@ -30,7 +30,7 @@ AC_DEFUN([ACVT_UNIMCI],
AC_ARG_WITH(unimci-config,
AC_HELP_STRING([--with-unimci-config=UNIMCICONFIG],
[give the command for UniMCI config utility, default: automatically by configure]),
[give the command for UniMCI config utility, default: unimci-config]),
[
AS_IF([test x"$withval" = "xyes" -o x"$withval" = "xno"],
[AC_MSG_ERROR([value of '--with-unimci-config' not properly set!])])
@ -69,7 +69,7 @@ dnl check for version
unimci_major_version=`echo $unimci_version | cut -d '.' -f 1`
AS_IF([test $unimci_major_version -ne 1],
[
AC_MSG_NOTICE([error: the version of UniMCI isn't supported!])
AC_MSG_NOTICE([error: the version of UniMCI isn't supported])
unimci_error="yes"
])
],
@ -229,6 +229,26 @@ dnl check for linker flags
])
])
dnl check for MPI Fortran interoperability
AS_IF([test x"$unimci_error" = "xno" -a x"$have_fmpi" = "xyes" -a x"$build_fmpiwraplib" = "xno"],
[
AS_IF([test x"$F77" != x -o x"$FC" != x],
[
ACVT_CONF_SUBSUBTITLE([MPI Fortran interoperability])
ACVT_FMPIWRAPLIB
AS_IF([test x"$fmpiwraplib_error" = "xno"],
[
build_fmpiwraplib="yes"
FMPILIB="-lvt-fmpi"
],
[
AC_MSG_NOTICE([error: MPI Fortran interoperability checks failed])
unimci_error = "yes"
])
])
])
AS_IF([test x"$unimci_error" = "xno"],
[
AC_DEFINE_UNQUOTED([UNIMCI_CHECKER_NAME],

71
ompi/contrib/vt/vt/config/m4/acinclude.vtrun.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,71 @@
AC_DEFUN([ACVT_RUN],
[
vtrun_error="no"
check_vtrun="yes"
force_vtrun="no"
build_vtrun="no"
VT_RUN_MACOS=0
VT_RUN_HAVE_THREADS=0
VT_RUN_HAVE_MPI=0
VT_RUN_HAVE_FMPI=0
VT_RUN_HAVE_DYNINST=0
VT_RUN_NM=
VT_RUN_VTLIB=
VT_RUN_VTMPILIB=
VT_RUN_VTMTLIB=
VT_RUN_VTHYBLIB=
VT_RUN_FMPILIB=
VT_RUN_DYNATTLIB=
AC_REQUIRE([ACVT_PLATFORM])
AC_REQUIRE([ACVT_MPI])
AC_REQUIRE([ACVT_THREADS])
AC_REQUIRE([ACVT_DYNINST])
AC_ARG_ENABLE(vtrun,
AC_HELP_STRING([--enable-vtrun],
[build vtrun - an application execution wrapper script, default: enable if shared libraries are supported]),
[AS_IF([test x"$enableval" = "xyes"], [force_vtrun="yes"], [check_vtrun="no"])])
AS_IF([test x"$check_vtrun" = "xyes"],
[
AC_MSG_CHECKING([whether we can build shared libraries])
AS_IF([test x"$enable_shared" = "xyes"],
[AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no]); vtrun_error="yes"])
AS_IF([test x"$vtrun_error" = "xno"],
[
AC_MSG_NOTICE([setup capabilities of vtrun])
AS_IF([test $PLATFORM = "macos"], [VT_RUN_MACOS=1])
AS_IF([test x"$have_threads" = "xyes"], [VT_RUN_HAVE_THREADS=1])
AS_IF([test x"$have_mpi" = "xyes"], [VT_RUN_HAVE_MPI=1])
AS_IF([test x"$have_fmpi" = "xyes"], [VT_RUN_HAVE_FMPI=1])
AS_IF([test x"$have_dyninst" = "xyes" -a x"$build_dynattlib" = "xyes"], [VT_RUN_HAVE_DYNINST=1])
VT_RUN_NM=`echo $NM | sed s/--line-numbers//g`
VT_RUN_VTLIB="libvt$SHREXT"
VT_RUN_VTMPILIB="libvt-mpi$SHREXT"
VT_RUN_VTMTLIB="libvt-mt$SHREXT"
VT_RUN_VTHYBLIB="libvt-hyb$SHREXT"
VT_RUN_FMPILIB="libvt-fmpi$SHREXT"
VT_RUN_DYNATTLIB="libvt-dynatt$SHREXT"
build_vtrun=yes
])
])
AC_SUBST(VT_RUN_MACOS)
AC_SUBST(VT_RUN_HAVE_THREADS)
AC_SUBST(VT_RUN_HAVE_MPI)
AC_SUBST(VT_RUN_HAVE_FMPI)
AC_SUBST(VT_RUN_HAVE_DYNINST)
AC_SUBST(VT_RUN_NM)
AC_SUBST(VT_RUN_VTLIB)
AC_SUBST(VT_RUN_VTMPILIB)
AC_SUBST(VT_RUN_VTMTLIB)
AC_SUBST(VT_RUN_VTHYBLIB)
AC_SUBST(VT_RUN_FMPILIB)
AC_SUBST(VT_RUN_DYNATTLIB)
])

85
ompi/contrib/vt/vt/config/m4/acinclude.vtsetup.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,85 @@
AC_DEFUN([ACVT_SETUP],
[
vtsetup_error="no"
check_vtsetup="yes"
force_vtsetup="no"
build_vtsetup="no"
VT_SETUP_NM=
VT_SETUP_COMPINST_GNU=0
VT_SETUP_COMPRESSION=0
VT_SETUP_CPUIDTRACE=0
VT_SETUP_DYNINST=0
VT_SETUP_ETIMESYNC=0
VT_SETUP_IOTRACE=0
VT_SETUP_JAVA=0
VT_SETUP_LIBCTRACE=0
VT_SETUP_MEMTRACE=0
VT_SETUP_METRICS=0
VT_SETUP_MPI=0
VT_SETUP_MPICHECK=0
VT_SETUP_OMP=0
VT_SETUP_PLUGIN_CNTR=0
VT_SETUP_PTHREAD=0
VT_SETUP_RUSAGE=0
AC_ARG_ENABLE(vtsetup,
AC_HELP_STRING([--enable-vtsetup],
[build vtsetup - a GUI to prepare measurement runs with VampirTrace, default: enable if JAVA found by configure]),
[AS_IF([test x"$enableval" = "xyes"], [force_vtsetup="yes"], [check_vtsetup="no"])])
AS_IF([test x"$check_vtsetup" = "xyes"],
[
AC_CHECK_PROG(JAVA, java, java)
AS_IF([test x"$JAVA" = x],
[
AC_MSG_RESULT([no])
AC_MSG_NOTICE([error: no java found; check path for JAVA package first...])
vtsetup_error="yes"
])
AS_IF([test x"$vtsetup_error" = "xno"],
[
AC_MSG_NOTICE([setup capabilities of vtsetup])
VT_SETUP_NM=`echo $NM | sed s/--line-numbers//g`
AS_IF([test x"$compinst_type" = "xgnu"], [VT_SETUP_COMPINST_GNU=1])
AS_IF([test x"$have_zlib" = "xyes"], [VT_SETUP_COMPRESSION=1])
AS_IF([test x"$have_getcpu" = "xyes"], [VT_SETUP_CPUIDTRACE=1])
AS_IF([test x"$have_dyninst" = "xyes" -a x"$build_dynattlib" = "xyes"], [VT_SETUP_DYNINST=1])
AS_IF([test x"$build_etimesync" = "xyes"], [VT_SETUP_ETIMESYNC=1])
AS_IF([test x"$have_iowrap" = "xyes"], [VT_SETUP_IOTRACE=1])
AS_IF([test x"$have_java" = "xyes"], [VT_SETUP_JAVA=1])
AS_IF([test x"$have_libcwrap" = "xyes"], [VT_SETUP_LIBCTRACE=1])
AS_IF([test x"$have_memhooks" = "xyes"], [VT_SETUP_MEMTRACE=1])
AS_IF([test x"$have_papi" = "xyes"], [VT_SETUP_METRICS=1])
AS_IF([test x"$have_mpi" = "xyes"], [VT_SETUP_MPI=1])
AS_IF([test x"$have_unimci" = "xyes"], [VT_SETUP_MPICHECK=1])
AS_IF([test x"$have_omp" = "xyes"], [VT_SETUP_OMP=1])
AS_IF([test x"$have_plugin_cntr" = "xyes"], [VT_SETUP_PLUGIN_CNTR=1])
AS_IF([test x"$have_pthread" = "xyes"], [VT_SETUP_PTHREAD=1])
AS_IF([test x"$have_rusage" = "xyes"], [VT_SETUP_RUSAGE=1])
build_vtsetup="yes"
])
])
AC_SUBST(VT_SETUP_NM)
AC_SUBST(VT_SETUP_COMPINST_GNU)
AC_SUBST(VT_SETUP_COMPRESSION)
AC_SUBST(VT_SETUP_CPUIDTRACE)
AC_SUBST(VT_SETUP_DYNINST)
AC_SUBST(VT_SETUP_ETIMESYNC)
AC_SUBST(VT_SETUP_IOTRACE)
AC_SUBST(VT_SETUP_JAVA)
AC_SUBST(VT_SETUP_LIBCTRACE)
AC_SUBST(VT_SETUP_MEMTRACE)
AC_SUBST(VT_SETUP_METRICS)
AC_SUBST(VT_SETUP_MPI)
AC_SUBST(VT_SETUP_MPICHECK)
AC_SUBST(VT_SETUP_OMP)
AC_SUBST(VT_SETUP_PLUGIN_CNTR)
AC_SUBST(VT_SETUP_PTHREAD)
AC_SUBST(VT_SETUP_RUSAGE)
])

9
ompi/contrib/vt/vt/config/m4/acinclude.zlib.m4
Просмотреть файл

@ -4,9 +4,6 @@ AC_DEFUN([ACVT_ZLIB],
check_zlib="yes"
force_zlib="no"
have_zlib="no"
zlib_dir_withval=
zlib_incdir_withval=
zlib_libdir_withval=
ZLIBDIR=
ZLIBINCDIR=
@ -20,18 +17,18 @@ AC_DEFUN([ACVT_ZLIB],
AC_ARG_WITH(zlib-dir,
AC_HELP_STRING([--with-zlib-dir=ZLIBDIR], [give the path for ZLIB, default: /usr]),
[zlib_dir_withval=$withval; ZLIBDIR="$withval/"])
[ZLIBDIR="$withval/"])
AC_ARG_WITH(zlib-inc-dir,
AC_HELP_STRING([--with-zlib-inc-dir=ZLIBINCDIR],
[give the path for ZLIB-include files, default: ZLIB/include]),
[zlib_incdir_withval=$withval; ZLIBINCDIR="-I$withval/"],
[ZLIBINCDIR="-I$withval/"],
[AS_IF([test x"$ZLIBDIR" != x], [ZLIBINCDIR="-I$ZLIBDIR"include/])])
AC_ARG_WITH(zlib-lib-dir,
AC_HELP_STRING([--with-zlib-lib-dir=ZLIBLIBDIR],
[give the path for ZLIB-libraries, default: ZLIBDIR/lib]),
[zlib_libdir_withval=$withval; ZLIBLIBDIR="-L$withval/"],
[ZLIBLIBDIR="-L$withval/"],
[AS_IF([test x"$ZLIBDIR" != x], [ZLIBLIBDIR="-L$ZLIBDIR"lib/])])
AC_ARG_WITH(zlib-lib,

5
ompi/contrib/vt/vt/config/mpigen/c_dont_generate.txt
Просмотреть файл

@ -1,7 +1,6 @@
# This file lists all calls, which should not be generated
# automatically by mk_c_wrapper.sh
MPI_Initialized
MPI_Pcontrol
MPI_Wtick
MPI_Wtime
@ -19,6 +18,9 @@ MPI_Win_create_errhandler
MPI_Win_get_errhandler
MPI_Win_set_errhandler
# conflicting argument types with SGI-MPT (noticed on version 1.26)
MPI_Grequest_complete
# implemented MPI functions
MPI_Allgather
MPI_Allgatherv
@ -51,6 +53,7 @@ MPI_Irsend
MPI_Isend
MPI_Issend
MPI_Finalize
MPI_Finalized
MPI_Recv
MPI_Recv_init
MPI_Reduce

13
ompi/contrib/vt/vt/config/mpigen/fortran_dont_generate.txt
Просмотреть файл

@ -1,9 +1,6 @@
# This file lists all calls, which should not be generated
# automatically by mk_fortran_wrapper.sh
MPI_Init
MPI_Initialized
MPI_Init_thread
MPI_Pcontrol
MPI_Wtick
MPI_Wtime
@ -27,3 +24,13 @@ MPI_Win_create_keyval
MPI_Comm_spawn
MPI_Comm_spawn_multiple
# TODO: Fortran/C conversion of type 'MPI_Datarep_conversion_function'
MPI_Register_datarep
# conflicting argument types with SGI-MPT (noticed on version 1.26)
MPI_Grequest_complete
# implemented MPI functions
MPI_Init
MPI_Init_thread

62
ompi/contrib/vt/vt/config/mpigen/mk_c_wrapper.sh.in
Просмотреть файл

@ -6,12 +6,15 @@
export SRCDIR=@top_vt_srcdir@/config/mpigen
have_mpi2=0 #@VT_MPIGEN_HAVE_MPI2@
have_mpi2_thread=@VT_MPIGEN_HAVE_MPI2_THREAD@
have_mpi2_1sided=@VT_MPIGEN_HAVE_MPI2_1SIDED@
have_mpi2_extcoll=@VT_MPIGEN_HAVE_MPI2_EXTCOLL@
have_mpi2_file=@VT_MPIGEN_HAVE_MPI2_IO@
have_mpi2_proc=0 #@VT_MPIGEN_HAVE_MPI2_PROC@
have_mpi2_proc=0 #@VT_MPIGEN_HAVE_MPI2_PROC@
if [ $have_mpi2_thread -o $have_mpi2_1sided -o $have_mpi2_extcoll -o $have_mpi2_proc ] ; then
have_mpi2=1
fi
mpi2_src1=""; if [ $have_mpi2 = 1 ] ; then mpi2_src1="mpi2_standard.h"; fi
mpi2_src2=""; if [ $have_mpi2_thread = 1 ] ; then mpi2_src2="mpi2_thread.h"; fi
mpi2_src3=""; if [ $have_mpi2_1sided = 1 ] ; then mpi2_src3="mpi2_1sided.h"; fi
@ -48,7 +51,7 @@ cat <<End-of-File >$tmp.c
* VampirTrace
* http://www.tu-dresden.de/zih/vampirtrace
*
* Copyright (c) 2005-2010, ZIH, TU Dresden, Federal Republic of Germany
* Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
*
* Copyright (c) 1998-2005, Forschungszentrum Juelich, Juelich Supercomputing
* Centre, Federal Republic of Germany
@ -80,17 +83,51 @@ cat <<End-of-File >$tmp.awk
next
}
optional=0
if (index(mpicall,"MPI_Add_error_class") != 0) {
printf "#if defined(HAVE_MPI_ADD_ERROR_CLASS) && HAVE_MPI_ADD_ERROR_CLASS\n\n"
optional=1
}
if (index(mpicall,"MPI_Add_error_code") != 0) {
printf "#if defined(HAVE_MPI_ADD_ERROR_CODE) && HAVE_MPI_ADD_ERROR_CODE\n\n"
optional=1
}
if (index(mpicall,"MPI_Add_error_string") != 0) {
printf "#if defined(HAVE_MPI_ADD_ERROR_STRING) && HAVE_MPI_ADD_ERROR_STRING\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_create_f90_complex") != 0) {
printf "#if defined(HAVE_MPI_TYPE_CREATE_F90_COMPLEX) && HAVE_MPI_TYPE_CREATE_F90_COMPLEX\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_create_f90_integer") != 0) {
printf "#if defined(HAVE_MPI_TYPE_CREATE_F90_INTEGER) && HAVE_MPI_TYPE_CREATE_F90_INTEGER\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_create_f90_real") != 0) {
printf "#if defined(HAVE_MPI_TYPE_CREATE_F90_REAL) && HAVE_MPI_TYPE_CREATE_F90_REAL\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_match_size") != 0) {
printf "#if defined(HAVE_MPI_TYPE_MATCH_SIZE) && HAVE_MPI_TYPE_MATCH_SIZE\n\n"
optional=1
}
if (index(mpicall,"MPI_Win_test") != 0) {
printf "#if defined(HAVE_PMPI_WIN_TEST) && HAVE_PMPI_WIN_TEST\n\n"
optional=1
}
if (index(mpicall,"MPI_Win_lock") != 0) {
printf "#if defined(HAVE_PMPI_WIN_LOCK) && HAVE_PMPI_WIN_LOCK\n\n"
optional=1
}
if (index(mpicall,"MPI_Win_unlock") != 0) {
printf "#if defined(HAVE_PMPI_WIN_UNLOCK) && HAVE_PMPI_WIN_UNLOCK\n\n"
optional=1
}
if (index(mpicall,"MPI_Register_datarep") != 0) {
printf "#if defined(HAVE_MPI_REGISTER_DATAREP) && HAVE_MPI_REGISTER_DATAREP\n\n"
optional=1
}
printf "/* -- %s -- */\n\n", mpicall
@ -118,7 +155,7 @@ cat <<End-of-File >$tmp.awk
print " MPI_TRACE_OFF();"
print ""
print " time = vt_pform_wtime();"
printf" was_recorded = vt_enter(&time, vt_mpi_regid[VT__%s]);\n", toupper(mpicall)
printf" was_recorded = vt_enter(VT_CURRENT_THREAD, &time, vt_mpi_regid[VT__%s]);\n", toupper(mpicall)
print ""
printf" CALL_PMPI_%d(%s", NF-2, mpicall
@ -130,11 +167,11 @@ cat <<End-of-File >$tmp.awk
printf para[i-2]
}
}
print", result, 0, was_recorded, &time);"
print", result, was_recorded, &time);"
print ""
print " time = vt_pform_wtime();"
print " vt_exit(&time);"
print " vt_exit(VT_CURRENT_THREAD, &time);"
print ""
print " MPI_TRACE_ON();"
print " }"
@ -150,7 +187,7 @@ cat <<End-of-File >$tmp.awk
printf para[i-2]
}
}
print", result, 0, 0, NULL);"
print", result, 0, NULL);"
print " }"
print ""
@ -158,17 +195,8 @@ cat <<End-of-File >$tmp.awk
print "}"
print ""
if (index(mpicall,"MPI_Win_test") != 0) {
printf "#endif /* HAVE_PMPI_WIN_TEST */\n\n"
}
if (index(mpicall,"MPI_Win_lock") != 0) {
printf "#endif /* HAVE_PMPI_WIN_LOCK */\n\n"
}
if (index(mpicall,"MPI_Win_unlock") != 0) {
printf "#endif /* HAVE_PMPI_WIN_UNLOCK */\n\n"
}
if (index(mpicall,"MPI_Register_datarep") != 0) {
printf "#endif /* HAVE_MPI_REGISTER_DATAREP */\n\n"
if (optional) {
printf "#endif\n\n"
}
}
End-of-File

61
ompi/contrib/vt/vt/config/mpigen/mk_fortran_wrapper.sh.in
Просмотреть файл

@ -18,12 +18,15 @@ export TYPE_CONVERT=@VT_MPIGEN_HAVE_FC_CONV_TYPE@
export WIN_CONVERT=@VT_MPIGEN_HAVE_FC_CONV_WIN@
export MPI2CONST_CONVERT=@VT_MPIGEN_HAVE_FC_CONV_MPI2CONST@
have_mpi2=0 #@VT_MPIGEN_HAVE_MPI2@
have_mpi2_thread=@VT_MPIGEN_HAVE_MPI2_THREAD@
have_mpi2_1sided=@VT_MPIGEN_HAVE_MPI2_1SIDED@
have_mpi2_extcoll=@VT_MPIGEN_HAVE_MPI2_EXTCOLL@
have_mpi2_file=@VT_MPIGEN_HAVE_MPI2_IO@
have_mpi2_proc=0 #@VT_MPIGEN_HAVE_MPI2_PROC@
have_mpi2_proc=0 #@VT_MPIGEN_HAVE_MPI2_PROC@
if [ $have_mpi2_thread -o $have_mpi2_1sided -o $have_mpi2_extcoll -o $have_mpi2_proc ] ; then
have_mpi2=1
fi
mpi2_src1=""; if [ $have_mpi2 = 1 ] ; then mpi2_src1="mpi2_standard.h"; fi
mpi2_src2=""; if [ $have_mpi2_thread = 1 ] ; then mpi2_src2="mpi2_thread.h"; fi
mpi2_src3=""; if [ $have_mpi2_1sided = 1 ] ; then mpi2_src3="mpi2_1sided.h"; fi
@ -60,7 +63,7 @@ cat <<End-of-File >$tmp.c
* VampirTrace
* http://www.tu-dresden.de/zih/vampirtrace
*
* Copyright (c) 2005-2010, ZIH, TU Dresden, Federal Republic of Germany
* Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
*
* Copyright (c) 1998-2005, Forschungszentrum Juelich, Juelich Supercomputing
* Centre, Federal Republic of Germany
@ -92,17 +95,51 @@ cat <<End-of-File >$tmp.awk
next
}
optional=0
if (index(mpicall,"MPI_Add_error_class") != 0) {
printf "#if defined(HAVE_MPI_ADD_ERROR_CLASS) && HAVE_MPI_ADD_ERROR_CLASS\n\n"
optional=1
}
if (index(mpicall,"MPI_Add_error_code") != 0) {
printf "#if defined(HAVE_MPI_ADD_ERROR_CODE) && HAVE_MPI_ADD_ERROR_CODE\n\n"
optional=1
}
if (index(mpicall,"MPI_Add_error_string") != 0) {
printf "#if defined(HAVE_MPI_ADD_ERROR_STRING) && HAVE_MPI_ADD_ERROR_STRING\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_create_f90_complex") != 0) {
printf "#if defined(HAVE_MPI_TYPE_CREATE_F90_COMPLEX) && HAVE_MPI_TYPE_CREATE_F90_COMPLEX\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_create_f90_integer") != 0) {
printf "#if defined(HAVE_MPI_TYPE_CREATE_F90_INTEGER) && HAVE_MPI_TYPE_CREATE_F90_INTEGER\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_create_f90_real") != 0) {
printf "#if defined(HAVE_MPI_TYPE_CREATE_F90_REAL) && HAVE_MPI_TYPE_CREATE_F90_REAL\n\n"
optional=1
}
if (index(mpicall,"MPI_Type_match_size") != 0) {
printf "#if defined(HAVE_MPI_TYPE_MATCH_SIZE) && HAVE_MPI_TYPE_MATCH_SIZE\n\n"
optional=1
}
if (index(mpicall,"MPI_Win_test") != 0) {
printf "#if defined(HAVE_PMPI_WIN_TEST) && HAVE_PMPI_WIN_TEST\n\n"
optional=1
}
if (index(mpicall,"MPI_Win_lock") != 0) {
printf "#if defined(HAVE_PMPI_WIN_LOCK) && HAVE_PMPI_WIN_LOCK\n\n"
optional=1
}
if (index(mpicall,"MPI_Win_unlock") != 0) {
printf "#if defined(HAVE_PMPI_WIN_UNLOCK) && HAVE_PMPI_WIN_UNLOCK\n\n"
optional=1
}
if (index(mpicall,"MPI_Register_datarep") != 0) {
printf "#if defined(HAVE_MPI_REGISTER_DATAREP) && HAVE_MPI_REGISTER_DATAREP\n\n"
optional=1
}
stringcnt=0
@ -165,6 +202,7 @@ cat <<End-of-File >$tmp.awk
print_convert_function(type[i-2],para[i-2],0)
print ""
print " VT_UNIMCI_SET_BINDING_LANGUAGE_FORTRAN();"
printf " *ierr = %s(", mpicall
for (i=3; i<=NF; i++) {
if (i > 3) printf ", "
@ -172,7 +210,9 @@ cat <<End-of-File >$tmp.awk
# otherwise dereference the parameter
printf "%s", get_converted_name(para[i-2],type[i-2])
}
print ");\n"
print ");"
print " VT_UNIMCI_SET_BINDING_LANGUAGE_C();"
print ""
# finaly do the handle back conversion if possible/necessary
for (i=3; i<=NF; i++)
@ -221,17 +261,8 @@ cat <<End-of-File >$tmp.awk
printf "))\n\n"
}
if (index(mpicall,"MPI_Win_test") != 0) {
printf "#endif /* HAVE_PMPI_WIN_TEST */\n\n"
}
if (index(mpicall,"MPI_Win_lock") != 0) {
printf "#endif /* HAVE_PMPI_WIN_LOCK */\n\n"
}
if (index(mpicall,"MPI_Win_unlock") != 0) {
printf "#endif /* HAVE_PMPI_WIN_UNLOCK */\n\n"
}
if (index(mpicall,"MPI_Register_datarep") != 0) {
printf "#endif /* HAVE_MPI_REGISTER_DATAREP */\n\n"
if (optional) {
printf "#endif\n\n"
}
}
@ -293,7 +324,7 @@ function print_convert_function(type,para,decl) {
pointer="*"
if (type == "char*") {
if (decl) printf" char* %sC;\n", para
if (decl) printf" char* %sC = NULL;\n", para
else printf" vt_string_f2c(%s, %s_len, &%sC);\n", para, para, para
} else if (index(type,"MPI_Aint") > 0) {
if (decl) printf" MPI_Aint %sC;\n",para

12
ompi/contrib/vt/vt/config/mpigen/mk_registry.sh.in
Просмотреть файл

@ -6,12 +6,14 @@
export SRCDIR=@top_vt_srcdir@/config/mpigen
have_mpi2=0 #@VT_MPIGEN_HAVE_MPI2@
have_mpi2_thread=@VT_MPIGEN_HAVE_MPI2_THREAD@
have_mpi2_1sided=@VT_MPIGEN_HAVE_MPI2_1SIDED@
have_mpi2_extcoll=@VT_MPIGEN_HAVE_MPI2_EXTCOLL@
have_mpi2_file=@VT_MPIGEN_HAVE_MPI2_IO@
have_mpi2_proc=0 #@VT_MPIGEN_HAVE_MPI2_PROC@
if [ $have_mpi2_thread -o $have_mpi2_1sided -o $have_mpi2_extcoll -o $have_mpi2_proc ] ; then
have_mpi2=1
fi
mpi2_src1=""; if [ $have_mpi2 = 1 ] ; then mpi2_src1="mpi2_standard.h"; fi
mpi2_src2=""; if [ $have_mpi2_thread = 1 ] ; then mpi2_src2="mpi2_thread.h"; fi
mpi2_src3=""; if [ $have_mpi2_1sided = 1 ] ; then mpi2_src3="mpi2_1sided.h"; fi
@ -27,7 +29,7 @@ trap "rm -f $tmp.*; exit" 0 1 2 3 15
rm -f $tmp.tmp $outprefix.c $outprefix.h
for s in $src; do
if [ ! -f $SRCDIR/$s ] ; then
echo "$0: error: $SRCDIR/$s not found!"
echo "$0: error: $SRCDIR/$s not found!"
exit 1
fi
@ -48,7 +50,7 @@ cat <<End-of-File >$tmp.h
* VampirTrace
* http://www.tu-dresden.de/zih/vampirtrace
*
* Copyright (c) 2005-2010, ZIH, TU Dresden, Federal Republic of Germany
* Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
*
* Copyright (c) 1998-2005, Forschungszentrum Juelich, Juelich Supercomputing
* Centre, Federal Republic of Germany
@ -97,7 +99,7 @@ cat <<End-of-File >$tmp.c
* VampirTrace
* http://www.tu-dresden.de/zih/vampirtrace
*
* Copyright (c) 2005-2010, ZIH, TU Dresden, Federal Republic of Germany
* Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
*
* Copyright (c) 1998-2005, Forschungszentrum Juelich, Juelich Supercomputing
* Centre, Federal Republic of Germany
@ -139,7 +141,7 @@ cat <<End-of-File >$tmp.awk
type="VT_MPI_FUNCTION"
printf" vt_mpi_regid[VT__%s] =\n", toupper(mpicall)
printf" vt_def_region(\\"%s\\", mpi_fid, VT_NO_LNO, VT_NO_LNO, NULL, %s);\n",
printf" vt_def_region(VT_CURRENT_THREAD, \\"%s\\", mpi_fid, VT_NO_LNO, VT_NO_LNO, NULL, %s);\n",
mpicall, type
}
End-of-File

5
ompi/contrib/vt/vt/config/mpigen/mpi2_file.h
Просмотреть файл

@ -35,10 +35,6 @@
*
**/
VT_MPI_INT MPI_File_call_errhandler(MPI_File fh, VT_MPI_INT errorcode);
VT_MPI_INT MPI_File_create_errhandler(MPI_File_errhandler_fn* function_CLASS_SINGLE_IN, MPI_Errhandler* errhandler_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_File_get_errhandler(MPI_File file, MPI_Errhandler* errhandler_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler);
VT_MPI_INT MPI_File_open(MPI_Comm comm, char* filename_CLASS_SINGLE_IN, VT_MPI_INT amode, MPI_Info info, MPI_File* fh_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_File_close(MPI_File* fh_CLASS_SINGLE_IO);
VT_MPI_INT MPI_File_delete(char* filename_CLASS_SINGLE_IN, MPI_Info info);
@ -90,3 +86,4 @@ VT_MPI_INT MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint
VT_MPI_INT MPI_File_set_atomicity(MPI_File fh, VT_MPI_INT flag);
VT_MPI_INT MPI_File_get_atomicity(MPI_File fh, VT_MPI_INT* flag);
VT_MPI_INT MPI_File_sync(MPI_File fh);
VT_MPI_INT MPI_Register_datarep(char* datarep_CLASS_SINGLE_IN, MPI_Datarep_conversion_function* read_conversion_fn, MPI_Datarep_conversion_function* write_conversion_fn, MPI_Datarep_extent_function* dtype_file_extent_fn, void* extra_state);

10
ompi/contrib/vt/vt/config/mpigen/mpi2_standard.h
Просмотреть файл

@ -40,6 +40,10 @@ VT_MPI_INT MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void* baseptr);
VT_MPI_INT MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn* function, MPI_Errhandler* errhandler_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler* errhandler_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler);
VT_MPI_INT MPI_File_call_errhandler(MPI_File fh, VT_MPI_INT errorcode);
VT_MPI_INT MPI_File_create_errhandler(MPI_File_errhandler_fn* function_CLASS_SINGLE_IN, MPI_Errhandler* errhandler_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_File_get_errhandler(MPI_File file, MPI_Errhandler* errhandler_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler);
VT_MPI_INT MPI_Finalized(VT_MPI_INT* flag);
VT_MPI_INT MPI_Free_mem(void* base);
VT_MPI_INT MPI_Get_address(void* location, MPI_Aint* address_CLASS_SINGLE_OUT);
@ -103,3 +107,9 @@ VT_MPI_INT MPI_Win_get_attr(MPI_Win win, VT_MPI_INT win_keyval, void* attribute_
VT_MPI_INT MPI_Win_get_name(MPI_Win win, char* win_name_CLASS_SINGLE_OUT, VT_MPI_INT* resultlen);
VT_MPI_INT MPI_Win_set_attr(MPI_Win win, VT_MPI_INT win_keyval, void* attribute_val);
VT_MPI_INT MPI_Win_set_name(MPI_Win win, char* win_name_CLASS_SINGLE_IN);
/* Language Bindings */
VT_MPI_INT MPI_Type_create_f90_complex(VT_MPI_INT p, VT_MPI_INT r, MPI_Datatype* newtype_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_Type_create_f90_integer(VT_MPI_INT r, MPI_Datatype* newtype_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_Type_create_f90_real(VT_MPI_INT p, VT_MPI_INT r, MPI_Datatype* newtype_CLASS_SINGLE_OUT);
VT_MPI_INT MPI_Type_match_size(VT_MPI_INT typeclass, VT_MPI_INT size, MPI_Datatype* type_CLASS_SINGLE_OUT);

5
ompi/contrib/vt/vt/config_bottom.h
Просмотреть файл

@ -29,6 +29,11 @@
# define strdup vt_strdup
#endif /* HAVE_STRDUP */
#if !(defined(HAVE_MEMMOVE) && HAVE_MEMMOVE)
# undef memmove
# define memmove vt_memmove
#endif /* HAVE_MEMMOVE */
#if defined(HAVE_FNMATCH_H) && HAVE_FNMATCH_H
# include <fnmatch.h>
#else /* HAVE_FNMATCH_H */

136
ompi/contrib/vt/vt/configure.in
Просмотреть файл

@ -28,6 +28,7 @@ ACVT_CONF_TITLE([Initialization])
# Check for platform
ACVT_PLATFORM
AM_CONDITIONAL(AMMACOS, test "$PLATFORM" = "macos")
# Get configuration options
ACVT_CONF_OPTIONS
@ -113,18 +114,26 @@ AM_CONDITIONAL(AMBUILDBINARIES, test x"$enable_binaries" = "xyes")
# Declare additional variables
AC_ARG_VAR(AR, [archiver command])
AC_ARG_VAR(NM, [command to list symbols from object files])
AC_ARG_VAR(JAVA, [Java application launcher command])
# Check for programs
#AC_PROG_AR
AC_CHECK_PROGS(AR, ar, AR=ar)
AC_CHECK_PROGS(AR, ar, ar)
AC_PROG_LN_S
AC_PROG_AWK
AC_CHECK_PROG(JAVA, java, java)
ACVT_CONF_TITLE([Header files, types, and functions])
# Check for header files
AC_HEADER_STDC
AC_CHECK_HEADERS([stdint.h inttypes.h fnmatch.h sys/param.h])
HAVE_STDINT_H=0
HAVE_INTTYPES_H=0
AS_IF([test x"$ac_cv_header_stdint_h"], [HAVE_STDINT_H=1])
AS_IF([test x"$ac_cv_header_inttypes.h"], [HAVE_INTTYPES_H=1])
AC_SUBST(HAVE_STDINT_H)
AC_SUBST(HAVE_INTTYPES_H)
# Check for datatypes
AC_TYPE_SIZE_T
@ -132,6 +141,8 @@ AC_CHECK_SIZEOF(void*, 8)
AC_CHECK_SIZEOF(int, 4)
AC_CHECK_SIZEOF(long, 8)
AC_CHECK_SIZEOF(mode_t, 4)
SIZEOF_LONG=$ac_cv_sizeof_long
AC_SUBST(SIZEOF_LONG)
# Check for library functions
#AC_REPLACE_FNMATCH
@ -143,7 +154,7 @@ AC_CHECK_DECL([va_copy],
AC_CHECK_DECL([__va_copy],
[AC_DEFINE([HAVE_UNDERSCORE_VA_COPY], [1], [Define to 1 if you have the `__va_copy' function.])],
[], [#include <stdarg.h>])
AC_CHECK_FUNCS([asprintf snprintf vasprintf vsnprintf strdup])
AC_CHECK_FUNCS([asprintf snprintf vasprintf vsnprintf strdup memmove])
# Check for libtool
ACVT_CONF_TITLE([Libtool])
@ -153,19 +164,39 @@ ACVT_CONF_TITLE([Libtool])
AS_IF([test "$PLATFORM" = "crayxt" -o "$PLATFORM" = "bgl"],
[enable_static="yes"; enable_shared="no"])
# Save prior set symbol lister command to distinguish whether it is given
# by configure option or determined by AC_PROG_LIBTOOL
given_nm=$NM
AC_PROG_LIBTOOL
# Extract extension for shared libraries from Libtool variables
SHREXT=$shrext_cmds
AC_SUBST(SHREXT)
# If building of shared libraries is desired on BlueGene/P, add '-Wl,-dy'
# to linker flags on BlueGene/P platforms to lead libtool to believe that
# dynamic linking is the default behaviour of the linker.
AS_IF([test "$PLATFORM" = "bgp" -a x"$enable_shared" = "xyes"],
[export LDFLAGS="$LDFLAGS -Wl,-dy"])
# Check for OTF
ACVT_CONF_TITLE([Open Trace Format (OTF)])
ACVT_OTF
AS_IF([test x"$use_extern_otf" = "xyes" -a x"$otf_error" = "xyes"], [exit 1])
AM_CONDITIONAL(AMEXTERNOTF, test x"$use_extern_otf" = "xyes")
# Check for BSD compatible symbol lister command
#AC_PROG_NM # already been checked by AC_PROG_LIBTOOL
AS_IF([test x"$NM" != x -a x"$given_nm" = x],
[
# Append demangle and file/line number options
case `$NM -V 2>&1` in
GNU\ nm\ *)
NM="$NM --demangle --line-numbers"
;;
esac
])
AC_DEFINE_UNQUOTED([DEFAULT_NM], ["$NM"],
[Command to list symbols from object files.])
# Check for timer
ACVT_CONF_TITLE([Timer])
ACVT_TIMER
# Check for compiler instrumentation
ACVT_CONF_TITLE([Compiler instrumentation])
@ -173,12 +204,12 @@ ACVT_COMPINST
AS_IF([test x"$force_compinst" = "xyes" -a x"$compinst_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_compinst" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AM_CONDITIONAL(AMHAVECOMPINST, test x"$compinst_type" != x)
AM_CONDITIONAL(AMHAVECOMPINST, test x"$have_compinst" = "xyes")
AM_CONDITIONAL(AMBUILDCOMPINST_GNU, test x"$compinst_type" = "xgnu" -o x"$compinst_type" = "xpgi9")
AM_CONDITIONAL(AMBUILDCOMPINST_PGI, test x"$compinst_type" = "xpgi")
AM_CONDITIONAL(AMBUILDCOMPINST_PHAT, test x"$compinst_type" = "xsun")
AM_CONDITIONAL(AMBUILDCOMPINST_XL, test x"$compinst_type" = "xxl")
AM_CONDITIONAL(AMBUILDCOMPINST_FTRACE, test x"$compinst_type" = "xnec")
AM_CONDITIONAL(AMBUILDCOMPINST_FTRACE, test x"$compinst_type" = "xnecsx")
AM_CONDITIONAL(AMBUILDCOMPINST_OPENUH, test x"$compinst_type" = "xopenuh")
# Check for binary instrumentation by Dyninst
@ -191,6 +222,14 @@ AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_dyninst" = "xno"],
AM_CONDITIONAL(AMHAVEDYNINST, test x"$have_dyninst" = "xyes")
AM_CONDITIONAL(AMBUILDDYNATTLIB, test x"$build_dynattlib" = "xyes")
# Check for source conde instrumentation by TAU
ACVT_CONF_TITLE([Automatic source code instrumentation by TAU])
ACVT_TAUINST
AS_IF([test x"$force_tauinst" = "xyes" -a x"$tauinst_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_tauinst" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AM_CONDITIONAL(AMHAVETAUINST, test x"$have_tauinst" = "xyes")
# Check for MPI support
ACVT_CONF_TITLE([Message Passing Interface (MPI)])
ACVT_MPI
@ -207,23 +246,33 @@ AM_CONDITIONAL(AMBUILDMPI, test x"$have_mpi" = "xyes")
AM_CONDITIONAL(AMBUILDFMPIWRAPLIB, test x"$build_fmpiwraplib" = "xyes")
AS_IF([test x"$have_mpi" = "xyes"],
[
# Check for enhanced time synchronization support
ACVT_CONF_SUBTITLE([Enhanced time synchronization])
ACVT_ETIMESYNC
AS_IF([test x"$force_etimesync" = "xyes" -a x"$etimesync_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_etimesync" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
# Check for UniMCI support
ACVT_CONF_SUBTITLE([Universal MPI Correctness Interface (UniMCI)])
ACVT_UNIMCI
AS_IF([test x"$force_unimci" = "xyes" -a x"$unimci_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_unimci" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AM_CONDITIONAL(AMHAVEMPI2CONST, test x"$have_mpi2_const" = "xyes")
AM_CONDITIONAL(AMBUILDFMPIWRAPLIB, test x"$build_fmpiwraplib" = "xyes")
# Check for enhanced time synchronization support
ACVT_CONF_SUBTITLE([Enhanced time synchronization])
ACVT_ETIMESYNC
AS_IF([test x"$force_etimesync" = "xyes" -a x"$etimesync_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_etimesync" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
# Check for MPI trace unification library
ACVT_CONF_SUBTITLE([MPI trace unification library])
ACVT_MPIUNIFYLIB
AS_IF([test x"$force_mpiunifylib" = "xyes" -a x"$mpiunifylib_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_mpiunifylib" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
])
AM_CONDITIONAL(AMBUILDETIMESYNC, test x"$have_etimesync" = "xyes")
AM_CONDITIONAL(AMBUILDETIMESYNC, test x"$build_etimesync" = "xyes")
AM_CONDITIONAL(AMHAVEMATH, test x"$have_math" = "xyes")
AM_CONDITIONAL(AMHAVEUNIMCI, test x"$have_unimci" = "xyes")
AM_CONDITIONAL(AMBUILDMPIUNIFYLIB, test x"$build_mpiunifylib" = "xyes")
# Check for Threads support
ACVT_CONF_TITLE([Multithreading])
@ -255,10 +304,7 @@ AS_IF([test x"$force_java" = "xyes" -a x"$java_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_java" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AM_CONDITIONAL(AMBUILDJAVA, test x"$have_java" = "xyes")
# Check for timer
ACVT_CONF_TITLE([Timer])
ACVT_TIMER
AM_CONDITIONAL(AMBUILDVTJAVA, test x"$have_java" = "xyes" -a x"$JAVA" != x)
# Check for hardware performace counter support
ACVT_CONF_TITLE([Hardware performance counter])
@ -279,6 +325,14 @@ AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_rusage" = "xno"],
AS_IF([test x"$force_rusage" = "xyes" -a x"$rusage_error" = "xyes"], [exit 1])
AM_CONDITIONAL(AMHAVERUSAGE, test x"$have_rusage" = "xyes")
# Check for plugin counter support
ACVT_CONF_TITLE([Plugin Counter support])
ACVT_PLUGINCNTR
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_plugin_cntr" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AS_IF([test x"$force_plugin_cntr" = "xyes" -a x"plugin_cntr_error" = "xyes"], [exit 1])
AM_CONDITIONAL(AMHAVEPLUGINCNTR, test x"$have_plugin_cntr" = "xyes")
# Check for memory tracing support
ACVT_CONF_TITLE([GLIBC's memory allocation tracing])
ACVT_MEMHOOKS
@ -307,6 +361,10 @@ AM_CONDITIONAL(AMHAVEDL, test x"$have_dl" = "xyes")
AM_CONDITIONAL(AMBUILDLIBCWRAP, test x"$have_libcwrap" = "xyes")
AM_CONDITIONAL(AMHAVEFORK, test x"$have_libcwrap" = "xyes" -a x"$have_fork" = "xyes")
AM_CONDITIONAL(AMBUILDIOWRAP, test x"$have_iowrap" = "xyes")
AM_CONDITIONAL(AMBUILDCUDAWRAP, test x"$have_cudawrap" = "xyes")
AM_CONDITIONAL(AMBUILDCUDARTWRAP, test x"$have_cudartwrap" = "xyes")
AM_CONDITIONAL(AMBUILDCUPTI, test x"$have_cupti" = "xyes")
AM_CONDITIONAL(AMBUILDVTNVCC, test x"$have_cudartwrap" = "xyes" -a x"$NVCC" != x)
# Check path for node-local temporary directory
ACVT_LTMPDIR
@ -314,11 +372,34 @@ ACVT_LTMPDIR
# Setup compiler wrappers
ACVT_COMPWRAP
# Check for OTF
ACVT_CONF_TITLE([Open Trace Format (OTF)])
ACVT_OTF
AS_IF([test x"$use_extern_otf" = "xyes" -a x"$otf_error" = "xyes"], [exit 1])
AM_CONDITIONAL(AMEXTERNOTF, test x"$use_extern_otf" = "xyes")
# Check for capabilities of vtsetup
ACVT_CONF_TITLE([VTSetup])
ACVT_SETUP
AS_IF([test x"$force_vtsetup" = "xyes" -a x"$vtsetup_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_vtsetup" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AM_CONDITIONAL(AMBUILDVTSETUP, test x"$build_vtsetup" = "xyes")
# Check for capabilities of vtrun
ACVT_CONF_TITLE([VTRun])
ACVT_RUN
AS_IF([test x"$force_vtrun" = "xyes" -a x"$vtrun_error" = "xyes"], [exit 1])
AS_IF([test x"$enable_config_titles" = "xyes" -a x"$check_vtrun" = "xno"],
[AC_MSG_NOTICE([disabled via command line switch])])
AM_CONDITIONAL(AMBUILDVTRUN, test x"$build_vtrun" = "xyes")
# Output files
AC_CONFIG_FILES([Makefile
extlib/Makefile
util/Makefile
util/installdirs_conf.h
extlib/Makefile
rfg/Makefile
vtlib/Makefile
tools/Makefile
tools/opari/Makefile
@ -328,10 +409,17 @@ AC_CONFIG_FILES([Makefile
tools/vtdyn/Makefile
tools/vtdyn/dynattlib/Makefile
tools/vtfilter/Makefile
tools/vtfilter/mpi/Makefile
tools/vtjava/Makefile
tools/vtjava/vtjava
tools/vtlibwrapgen/Makefile
tools/vtlibwrapgen/vt_libwrapgen_defs.h
tools/vtrun/Makefile
tools/vtrun/vtrun
tools/vtsetup/Makefile
tools/vtsetup/vtsetup
tools/vtsetup/vtsetup-data.xml
tools/vtsetup/doc/Makefile
tools/vtunify/Makefile
tools/vtunify/mpi/Makefile
tools/vtwrapper/Makefile
@ -339,8 +427,12 @@ AC_CONFIG_FILES([Makefile
tools/vtwrapper/vtc++-wrapper-data.txt
tools/vtwrapper/vtf77-wrapper-data.txt
tools/vtwrapper/vtf90-wrapper-data.txt
tools/vtwrapper/vtnvcc-wrapper-data.txt
include/Makefile
include/vt_inttypes.h
doc/Makefile
etc/Makefile
etc/vt-setup-config.xml
])
# Add MPI wrapper generator scripts to output files

2665
ompi/contrib/vt/vt/doc/UserManual.html
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

Двоичные данные
ompi/contrib/vt/vt/doc/UserManual.pdf
Просмотреть файл

Двоичный файл не отображается.

7
ompi/contrib/vt/vt/etc/Makefile.am
Просмотреть файл

@ -1,8 +1,11 @@
vtsysconf_DATA = \
vt-java-default-filter.spec
vt-java-default-filter.spec \
vt-setup-config.dtd \
vt-setup-config.xml
vtsysconfdir = $(sysconfdir)
EXTRA_DIST = \
$(vtsysconf_DATA)
vt-java-default-filter.spec \
vt-setup-config.dtd

220
ompi/contrib/vt/vt/etc/vt-setup-config.dtd Обычный файл
Просмотреть файл

@ -0,0 +1,220 @@
<!--
*** VampirTrace
*** http://www.tu-dresden.de/zih/vampirtrace
***
*** Copyright (c) 2005-2011, ZIH, TU Dresden, Federal Republic of Germany
***
*** Copyright (c) 1998-2005, Forschungszentrum Juelich GmbH, Federal
*** Republic of Germany
***
*** See the file COPYRIGHT in the package base directory for details
*
* DTD for VampirTrace environmental descriptions.
*
*
* Authors: Mathias Korepkat
* Version: 1.0
*
* ChangeLog:
* 12.07.2010: Version 1.0
-->
<!--Root node for standard group specification.
"vtversion": Version of VampirTrace.
"vtconfigversion": Version of the configuration specification format.
-->
<!ELEMENT vtconfig (config*, standardGroups,symbolfilter)>
<!ATTLIST vtconfig
vtconfigversion CDATA #REQUIRED
vtversion CDATA #REQUIRED
>
<!-- Specification for attributes given to vtsetup.
"attr": name of the attribute
-->
<!ELEMENT config (#PCDATA)>
<!ATTLIST config
attr CDATA #REQUIRED
>
<!--Specification for standard symbols in vampirTrace
-->
<!ELEMENT standardGroups (group*)>
<!--Specification for standard symbols in vampirTrace
"identifier": Id used to refer to this group and name of the group shown in vtLaunch
-->
<!ELEMENT group (symbol*)>
<!ATTLIST group
identifier CDATA #REQUIRED
>
<!-- Name of a region that belongs to the group. -->
<!ELEMENT symbol (#PCDATA)>
<!ATTLIST symbol
vtDef CDATA #REQUIRED
>
<!--Specification for standard symbols in vampirTrace
-->
<!ELEMENT symbolfilter (filter*)>
<!-- Specification for Symbols that should be filtered.
"caseSensetiv": 0 for no case sensitive matching, 1 for case sensitive matching
-->
<!ELEMENT filter (pattern*)>
<!ATTLIST filter
caseSensitive CDATA #REQUIRED
>
<!-- pattern that describes the filter rules
-->
<!ELEMENT pattern (#PCDATA)>
<!--
Summary of regular-expression constructs
Construct Matches
Characters:
x The character x
\\ The backslash character
\0n The character with octal value 0n (0 <= n <= 7)
\0nn The character with octal value 0nn (0 <= n <= 7)
\0mnn The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh The character with hexadecimal value 0xhh
\uhhhh The character with hexadecimal value 0xhhhh
\t The tab character ('\u0009')
\n The newline (line feed) character ('\u000A')
\r The carriage-return character ('\u000D')
\f The form-feed character ('\u000C')
\a The alert (bell) character ('\u0007')
\e The escape character ('\u001B')
\cx The control character corresponding to x
Character classes:
[abc] a, b, or c (simple class)
[^abc] Any character except a, b, or c (negation)
[a-zA-Z] a through z or A through Z, inclusive (range)
[a-d[m-p]] a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]] d, e, or f (intersection)
[a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]] a through z, and not m through p: [a-lq-z](subtraction)
Predefined character classes:
. Any character (may or may not match line terminators)
\d A digit: [0-9]
\D A non-digit: [^0-9]
\s A whitespace character: [ \t\n\x0B\f\r]
\S A non-whitespace character: [^\s]
\w A word character: [a-zA-Z_0-9]
\W A non-word character: [^\w]
POSIX character classes (US-ASCII only):
\p{Lower} A lower-case alphabetic character: [a-z]
\p{Upper} An upper-case alphabetic character:[A-Z]
\p{ASCII} All ASCII:[\x00-\x7F]
\p{Alpha} An alphabetic character:[\p{Lower}\p{Upper}]
\p{Digit} A decimal digit: [0-9]
\p{Alnum} An alphanumeric character:[\p{Alpha}\p{Digit}]
\p{Punct} Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} A visible character: [\p{Alnum}\p{Punct}]
\p{Print} A printable character: [\p{Graph}]
\p{Blank} A space or a tab: [ \t]
\p{Cntrl} A control character: [\x00-\x1F\x7F]
\p{XDigit} A hexadecimal digit: [0-9a-fA-F]
\p{Space} A whitespace character: [ \t\n\x0B\f\r]
Classes for Unicode blocks and categories:
\p{InGreek} A character in the Greek block (simple block)
\p{Lu} An uppercase letter (simple category)
\p{Sc} A currency symbol
\P{InGreek} Any character except one in the Greek block (negation)
[\p{L}&&[^\p{Lu}]] Any letter except an uppercase letter (subtraction)
Boundary matchers:
^ The beginning of a line
$ The end of a line
\b A word boundary
\B A non-word boundary
\A The beginning of the input
\G The end of the previous match
\Z The end of the input but for the final terminator, if any
\z The end of the input
Greedy quantifiers:
X? X, once or not at all
X* X, zero or more times
X+ X, one or more times
X{n} X, exactly n times
X{n,} X, at least n times
X{n,m} X, at least n but not more than m times
Reluctant quantifiers:
X?? X, once or not at all
X*? X, zero or more times
X+? X, one or more times
X{n}? X, exactly n times
X{n,}? X, at least n times
X{n,m}? X, at least n but not more than m times
Possessive quantifiers:
X?+ X, once or not at all
X*+ X, zero or more times
X++ X, one or more times
X{n}+ X, exactly n times
X{n,}+ X, at least n times
X{n,m}+ X, at least n but not more than m times
Logical operators:
XY X followed by Y
X|Y Either X or Y
(X) X, as a capturing group
Back references:
\n Whatever the nth capturing group matched
Quotation:
\ Nothing, but quotes the following character
\Q Nothing, but quotes all characters until \E
\E Nothing, but ends quoting started by \Q
Special constructs (non-capturing):
(?:X) X, as a non-capturing group
(?idmsux-idmsux) Nothing, but turns match flags on - off
(?idmsux-idmsux:X) X, as a non-capturing group with the given flags on - off
(?=X) X, via zero-width positive lookahead
(?!X) X, via zero-width negative lookahead
(?<=X) X, via zero-width positive lookbehind
(?<!X) X, via zero-width negative lookbehind
(?>X) X, as an independent, non-capturing group
-->

747
ompi/contrib/vt/vt/etc/vt-setup-config.xml.in Обычный файл
Просмотреть файл

@ -0,0 +1,747 @@
<vtconfig vtconfigversion="1.0" vtversion="5.10">
<config attr="nm">@VT_SETUP_NM@</config>
<standardGroups>
<group identifier="MEM">
<symbol vtDef="1">malloc</symbol>
<symbol vtDef="1">realloc</symbol>
<symbol vtDef="1">free</symbol>
</group>
<group identifier="Pthread">
<symbol vtDef="1">pthread_create</symbol>
<symbol vtDef="1">pthread_join</symbol>
<symbol vtDef="1">pthread_exit</symbol>
<symbol vtDef="1">pthread_once</symbol>
<symbol vtDef="1">pthread_self</symbol>
<symbol vtDef="1">pthread_equal</symbol>
<symbol vtDef="1">pthread_detach</symbol>
<symbol vtDef="1">pthread_key_create</symbol>
<symbol vtDef="1">pthread_key_delete</symbol>
<symbol vtDef="1">pthread_getspecific</symbol>
<symbol vtDef="1">pthread_setspecific</symbol>
<symbol vtDef="1">pthread_cancel</symbol>
<symbol vtDef="1">pthread_setcancelstate</symbol>
<symbol vtDef="1">pthread_testcancel</symbol>
<symbol vtDef="1">pthread_getschedparam</symbol>
<symbol vtDef="1">pthread_setschedparam</symbol>
<symbol vtDef="1">pthread_attr_init</symbol>
<symbol vtDef="1">pthread_attr_destroy</symbol>
<symbol vtDef="1">pthread_attr_setdetachstate</symbol>
<symbol vtDef="1">pthread_attr_getdetachstate</symbol>
<symbol vtDef="1">pthread_attr_getstacksize</symbol>
<symbol vtDef="1">pthread_attr_setstacksize</symbol>
<symbol vtDef="1">pthread_attr_getschedparam</symbol>
<symbol vtDef="1">pthread_attr_setschedparam</symbol>
<symbol vtDef="1">pthread_attr_getschedpolicy</symbol>
<symbol vtDef="1">pthread_attr_setschedpolicy</symbol>
<symbol vtDef="1">pthread_attr_setinheritsched</symbol>
<symbol vtDef="1">pthread_attr_getinheritsched</symbol>
<symbol vtDef="1">pthread_attr_setscope</symbol>
<symbol vtDef="1">pthread_attr_getscope</symbol>
<symbol vtDef="1">pthread_mutex_init</symbol>
<symbol vtDef="1">pthread_mutex_destroy</symbol>
<symbol vtDef="1">pthread_mutex_lock</symbol>
<symbol vtDef="1">pthread_mutex_unlock</symbol>
<symbol vtDef="1">pthread_mutex_trylock</symbol>
<symbol vtDef="1">pthread_mutexattr_init</symbol>
<symbol vtDef="1">pthread_mutexattr_destroy</symbol>
<symbol vtDef="1">pthread_mutexattr_getpshared</symbol>
<symbol vtDef="1">pthread_mutexattr_setpshared</symbol>
<symbol vtDef="1">pthread_cond_init</symbol>
<symbol vtDef="1">pthread_cond_destroy</symbol>
<symbol vtDef="1">pthread_cond_signal</symbol>
<symbol vtDef="1">pthread_cond_broadcast</symbol>
<symbol vtDef="1">pthread_cond_wait</symbol>
<symbol vtDef="1">pthread_cond_timedwait</symbol>
<symbol vtDef="1">pthread_condattr_init</symbol>
<symbol vtDef="1">pthread_condattr_destroy</symbol>
<symbol vtDef="1">pthread_condattr_getpshared</symbol>
<symbol vtDef="1">pthread_condattr_setpshared</symbol>
</group>
<group identifier="LIBC-I/O">
<symbol vtDef="1">open</symbol>
<symbol vtDef="1">open64</symbol>
<symbol vtDef="1">creat</symbol>
<symbol vtDef="1">creat64</symbol>
<symbol vtDef="1">close</symbol>
<symbol vtDef="1">dup</symbol>
<symbol vtDef="1">dup2</symbol>
<symbol vtDef="1">lseek</symbol>
<symbol vtDef="1">lseek64</symbol>
<symbol vtDef="1">read</symbol>
<symbol vtDef="1">write</symbol>
<symbol vtDef="1">readv</symbol>
<symbol vtDef="1">writev</symbol>
<symbol vtDef="1">pread</symbol>
<symbol vtDef="1">pwrite</symbol>
<symbol vtDef="1">pread64</symbol>
<symbol vtDef="1">pwrite64</symbol>
<symbol vtDef="1">fdopen</symbol>
<symbol vtDef="1">fopen</symbol>
<symbol vtDef="1">fopen64</symbol>
<symbol vtDef="1">fclose</symbol>
<symbol vtDef="1">fseek</symbol>
<symbol vtDef="1">fseeko</symbol>
<symbol vtDef="1">fseeko64</symbol>
<symbol vtDef="1">rewind</symbol>
<symbol vtDef="1">fsetpos</symbol>
<symbol vtDef="1">fsetpos64</symbol>
<symbol vtDef="1">fread</symbol>
<symbol vtDef="1">fwrite</symbol>
<symbol vtDef="1">fgetc</symbol>
<symbol vtDef="1">getc</symbol>
<symbol vtDef="1">fgets</symbol>
<symbol vtDef="1">gets</symbol>
<symbol vtDef="1">fputc</symbol>
<symbol vtDef="1">putc</symbol>
<symbol vtDef="1">fputs</symbol>
<symbol vtDef="1">puts</symbol>
<symbol vtDef="1">fscanf</symbol>
<symbol vtDef="1">fprintf</symbol>
<symbol vtDef="1">unlink</symbol>
<symbol vtDef="1">flockfile</symbol>
<symbol vtDef="1">ftrylockfile</symbol>
<symbol vtDef="1">funlockfile</symbol>
<symbol vtDef="1">lockf</symbol>
<symbol vtDef="1">fcntl</symbol>
<symbol vtDef="1">sync</symbol>
<symbol vtDef="1">fflush</symbol>
<symbol vtDef="1">fsync</symbol>
<symbol vtDef="1">fdatasync</symbol>
</group>
<group identifier="OMP">
<symbol vtDef="1">omp_destroy_lock</symbol>
<symbol vtDef="1">omp_destroy_nest_lock</symbol>
<symbol vtDef="1">omp_get_dynamic</symbol>
<symbol vtDef="1">omp_get_max_threads</symbol>
<symbol vtDef="1">omp_get_nested</symbol>
<symbol vtDef="1">omp_get_num_procs</symbol>
<symbol vtDef="1">omp_get_num_threads</symbol>
<symbol vtDef="1">omp_get_thread_num</symbol>
<symbol vtDef="1">omp_in_parallel</symbol>
<symbol vtDef="1">omp_init_lock</symbol>
<symbol vtDef="1">omp_init_nest_lock</symbol>
<symbol vtDef="1">omp_set_dynamic</symbol>
<symbol vtDef="1">omp_set_lock</symbol>
<symbol vtDef="1">omp_set_nest_lock</symbol>
<symbol vtDef="1">omp_set_nested</symbol>
<symbol vtDef="1">omp_set_num_threads</symbol>
<symbol vtDef="1">omp_test_lock</symbol>
<symbol vtDef="1">omp_test_nest_lock</symbol>
<symbol vtDef="1">omp_unset_lock</symbol>
<symbol vtDef="1">omp_unset_nest_lock</symbol>
</group>
<group identifier="CUDA_KERNEL">
</group>
<group identifier="CUDA_API">
<symbol vtDef="1">__cudaRegisterFunction</symbol>
<symbol vtDef="1">cudaGetDeviceCount</symbol>
<symbol vtDef="1">cudaGetDevice</symbol>
<symbol vtDef="1">cudaGetDeviceProperties</symbol>
<symbol vtDef="1">cudaEventCreate</symbol>
<symbol vtDef="1">cudaEventCreateWithFlags</symbol>
<symbol vtDef="1">cudaEventRecord</symbol>
<symbol vtDef="1">cudaEventSynchronize</symbol>
<symbol vtDef="1">cudaEventElapsedTime</symbol>
<symbol vtDef="1">cudaEventDestroy</symbol>
<symbol vtDef="1">cudaStreamSynchronize</symbol>
<symbol vtDef="1">cudaThreadSynchronize</symbol>
<symbol vtDef="1">cudaGetErrorString</symbol>
<symbol vtDef="1">cudaGetLastError</symbol>
<symbol vtDef="1">cudaMalloc3D</symbol>
<symbol vtDef="1">cudaMalloc3DArray</symbol>
<symbol vtDef="1">cudaMallocArray</symbol>
<symbol vtDef="1">cudaMemset3D</symbol>
<symbol vtDef="1">cudaMemcpy3D</symbol>
<symbol vtDef="1">cudaMemcpy3DAsync</symbol>
<symbol vtDef="1">cudaMalloc</symbol>
<symbol vtDef="1">cudaMallocHost</symbol>
<symbol vtDef="1">cudaMallocPitch</symbol>
<symbol vtDef="1">cudaFree</symbol>
<symbol vtDef="1">cudaFreeHost</symbol>
<symbol vtDef="1">cudaFreeArray</symbol>
<symbol vtDef="1">cudaHostAlloc</symbol>
<symbol vtDef="1">cudaHostGetDevicePointer</symbol>
<symbol vtDef="1">cudaMemcpy</symbol>
<symbol vtDef="1">cudaMemcpyToArray</symbol>
<symbol vtDef="1">cudaMemcpyFromArray</symbol>
<symbol vtDef="1">cudaMemcpyArrayToArray</symbol>
<symbol vtDef="1">cudaMemcpy2D</symbol>
<symbol vtDef="1">cudaMemcpy2DToArray</symbol>
<symbol vtDef="1">cudaMemcpy2DFromArray</symbol>
<symbol vtDef="1">cudaMemcpy2DArrayToArray</symbol>
<symbol vtDef="1">cudaMemcpyToSymbol</symbol>
<symbol vtDef="1">cudaMemcpyFromSymbol</symbol>
<symbol vtDef="1">cudaMemcpyAsync</symbol>
<symbol vtDef="1">cudaMemcpyToArrayAsync</symbol>
<symbol vtDef="1">cudaMemcpyFromArrayAsync</symbol>
<symbol vtDef="1">cudaMemcpy2DAsync</symbol>
<symbol vtDef="1">cudaMemcpy2DToArrayAsync</symbol>
<symbol vtDef="1">cudaMemcpy2DFromArrayAsync</symbol>
<symbol vtDef="1">cudaMemcpyToSymbolAsync</symbol>
<symbol vtDef="1">cudaMemcpyFromSymbolAsync</symbol>
<symbol vtDef="1">cudaMemset</symbol>
<symbol vtDef="1">cudaMemset2D</symbol>
<symbol vtDef="1">cudaGetSymbolAddress</symbol>
<symbol vtDef="1">cudaGetSymbolSize</symbol>
<symbol vtDef="1">cudaGetDeviceCount</symbol>
<symbol vtDef="1">cudaGetDeviceProperties</symbol>
<symbol vtDef="1">cudaChooseDevice</symbol>
<symbol vtDef="1">cudaSetDevice</symbol>
<symbol vtDef="1">cudaGetDevice</symbol>
<symbol vtDef="1">cudaSetValidDevices</symbol>
<symbol vtDef="1">cudaSetDeviceFlags</symbol>
<symbol vtDef="1">cudaBindTexture</symbol>
<symbol vtDef="1">cudaBindTexture2D</symbol>
<symbol vtDef="1">cudaBindTextureToArray</symbol>
<symbol vtDef="1">cudaUnbindTexture</symbol>
<symbol vtDef="1">cudaGetTextureAlignmentOffset</symbol>
<symbol vtDef="1">cudaGetTextureReference</symbol>
<symbol vtDef="1">cudaGetChannelDesc</symbol>
<symbol vtDef="1">cudaCreateChannelDesc</symbol>
<symbol vtDef="1">cudaGetLastError</symbol>
<symbol vtDef="1">cudaGetErrorString</symbol>
<symbol vtDef="1">cudaConfigureCall</symbol>
<symbol vtDef="1">cudaSetupArgument</symbol>
<symbol vtDef="1">cudaLaunch</symbol>
<symbol vtDef="1">cudaFuncGetAttributes</symbol>
<symbol vtDef="1">cudaStreamCreate</symbol>
<symbol vtDef="1">cudaStreamDestroy</symbol>
<symbol vtDef="1">cudaStreamSynchronize</symbol>
<symbol vtDef="1">cudaStreamQuery</symbol>
<symbol vtDef="1">cudaEventCreate</symbol>
<symbol vtDef="1">cudaEventCreateWithFlags</symbol>
<symbol vtDef="1">cudaEventRecord</symbol>
<symbol vtDef="1">cudaEventQuery</symbol>
<symbol vtDef="1">cudaEventSynchronize</symbol>
<symbol vtDef="1">cudaEventDestroy</symbol>
<symbol vtDef="1">cudaEventElapsedTime</symbol>
<symbol vtDef="1">cudaSetDoubleForDevice</symbol>
<symbol vtDef="1">cudaSetDoubleForHost</symbol>
<symbol vtDef="1">cudaThreadExit</symbol>
<symbol vtDef="1">cudaThreadSynchronize</symbol>
<symbol vtDef="1">cudaDriverGetVersion</symbol>
<symbol vtDef="1">cudaRuntimeGetVersion</symbol>
<symbol vtDef="1">cudaHostGetFlags</symbol>
<symbol vtDef="1">cudaMemGetInfo</symbol>
<symbol vtDef="1">cudaFuncSetCacheConfig</symbol>
<symbol vtDef="1">cudaGraphicsUnregisterResource</symbol>
<symbol vtDef="1">cudaGraphicsResourceSetMapFlags</symbol>
<symbol vtDef="1">cudaGraphicsMapResources</symbol>
<symbol vtDef="1">cudaGraphicsUnmapResources</symbol>
<symbol vtDef="1">cudaGraphicsResourceGetMappedPointer</symbol>
<symbol vtDef="1">cudaGraphicsSubResourceGetMappedArray</symbol>
<symbol vtDef="1">cudaMallocArray</symbol>
<symbol vtDef="1">cudaMalloc3DArray</symbol>
<symbol vtDef="1">cudaBindSurfaceToArray</symbol>
<symbol vtDef="1">cudaGetSurfaceAlignmentOffset</symbol>
<symbol vtDef="1">cudaGetSurfaceReference</symbol>
<symbol vtDef="1">cudaPeekAtLastError</symbol>
<symbol vtDef="1">cudaThreadSetLimit</symbol>
<symbol vtDef="1">cudaThreadGetLimit</symbol>
<symbol vtDef="1">cudaGetExportTable</symbol>
</group>
<group identifier="CUDA_IDLE">
<symbol vtDef="1">gpu_idle</symbol>
</group>
<group identifier="VT_CUDA">
<symbol vtDef="1">vtcudaCheckThread</symbol>
<symbol vtDef="1">vtcudaCreateDevice</symbol>
<symbol vtDef="1">vtcudaFlush</symbol>
</group>
<group identifier="CUDA_SYNC">
<symbol vtDef="1">vtcudaSynchronize</symbol>
</group>
<group identifier="MPI">
<symbol vtDef="1">MPI_Init</symbol>
<symbol vtDef="1">MPI_Initialized</symbol>
<symbol vtDef="1">MPI_Init_thread</symbol>
<symbol vtDef="1">MPI_Accumulate</symbol>
<symbol vtDef="1">MPI_Get</symbol>
<symbol vtDef="1">MPI_Put</symbol>
<symbol vtDef="1">MPI_Win_complete</symbol>
<symbol vtDef="1">MPI_Win_create</symbol>
<symbol vtDef="1">MPI_Win_fence</symbol>
<symbol vtDef="1">MPI_Win_free</symbol>
<symbol vtDef="1">MPI_Win_lock</symbol>
<symbol vtDef="1">MPI_Win_post</symbol>
<symbol vtDef="1">MPI_Win_start</symbol>
<symbol vtDef="1">MPI_Win_test</symbol>
<symbol vtDef="1">MPI_Win_unlock</symbol>
<symbol vtDef="1">MPI_Win_wait</symbol>
<symbol vtDef="1">MPI_Alltoallw</symbol>
<symbol vtDef="1">MPI_Exscan</symbol>
<symbol vtDef="1">MPI_File_open</symbol>
<symbol vtDef="1">MPI_File_close</symbol>
<symbol vtDef="1">MPI_File_delete</symbol>
<symbol vtDef="1">MPI_File_set_size</symbol>
<symbol vtDef="1">MPI_File_preallocate</symbol>
<symbol vtDef="1">MPI_File_get_size</symbol>
<symbol vtDef="1">MPI_File_get_group</symbol>
<symbol vtDef="1">MPI_File_get_amode</symbol>
<symbol vtDef="1">MPI_File_set_info</symbol>
<symbol vtDef="1">MPI_File_get_info</symbol>
<symbol vtDef="1">MPI_File_set_view</symbol>
<symbol vtDef="1">MPI_File_get_view</symbol>
<symbol vtDef="1">MPI_File_read_at</symbol>
<symbol vtDef="1">MPI_File_read_at_all</symbol>
<symbol vtDef="1">MPI_File_write_at</symbol>
<symbol vtDef="1">MPI_File_write_at_all</symbol>
<symbol vtDef="1">MPI_File_iread_at</symbol>
<symbol vtDef="1">MPI_File_iwrite_at</symbol>
<symbol vtDef="1">MPI_File_read</symbol>
<symbol vtDef="1">MPI_File_read_all</symbol>
<symbol vtDef="1">MPI_File_write</symbol>
<symbol vtDef="1">MPI_File_write_all</symbol>
<symbol vtDef="1">MPI_File_iread</symbol>
<symbol vtDef="1">MPI_File_iwrite</symbol>
<symbol vtDef="1">MPI_File_seek</symbol>
<symbol vtDef="1">MPI_File_get_position</symbol>
<symbol vtDef="1">MPI_File_get_byte_offset</symbol>
<symbol vtDef="1">MPI_File_read_shared</symbol>
<symbol vtDef="1">MPI_File_write_shared</symbol>
<symbol vtDef="1">MPI_File_iread_shared</symbol>
<symbol vtDef="1">MPI_File_iwrite_shared</symbol>
<symbol vtDef="1">MPI_File_read_ordered</symbol>
<symbol vtDef="1">MPI_File_write_ordered</symbol>
<symbol vtDef="1">MPI_File_seek_shared</symbol>
<symbol vtDef="1">MPI_File_get_position_shared</symbol>
<symbol vtDef="1">MPI_File_read_at_all_begin</symbol>
<symbol vtDef="1">MPI_File_read_at_all_end</symbol>
<symbol vtDef="1">MPI_File_write_at_all_begin</symbol>
<symbol vtDef="1">MPI_File_write_at_all_end</symbol>
<symbol vtDef="1">MPI_File_read_all_begin</symbol>
<symbol vtDef="1">MPI_File_read_all_end</symbol>
<symbol vtDef="1">MPI_File_write_all_begin</symbol>
<symbol vtDef="1">MPI_File_write_all_end</symbol>
<symbol vtDef="1">MPI_File_read_ordered_begin</symbol>
<symbol vtDef="1">MPI_File_read_ordered_end</symbol>
<symbol vtDef="1">MPI_File_write_ordered_begin</symbol>
<symbol vtDef="1">MPI_File_write_ordered_end</symbol>
<symbol vtDef="1">MPI_File_get_type_extent</symbol>
<symbol vtDef="1">MPI_File_set_atomicity</symbol>
<symbol vtDef="1">MPI_File_get_atomicity</symbol>
<symbol vtDef="1">MPI_File_sync</symbol>
<symbol vtDef="1">MPI_Alloc_mem</symbol>
<symbol vtDef="1">MPI_Comm_create_errhandler</symbol>
<symbol vtDef="1">MPI_Comm_get_errhandler</symbol>
<symbol vtDef="1">MPI_Comm_set_errhandler</symbol>
<symbol vtDef="1">MPI_Finalized</symbol>
<symbol vtDef="1">MPI_Free_mem</symbol>
<symbol vtDef="1">MPI_Get_address</symbol>
<symbol vtDef="1">MPI_Info_create</symbol>
<symbol vtDef="1">MPI_Info_delete</symbol>
<symbol vtDef="1">MPI_Info_dup</symbol>
<symbol vtDef="1">MPI_Info_free</symbol>
<symbol vtDef="1">MPI_Info_get</symbol>
<symbol vtDef="1">MPI_Info_get_nkeys</symbol>
<symbol vtDef="1">MPI_Info_get_nthkey</symbol>
<symbol vtDef="1">MPI_Info_get_valuelen</symbol>
<symbol vtDef="1">MPI_Info_set</symbol>
<symbol vtDef="1">MPI_Pack_external</symbol>
<symbol vtDef="1">MPI_Pack_external_size</symbol>
<symbol vtDef="1">MPI_Request_get_status</symbol>
<symbol vtDef="1">MPI_Type_create_darray</symbol>
<symbol vtDef="1">MPI_Type_create_hindexed</symbol>
<symbol vtDef="1">MPI_Type_create_hvector</symbol>
<symbol vtDef="1">MPI_Type_create_indexed_block</symbol>
<symbol vtDef="1">MPI_Type_create_resized</symbol>
<symbol vtDef="1">MPI_Type_create_struct</symbol>
<symbol vtDef="1">MPI_Type_create_subarray</symbol>
<symbol vtDef="1">MPI_Type_get_extent</symbol>
<symbol vtDef="1">MPI_Type_get_true_extent</symbol>
<symbol vtDef="1">MPI_Unpack_external</symbol>
<symbol vtDef="1">MPI_Win_create_errhandler</symbol>
<symbol vtDef="1">MPI_Win_get_errhandler</symbol>
<symbol vtDef="1">MPI_Win_set_errhandler</symbol>
<symbol vtDef="1">MPI_File_call_errhandler</symbol>
<symbol vtDef="1">MPI_File_create_errhandler</symbol>
<symbol vtDef="1">MPI_File_get_errhandler</symbol>
<symbol vtDef="1">MPI_File_set_errhandler</symbol>
<symbol vtDef="1">MPI_Add_error_class</symbol>
<symbol vtDef="1">MPI_Add_error_code</symbol>
<symbol vtDef="1">MPI_Add_error_string</symbol>
<symbol vtDef="1">MPI_Comm_call_errhandler</symbol>
<symbol vtDef="1">MPI_Comm_create_keyval</symbol>
<symbol vtDef="1">MPI_Comm_delete_attr</symbol>
<symbol vtDef="1">MPI_Comm_free_keyval</symbol>
<symbol vtDef="1">MPI_Comm_get_attr</symbol>
<symbol vtDef="1">MPI_Comm_get_name</symbol>
<symbol vtDef="1">MPI_Comm_set_attr</symbol>
<symbol vtDef="1">MPI_Comm_set_name</symbol>
<symbol vtDef="1">MPI_Grequest_complete</symbol>
<symbol vtDef="1">MPI_Grequest_start</symbol>
<symbol vtDef="1">MPI_Is_thread_main</symbol>
<symbol vtDef="1">MPI_Query_thread</symbol>
<symbol vtDef="1">MPI_Status_set_cancelled</symbol>
<symbol vtDef="1">MPI_Status_set_elements</symbol>
<symbol vtDef="1">MPI_Type_create_keyval</symbol>
<symbol vtDef="1">MPI_Type_delete_attr</symbol>
<symbol vtDef="1">MPI_Type_dup</symbol>
<symbol vtDef="1">MPI_Type_free_keyval</symbol>
<symbol vtDef="1">MPI_Type_get_attr</symbol>
<symbol vtDef="1">MPI_Type_get_contents</symbol>
<symbol vtDef="1">MPI_Type_get_envelope</symbol>
<symbol vtDef="1">MPI_Type_get_name</symbol>
<symbol vtDef="1">MPI_Type_set_attr</symbol>
<symbol vtDef="1">MPI_Type_set_name</symbol>
<symbol vtDef="1">MPI_Win_call_errhandler</symbol>
<symbol vtDef="1">MPI_Win_create_keyval</symbol>
<symbol vtDef="1">MPI_Win_delete_attr</symbol>
<symbol vtDef="1">MPI_Win_free_keyval</symbol>
<symbol vtDef="1">MPI_Win_get_attr</symbol>
<symbol vtDef="1">MPI_Win_get_name</symbol>
<symbol vtDef="1">MPI_Win_set_attr</symbol>
<symbol vtDef="1">MPI_Win_set_name</symbol>
<symbol vtDef="1">MPI_Type_create_f90_complex</symbol>
<symbol vtDef="1">MPI_Type_create_f90_integer</symbol>
<symbol vtDef="1">MPI_Type_create_f90_real</symbol>
<symbol vtDef="1">MPI_Type_match_size</symbol>
<symbol vtDef="1">MPI_Register_datarep</symbol>
<symbol vtDef="1">MPI_Close_port</symbol>
<symbol vtDef="1">MPI_Comm_accept</symbol>
<symbol vtDef="1">MPI_Comm_connect</symbol>
<symbol vtDef="1">MPI_Comm_disconnect</symbol>
<symbol vtDef="1">MPI_Comm_get_parent</symbol>
<symbol vtDef="1">MPI_Comm_join</symbol>
<symbol vtDef="1">MPI_Comm_spawn</symbol>
<symbol vtDef="1">MPI_Comm_spawn_multiple</symbol>
<symbol vtDef="1">MPI_Lookup_name</symbol>
<symbol vtDef="1">MPI_Open_port</symbol>
<symbol vtDef="1">MPI_Publish_name</symbol>
<symbol vtDef="1">MPI_Unpublish_name</symbol>
<symbol vtDef="1">MPI_Abort</symbol>
<symbol vtDef="1">MPI_Address</symbol>
<symbol vtDef="1">MPI_Allgather</symbol>
<symbol vtDef="1">MPI_Allgatherv</symbol>
<symbol vtDef="1">MPI_Allreduce</symbol>
<symbol vtDef="1">MPI_Alltoall</symbol>
<symbol vtDef="1">MPI_Alltoallv</symbol>
<symbol vtDef="1">MPI_Attr_delete</symbol>
<symbol vtDef="1">MPI_Attr_get</symbol>
<symbol vtDef="1">MPI_Attr_put</symbol>
<symbol vtDef="1">MPI_Barrier</symbol>
<symbol vtDef="1">MPI_Bcast</symbol>
<symbol vtDef="1">MPI_Bsend</symbol>
<symbol vtDef="1">MPI_Bsend_init</symbol>
<symbol vtDef="1">MPI_Buffer_attach</symbol>
<symbol vtDef="1">MPI_Buffer_detach</symbol>
<symbol vtDef="1">MPI_Cancel</symbol>
<symbol vtDef="1">MPI_Cart_coords</symbol>
<symbol vtDef="1">MPI_Cart_create</symbol>
<symbol vtDef="1">MPI_Cart_get</symbol>
<symbol vtDef="1">MPI_Cart_map</symbol>
<symbol vtDef="1">MPI_Cart_rank</symbol>
<symbol vtDef="1">MPI_Cart_shift</symbol>
<symbol vtDef="1">MPI_Cart_sub</symbol>
<symbol vtDef="1">MPI_Cartdim_get</symbol>
<symbol vtDef="1">MPI_Comm_compare</symbol>
<symbol vtDef="1">MPI_Comm_create</symbol>
<symbol vtDef="1">MPI_Comm_dup</symbol>
<symbol vtDef="1">MPI_Comm_free</symbol>
<symbol vtDef="1">MPI_Comm_group</symbol>
<symbol vtDef="1">MPI_Comm_rank</symbol>
<symbol vtDef="1">MPI_Comm_remote_group</symbol>
<symbol vtDef="1">MPI_Comm_remote_size</symbol>
<symbol vtDef="1">MPI_Comm_size</symbol>
<symbol vtDef="1">MPI_Comm_split</symbol>
<symbol vtDef="1">MPI_Comm_test_inter</symbol>
<symbol vtDef="1">MPI_Dims_create</symbol>
<symbol vtDef="1">MPI_Errhandler_create</symbol>
<symbol vtDef="1">MPI_Errhandler_free</symbol>
<symbol vtDef="1">MPI_Errhandler_get</symbol>
<symbol vtDef="1">MPI_Errhandler_set</symbol>
<symbol vtDef="1">MPI_Error_class</symbol>
<symbol vtDef="1">MPI_Error_string</symbol>
<symbol vtDef="1">MPI_Finalize</symbol>
<symbol vtDef="1">MPI_Gather</symbol>
<symbol vtDef="1">MPI_Gatherv</symbol>
<symbol vtDef="1">MPI_Get_count</symbol>
<symbol vtDef="1">MPI_Get_elements</symbol>
<symbol vtDef="1">MPI_Get_processor_name</symbol>
<symbol vtDef="1">MPI_Get_version</symbol>
<symbol vtDef="1">MPI_Graph_create</symbol>
<symbol vtDef="1">MPI_Graph_get</symbol>
<symbol vtDef="1">MPI_Graph_map</symbol>
<symbol vtDef="1">MPI_Graph_neighbors</symbol>
<symbol vtDef="1">MPI_Graph_neighbors_count</symbol>
<symbol vtDef="1">MPI_Graphdims_get</symbol>
<symbol vtDef="1">MPI_Group_compare</symbol>
<symbol vtDef="1">MPI_Group_difference</symbol>
<symbol vtDef="1">MPI_Group_excl</symbol>
<symbol vtDef="1">MPI_Group_free</symbol>
<symbol vtDef="1">MPI_Group_incl</symbol>
<symbol vtDef="1">MPI_Group_intersection</symbol>
<symbol vtDef="1">MPI_Group_range_excl</symbol>
<symbol vtDef="1">MPI_Group_range_incl</symbol>
<symbol vtDef="1">MPI_Group_rank</symbol>
<symbol vtDef="1">MPI_Group_size</symbol>
<symbol vtDef="1">MPI_Group_translate_ranks</symbol>
<symbol vtDef="1">MPI_Group_union</symbol>
<symbol vtDef="1">MPI_Ibsend</symbol>
<symbol vtDef="1">MPI_Init</symbol>
<symbol vtDef="1">MPI_Init_thread</symbol>
<symbol vtDef="1">MPI_Initialized</symbol>
<symbol vtDef="1">MPI_Intercomm_create</symbol>
<symbol vtDef="1">MPI_Intercomm_merge</symbol>
<symbol vtDef="1">MPI_Iprobe</symbol>
<symbol vtDef="1">MPI_Irecv</symbol>
<symbol vtDef="1">MPI_Irsend</symbol>
<symbol vtDef="1">MPI_Isend</symbol>
<symbol vtDef="1">MPI_Issend</symbol>
<symbol vtDef="1">MPI_Keyval_create</symbol>
<symbol vtDef="1">MPI_Keyval_free</symbol>
<symbol vtDef="1">MPI_Op_create</symbol>
<symbol vtDef="1">MPI_Op_free</symbol>
<symbol vtDef="1">MPI_Pack</symbol>
<symbol vtDef="1">MPI_Pack_size</symbol>
<symbol vtDef="1">MPI_Pcontrol</symbol>
<symbol vtDef="1">MPI_Probe</symbol>
<symbol vtDef="1">MPI_Recv</symbol>
<symbol vtDef="1">MPI_Recv_init</symbol>
<symbol vtDef="1">MPI_Reduce</symbol>
<symbol vtDef="1">MPI_Reduce_scatter</symbol>
<symbol vtDef="1">MPI_Request_free</symbol>
<symbol vtDef="1">MPI_Rsend</symbol>
<symbol vtDef="1">MPI_Rsend_init</symbol>
<symbol vtDef="1">MPI_Scan</symbol>
<symbol vtDef="1">MPI_Scatter</symbol>
<symbol vtDef="1">MPI_Scatterv</symbol>
<symbol vtDef="1">MPI_Send</symbol>
<symbol vtDef="1">MPI_Send_init</symbol>
<symbol vtDef="1">MPI_Sendrecv</symbol>
<symbol vtDef="1">MPI_Sendrecv_replace</symbol>
<symbol vtDef="1">MPI_Ssend</symbol>
<symbol vtDef="1">MPI_Ssend_init</symbol>
<symbol vtDef="1">MPI_Start</symbol>
<symbol vtDef="1">MPI_Startall</symbol>
<symbol vtDef="1">MPI_Test</symbol>
<symbol vtDef="1">MPI_Test_cancelled</symbol>
<symbol vtDef="1">MPI_Testall</symbol>
<symbol vtDef="1">MPI_Testany</symbol>
<symbol vtDef="1">MPI_Testsome</symbol>
<symbol vtDef="1">MPI_Topo_test</symbol>
<symbol vtDef="1">MPI_Type_commit</symbol>
<symbol vtDef="1">MPI_Type_contiguous</symbol>
<symbol vtDef="1">MPI_Type_extent</symbol>
<symbol vtDef="1">MPI_Type_free</symbol>
<symbol vtDef="1">MPI_Type_hindexed</symbol>
<symbol vtDef="1">MPI_Type_hvector</symbol>
<symbol vtDef="1">MPI_Type_indexed</symbol>
<symbol vtDef="1">MPI_Type_lb</symbol>
<symbol vtDef="1">MPI_Type_size</symbol>
<symbol vtDef="1">MPI_Type_struct</symbol>
<symbol vtDef="1">MPI_Type_ub</symbol>
<symbol vtDef="1">MPI_Type_vector</symbol>
<symbol vtDef="1">MPI_Unpack</symbol>
<symbol vtDef="1">MPI_Wait</symbol>
<symbol vtDef="1">MPI_Waitall</symbol>
<symbol vtDef="1">MPI_Waitany</symbol>
<symbol vtDef="1">MPI_Waitsome</symbol>
<symbol vtDef="1">MPI_Wtick</symbol>
<symbol vtDef="1">MPI_Wtime</symbol>
<symbol vtDef="1">MPI_Accumulate</symbol>
<symbol vtDef="1">MPI_Get</symbol>
<symbol vtDef="1">MPI_Put</symbol>
<symbol vtDef="1">MPI_Win_complete</symbol>
<symbol vtDef="1">MPI_Win_create</symbol>
<symbol vtDef="1">MPI_Win_fence</symbol>
<symbol vtDef="1">MPI_Win_free</symbol>
<symbol vtDef="1">MPI_Win_lock</symbol>
<symbol vtDef="1">MPI_Win_post</symbol>
<symbol vtDef="1">MPI_Win_start</symbol>
<symbol vtDef="1">MPI_Win_test</symbol>
<symbol vtDef="1">MPI_Win_unlock</symbol>
<symbol vtDef="1">MPI_Win_wait</symbol>
<symbol vtDef="1">MPI_Alltoallw</symbol>
<symbol vtDef="1">MPI_Exscan</symbol>
<symbol vtDef="1">MPI_File_open</symbol>
<symbol vtDef="1">MPI_File_close</symbol>
<symbol vtDef="1">MPI_File_delete</symbol>
<symbol vtDef="1">MPI_File_set_size</symbol>
<symbol vtDef="1">MPI_File_preallocate</symbol>
<symbol vtDef="1">MPI_File_get_size</symbol>
<symbol vtDef="1">MPI_File_get_group</symbol>
<symbol vtDef="1">MPI_File_get_amode</symbol>
<symbol vtDef="1">MPI_File_set_info</symbol>
<symbol vtDef="1">MPI_File_get_info</symbol>
<symbol vtDef="1">MPI_File_set_view</symbol>
<symbol vtDef="1">MPI_File_get_view</symbol>
<symbol vtDef="1">MPI_File_read_at</symbol>
<symbol vtDef="1">MPI_File_read_at_all</symbol>
<symbol vtDef="1">MPI_File_write_at</symbol>
<symbol vtDef="1">MPI_File_write_at_all</symbol>
<symbol vtDef="1">MPI_File_iread_at</symbol>
<symbol vtDef="1">MPI_File_iwrite_at</symbol>
<symbol vtDef="1">MPI_File_read</symbol>
<symbol vtDef="1">MPI_File_read_all</symbol>
<symbol vtDef="1">MPI_File_write</symbol>
<symbol vtDef="1">MPI_File_write_all</symbol>
<symbol vtDef="1">MPI_File_iread</symbol>
<symbol vtDef="1">MPI_File_iwrite</symbol>
<symbol vtDef="1">MPI_File_seek</symbol>
<symbol vtDef="1">MPI_File_get_position</symbol>
<symbol vtDef="1">MPI_File_get_byte_offset</symbol>
<symbol vtDef="1">MPI_File_read_shared</symbol>
<symbol vtDef="1">MPI_File_write_shared</symbol>
<symbol vtDef="1">MPI_File_iread_shared</symbol>
<symbol vtDef="1">MPI_File_iwrite_shared</symbol>
<symbol vtDef="1">MPI_File_read_ordered</symbol>
<symbol vtDef="1">MPI_File_write_ordered</symbol>
<symbol vtDef="1">MPI_File_seek_shared</symbol>
<symbol vtDef="1">MPI_File_get_position_shared</symbol>
<symbol vtDef="1">MPI_File_read_at_all_begin</symbol>
<symbol vtDef="1">MPI_File_read_at_all_end</symbol>
<symbol vtDef="1">MPI_File_write_at_all_begin</symbol>
<symbol vtDef="1">MPI_File_write_at_all_end</symbol>
<symbol vtDef="1">MPI_File_read_all_begin</symbol>
<symbol vtDef="1">MPI_File_read_all_end</symbol>
<symbol vtDef="1">MPI_File_write_all_begin</symbol>
<symbol vtDef="1">MPI_File_write_all_end</symbol>
<symbol vtDef="1">MPI_File_read_ordered_begin</symbol>
<symbol vtDef="1">MPI_File_read_ordered_end</symbol>
<symbol vtDef="1">MPI_File_write_ordered_begin</symbol>
<symbol vtDef="1">MPI_File_write_ordered_end</symbol>
<symbol vtDef="1">MPI_File_get_type_extent</symbol>
<symbol vtDef="1">MPI_File_set_atomicity</symbol>
<symbol vtDef="1">MPI_File_get_atomicity</symbol>
<symbol vtDef="1">MPI_File_sync</symbol>
<symbol vtDef="1">MPI_Alloc_mem</symbol>
<symbol vtDef="1">MPI_Comm_create_errhandler</symbol>
<symbol vtDef="1">MPI_Comm_get_errhandler</symbol>
<symbol vtDef="1">MPI_Comm_set_errhandler</symbol>
<symbol vtDef="1">MPI_Finalized</symbol>
<symbol vtDef="1">MPI_Free_mem</symbol>
<symbol vtDef="1">MPI_Get_address</symbol>
<symbol vtDef="1">MPI_Info_create</symbol>
<symbol vtDef="1">MPI_Info_delete</symbol>
<symbol vtDef="1">MPI_Info_dup</symbol>
<symbol vtDef="1">MPI_Info_free</symbol>
<symbol vtDef="1">MPI_Info_get</symbol>
<symbol vtDef="1">MPI_Info_get_nkeys</symbol>
<symbol vtDef="1">MPI_Info_get_nthkey</symbol>
<symbol vtDef="1">MPI_Info_get_valuelen</symbol>
<symbol vtDef="1">MPI_Info_set</symbol>
<symbol vtDef="1">MPI_Pack_external</symbol>
<symbol vtDef="1">MPI_Pack_external_size</symbol>
<symbol vtDef="1">MPI_Request_get_status</symbol>
<symbol vtDef="1">MPI_Type_create_darray</symbol>
<symbol vtDef="1">MPI_Type_create_hindexed</symbol>
<symbol vtDef="1">MPI_Type_create_hvector</symbol>
<symbol vtDef="1">MPI_Type_create_indexed_block</symbol>
<symbol vtDef="1">MPI_Type_create_resized</symbol>
<symbol vtDef="1">MPI_Type_create_struct</symbol>
<symbol vtDef="1">MPI_Type_create_subarray</symbol>
<symbol vtDef="1">MPI_Type_get_extent</symbol>
<symbol vtDef="1">MPI_Type_get_true_extent</symbol>
<symbol vtDef="1">MPI_Unpack_external</symbol>
<symbol vtDef="1">MPI_Win_create_errhandler</symbol>
<symbol vtDef="1">MPI_Win_get_errhandler</symbol>
<symbol vtDef="1">MPI_Win_set_errhandler</symbol>
<symbol vtDef="1">MPI_File_call_errhandler</symbol>
<symbol vtDef="1">MPI_File_create_errhandler</symbol>
<symbol vtDef="1">MPI_File_get_errhandler</symbol>
<symbol vtDef="1">MPI_File_set_errhandler</symbol>
<symbol vtDef="1">MPI_Add_error_class</symbol>
<symbol vtDef="1">MPI_Add_error_code</symbol>
<symbol vtDef="1">MPI_Add_error_string</symbol>
<symbol vtDef="1">MPI_Comm_call_errhandler</symbol>
<symbol vtDef="1">MPI_Comm_create_keyval</symbol>
<symbol vtDef="1">MPI_Comm_delete_attr</symbol>
<symbol vtDef="1">MPI_Comm_free_keyval</symbol>
<symbol vtDef="1">MPI_Comm_get_attr</symbol>
<symbol vtDef="1">MPI_Comm_get_name</symbol>
<symbol vtDef="1">MPI_Comm_set_attr</symbol>
<symbol vtDef="1">MPI_Comm_set_name</symbol>
<symbol vtDef="1">MPI_Grequest_complete</symbol>
<symbol vtDef="1">MPI_Grequest_start</symbol>
<symbol vtDef="1">MPI_Is_thread_main</symbol>
<symbol vtDef="1">MPI_Query_thread</symbol>
<symbol vtDef="1">MPI_Status_set_cancelled</symbol>
<symbol vtDef="1">MPI_Status_set_elements</symbol>
<symbol vtDef="1">MPI_Type_create_keyval</symbol>
<symbol vtDef="1">MPI_Type_delete_attr</symbol>
<symbol vtDef="1">MPI_Type_dup</symbol>
<symbol vtDef="1">MPI_Type_free_keyval</symbol>
<symbol vtDef="1">MPI_Type_get_attr</symbol>
<symbol vtDef="1">MPI_Type_get_contents</symbol>
<symbol vtDef="1">MPI_Type_get_envelope</symbol>
<symbol vtDef="1">MPI_Type_get_name</symbol>
<symbol vtDef="1">MPI_Type_set_attr</symbol>
<symbol vtDef="1">MPI_Type_set_name</symbol>
<symbol vtDef="1">MPI_Win_call_errhandler</symbol>
<symbol vtDef="1">MPI_Win_create_keyval</symbol>
<symbol vtDef="1">MPI_Win_delete_attr</symbol>
<symbol vtDef="1">MPI_Win_free_keyval</symbol>
<symbol vtDef="1">MPI_Win_get_attr</symbol>
<symbol vtDef="1">MPI_Win_get_name</symbol>
<symbol vtDef="1">MPI_Win_set_attr</symbol>
<symbol vtDef="1">MPI_Win_set_name</symbol>
<symbol vtDef="1">MPI_Type_create_f90_complex</symbol>
<symbol vtDef="1">MPI_Type_create_f90_integer</symbol>
<symbol vtDef="1">MPI_Type_create_f90_real</symbol>
<symbol vtDef="1">MPI_Type_match_size</symbol>
<symbol vtDef="1">MPI_Register_datarep</symbol>
<symbol vtDef="1">MPI_Close_port</symbol>
<symbol vtDef="1">MPI_Comm_accept</symbol>
<symbol vtDef="1">MPI_Comm_connect</symbol>
<symbol vtDef="1">MPI_Comm_disconnect</symbol>
<symbol vtDef="1">MPI_Comm_get_parent</symbol>
<symbol vtDef="1">MPI_Comm_join</symbol>
<symbol vtDef="1">MPI_Comm_spawn</symbol>
<symbol vtDef="1">MPI_Comm_spawn_multiple</symbol>
<symbol vtDef="1">MPI_Lookup_name</symbol>
<symbol vtDef="1">MPI_Open_port</symbol>
<symbol vtDef="1">MPI_Publish_name</symbol>
<symbol vtDef="1">MPI_Unpublish_name</symbol>
</group>
<group identifier="OMP">
<symbol vtDef="1">!$omp atomic</symbol>
<symbol vtDef="1">!$omp critical</symbol>
<symbol vtDef="1">!$omp flush</symbol>
<symbol vtDef="1">!$omp master</symbol>
<symbol vtDef="1">!$omp parallel</symbol>
<symbol vtDef="1">!$omp sections</symbol>
<symbol vtDef="1">!$omp section</symbol>
<symbol vtDef="1">!$omp single</symbol>
<symbol vtDef="1">!$omp workshare</symbol>
</group>
<group identifier="OMP-LOOP">
<symbol vtDef="1">!$omp do</symbol>
<symbol vtDef="1">!$omp for</symbol>
</group>
<group identifier="OMP-SYNC">
<symbol vtDef="1">!$omp barrier</symbol>
<symbol vtDef="1">!$omp ibarrier</symbol>
</group>
<group identifier="OMP-PREG">
<symbol vtDef="1">parallel region</symbol>
</group>
</standardGroups>
<symbolfilter>
<filter caseSensitive="1">
<pattern>UNIMCI_.*</pattern>
<pattern>GOMP_.*</pattern>
<pattern>marmot_.*</pattern>
</filter>
<filter caseSensitive="0">
<pattern>pomp_.*</pattern>
<pattern>vt_.*</pattern>
</filter>
</symbolfilter>
</vtconfig>

21
ompi/contrib/vt/vt/examples/c/Makefile
Просмотреть файл

@ -1,9 +1,9 @@
include Makefile.config
TARGETS = $(HELLO_TGT1) $(HELLO_TGT2) $(HELLO_TGT3) \
$(PI_TGT1) $(PI_TGT2) $(PI_TGT3) \
$(RING_TGT1) $(RING_TGT2) $(RING_TGT3) \
$(MDLBROT_TGT1) $(MDLBROT_TGT2) $(MDLBROT_TGT3) $(MDLBROT_TGT4) $(MDLBROT_TGT5)
TARGETS = $(HELLO_TGT1) $(HELLO_TGT2) $(HELLO_TGT3) $(HELLO_TGT4) \
$(PI_TGT1) $(PI_TGT2) $(PI_TGT3) $(PI_TGT4) \
$(RING_TGT1) $(RING_TGT2) $(RING_TGT3) $(RING_TGT4) \
$(MDLBROT_TGT1) $(MDLBROT_TGT2) $(MDLBROT_TGT3) $(MDLBROT_TGT4) $(MDLBROT_TGT5) $(MDLBROT_TGT6)
.PHONY: all
all: $(TARGETS)
@ -18,6 +18,9 @@ hello-comp: hello.c
### hello-dyn ###
hello-dyn: hello.c
$(MPICC) -vt:inst dyninst $(MPICFLAGS) $^ -o $@ $(MPILIB)
### hello-tau ###
hello-tau: hello.c
$(MPICC) -vt:inst tauinst $(MPICFLAGS) $^ -o $@ $(MPILIB)
### pi-man ###
@ -29,6 +32,9 @@ pi-comp: pi.c
### pi-dyn ###
pi-dyn: pi.c
$(MPICC) -vt:inst dyninst $(MPICFLAGS) $^ -o $@ -lm $(MPILIB)
### pi-tau ###
pi-tau: pi.c
$(MPICC) -vt:inst tauinst $(MPICFLAGS) $^ -o $@ -lm $(MPILIB)
### ring-man ###
@ -40,6 +46,8 @@ ring-comp: ring.c
### ring-dyn ###
ring-dyn: ring.c
$(MPICC) -vt:inst dyninst $(MPICFLAGS) $^ -o $@ $(MPILIB)
ring-tau: ring.c
$(MPICC) -vt:inst tauinst $(MPICFLAGS) $^ -o $@ $(MPILIB)
### mdlbrot-man ###
@ -51,6 +59,9 @@ mdlbrot-comp: mdlbrot.c
### mdlbrot-dyn ###
mdlbrot-dyn: mdlbrot.c
$(MPICC) -vt:inst dyninst $(MPICFLAGS) $(SDLINCDIR) $^ -o $@ $(MPILIB) $(SDLLIB)
### mdlbrot-tau ###
mdlbrot-tau: mdlbrot.c
$(MPICC) -vt:inst tauinst $(MPICFLAGS) $(SDLINCDIR) $^ -o $@ $(MPILIB) $(SDLLIB)
### libSDLwrap.<a|so> ###
libSDLwrap.a: SDLwrap.c
vtlibwrapgen --build -o libSDLwrap --static $^
@ -63,5 +74,5 @@ SDLwrap.c:
.PHONY: clean
clean:
-rm -f $(TARGETS) SDLwrap.c *~ *.o
-rm -f *.uctl *.filt *.otf *.z
-rm -f *.uctl *.otf *.z

11
ompi/contrib/vt/vt/examples/c/Makefile.config
Просмотреть файл

@ -7,31 +7,36 @@ MPILIB =
# <prog>-man == manual: functions and loops by using VampirTrace's API
# <prog>-comp == automatic: functions by using compiler
# <prog>-dyn == binary-automatic: functions by using Dyninst
# <prog>-tau == source2source-automatic: functions by using PDT/TAU
# (comment line to disable a target)
# HELLO (Hello World (MPI))
HELLO_TGT1 = hello-man
#HELLO_TGT2 = hello-comp
#HELLO_TGT3 = hello-dyn
#HELLO_TGT4 = hello-tau
# PI (Approximates the value of pi (MPI))
PI_TGT1 = pi-man
#PI_TGT2 = pi-comp
#PI_TGT3 = pi-dyn
#PI_TGT4 = pi-tau
# RING (Send a trivial message around in a ring (MPI))
RING_TGT1 = ring-man
#RING_TGT2 = ring-comp
#RING_TGT3 = ring-dyn
#RING_TGT4 = ring-tau
# MANDELBROT (Calculate Mandelbrot set (MPI))
SDLINCDIR =
SDLLIB = -lSDL
MDLBROT_TGT1 = mdlbrot-man
#MDLBROT_TGT1 = mdlbrot-man
#MDLBROT_TGT2 = mdlbrot-comp
#MDLBROT_TGT3 = mdlbrot-dyn
#MDLBROT_TGT4 = mdlbrot-tau
# uncomment following lines, if you want to instrument the SDL API
#SDLHEADERS = /usr/include/SDL/SDL_*.h
#MDLBROT_TGT4 = libSDLwrap.so
#MDLBROT_TGT5 = libSDLwrap.a
#MDLBROT_TGT5 = libSDLwrap.so
#MDLBROT_TGT6 = libSDLwrap.a

17
ompi/contrib/vt/vt/examples/cxx/Makefile
Просмотреть файл

@ -1,8 +1,8 @@
include Makefile.config
TARGETS = $(HELLO_TGT1) $(HELLO_TGT2) $(HELLO_TGT3) \
$(PI_TGT1) $(PI_TGT2) $(PI_TGT3) \
$(RING_TGT1) $(RING_TGT2) $(RING_TGT3)
TARGETS = $(HELLO_TGT1) $(HELLO_TGT2) $(HELLO_TGT3) $(HELLO_TGT4) \
$(PI_TGT1) $(PI_TGT2) $(PI_TGT3) $(PI_TGT4) \
$(RING_TGT1) $(RING_TGT2) $(RING_TGT3) $(RING_TGT4)
.PHONY: all
all: $(TARGETS)
@ -17,6 +17,9 @@ hello-comp: hello.cc
### hello-dyn ###
hello-dyn: hello.cc
$(MPICXX) -vt:inst dyninst $(MPICXXFLAGS) $^ -o $@ $(MPILIB)
### hello-tau ###
hello-tau: hello.cc
$(MPICXX) -vt:inst tauinst $(MPICXXFLAGS) $^ -o $@ $(MPILIB)
### pi-man ###
@ -28,6 +31,9 @@ pi-comp: pi.cc
### pi-dyn ###
pi-dyn: pi.cc
$(MPICXX) -vt:inst dyninst $(MPICXXFLAGS) $^ -o $@ -lm $(MPILIB)
### pi-tau ###
pi-tau: pi.cc
$(MPICXX) -vt:inst tauinst $(MPICXXFLAGS) $^ -o $@ -lm $(MPILIB)
### ring-man ###
@ -39,8 +45,13 @@ ring-comp: ring.cc
### ring-dyn ###
ring-dyn: ring.cc
$(MPICXX) -vt:inst dyninst $(MPICXXFLAGS) $^ -o $@ $(MPILIB)
### ring-tau ###
ring-tau: ring.cc
$(MPICXX) -vt:inst tauinst $(MPICXXFLAGS) $^ -o $@ $(MPILIB)
.PHONY: clean
clean:
-rm -f $(TARGETS) *~ *.o
-rm -f *.uctl *.otf *.z

10
ompi/contrib/vt/vt/examples/cxx/Makefile.config
Просмотреть файл

@ -7,20 +7,24 @@ MPILIB =
# <prog>-man == manual: functions and loops by using VampirTrace's API
# <prog>-comp == automatic: functions by using compiler
# <prog>-dyn == binary-automatic: functions by using Dyninst
# <prog>-tau == source2source-automatic: functions by using PDT/TAU
# (comment line to disable a target)
# HELLO (Hello World (MPI))
HELLO_TGT1 = hello-man
HELLO_TGT2 = hello-comp
#HELLO_TGT2 = hello-comp
#HELLO_TGT3 = hello-dyn
#HELLO_TGT4 = hello-tau
# PI (Approximates the value of pi (MPI))
PI_TGT1 = pi-man
PI_TGT2 = pi-comp
#PI_TGT2 = pi-comp
#PI_TGT3 = pi-dyn
#PI_TGT4 = pi-tau
# RING (Send a trivial message around in a ring (MPI))
RING_TGT1 = ring-man
RING_TGT2 = ring-comp
#RING_TGT2 = ring-comp
#RING_TGT3 = ring-dyn
#RING_TGT4 = ring-tau

17
ompi/contrib/vt/vt/examples/fortran/Makefile
Просмотреть файл

@ -1,8 +1,8 @@
include Makefile.config
TARGETS = $(HELLO_TGT1) $(HELLO_TGT2) $(HELLO_TGT3) \
$(PI_TGT1) $(PI_TGT2) $(PI_TGT3) \
$(RING_TGT1) $(RING_TGT2) $(RING_TGT3)
TARGETS = $(HELLO_TGT1) $(HELLO_TGT2) $(HELLO_TGT3) $(HELLO_TGT4) \
$(PI_TGT1) $(PI_TGT2) $(PI_TGT3) $(PI_TGT4) \
$(RING_TGT1) $(RING_TGT2) $(RING_TGT3) $(RING_TGT4)
.PHONY: all
all: $(TARGETS)
@ -17,6 +17,9 @@ hello-comp: hello.F
### hello-dyn ###
hello-dyn: hello.F
$(MPIFC) -vt:inst dyninst $(MPIFFLAGS) $^ -o $@ $(MPILIB)
### hello-tau ###
hello-tau: hello.F
$(MPIFC) -vt:inst tauinst $(MPIFFLAGS) $^ -o $@ $(MPILIB)
### pi-man ###
@ -28,6 +31,9 @@ pi-comp: pi.F
### pi-dyn ###
pi-dyn: pi.F
$(MPIFC) -vt:inst dyninst $(MPIFFLAGS) $^ -o $@ -lm $(MPILIB)
### pi-tau ###
pi-tau: pi.F
$(MPIFC) -vt:inst tauinst $(MPIFFLAGS) $^ -o $@ -lm $(MPILIB)
### ring-man ###
@ -39,8 +45,13 @@ ring-comp: ring.F
### ring-dyn ###
ring-dyn: ring.F
$(MPIFC) -vt:inst dyninst $(MPIFFLAGS) $^ -o $@ $(MPILIB)
### ring-tau ###
ring-tau: ring.F
$(MPIFC) -vt:inst tauinst $(MPIFFLAGS) $^ -o $@ $(MPILIB)
.PHONY: clean
clean:
-rm -f $(TARGETS) *~ *.o
-rm -f *.uctl *.otf *.z

12
ompi/contrib/vt/vt/examples/fortran/Makefile.config
Просмотреть файл

@ -3,27 +3,31 @@ MPIFC = vtf90 -vt:f90 mpif90
MPIFFLAGS = -g
MPILIB =
FDOPT = -D
#FDOPT = -WF,D
#FDOPT = -WF,-D
# Example targets:
# targets and coresponding instrumentation type
# <prog>-man == manual: functions and loops by using VampirTrace's API
# <prog>-comp == automatic: functions by using compiler
# <prog>-dyn == binary-automatic: functions by using Dyninst
# <prog>-tau == source2source-automatic: functions by using PDT/TAU
# (comment line to disable a target)
# HELLO (Hello World)
HELLO_TGT1 = hello-man
HELLO_TGT2 = hello-comp
#HELLO_TGT2 = hello-comp
#HELLO_TGT3 = hello-dyn
#HELLO_TGT4 = hello-tau
# PI (Approximates the value of pi)
PI_TGT1 = pi-man
PI_TGT2 = pi-comp
#PI_TGT2 = pi-comp
#PI_TGT3 = pi-dyn
#PI_TGT4 = pi-tau
# RING (Send a trivial message around in a ring)
RING_TGT1 = ring-man
RING_TGT2 = ring-comp
#RING_TGT2 = ring-comp
#RING_TGT3 = ring-dyn
#RING_TGT4 = ring-tau

4
ompi/contrib/vt/vt/extlib/otf/AUTHORS
Просмотреть файл

@ -1,7 +1,9 @@
Andreas Knuepfer <andreas.knuepfer AT tu-dresden.de>
Ronny Brendel <ronny.brendel AT tu-dresden.de>
Matthias Jurenz <matthias.jurenz AT tu-dresden.de>
Johannes Spazier <johannes.spazier AT tu-dresden.de>
Matthias Jurenz <matthias.jurenz AT tu-dresden.de>
Bert Wesarg <bert.wesarg AT tu-dresden.de>
Robert Dietrich <robert.dietrich AT zih.tu-dresden.de>
Michael Heyde <michael.heyde AT tu-dresden.de>
Michael Kluge <michael.kluge AT tu-dresden.de>
Holger Mickler <holger.mickler AT tu-dresden.de>

2
ompi/contrib/vt/vt/extlib/otf/COPYING
Просмотреть файл

@ -1,4 +1,4 @@
Copyright (c) 2005-2010, ZIH, Technische Universitaet Dresden,
Copyright (c) 2005-2011, ZIH, Technische Universitaet Dresden,
Federal Republic of Germany
All rights reserved.

59
ompi/contrib/vt/vt/extlib/otf/ChangeLog
Просмотреть файл

@ -1,15 +1,66 @@
1.6.5openmpi
1.9.1openmpi = 1.9sawfish
1.9sawfish
- added MPI-parallel version of otfprofile (otfprofile-mpi)
- added library 'libotfaux' for matching message events
- added time range record
- added counter process assignment record
- minor extensions on API for handling key-value lists
- define PATH_MAX under Windows if it is not defined yet
- fixed incorrect execution mode when using otfdecompress under Windows
1.8.1sturgeon
- added option to 'otfdump' for specifying the maximum number of files
that are allowed to be open simultaneously
- fixed compile error in 'otfmerge-mpi' due to a missing header include
- extended the 'hello' example source code to show the usage of
key-values
1.8sturgeon
- extended API for reading definitions from an external memory buffer
instead of a file
- added copy handlers for single trace streams
- added support for Python 3
- temporary disabled OpenMP support completely if the PGI compiler is
used to work around some uncleared compile errors
1.7.1catfish
- removed size limit of key-value byte arrays
- disable OpenMP support in otfprofile if the PGI compiler
is used to work around some compiler errors
- fixed bug while reading an empty process group definition record
- fixed composition of output file name in otf[de]compress
- fixed a memory leak in python interface
1.7catfish
- added second version of each record that contains a Key-Value
list to store individual data
- two new definition records which can be used to assign
attributes to processes
- two new snapshot record types: BeginCollopSnapshot,
BeginFileOpSnapshot
- API changes in EndFileOP record and SendSnapshot record because
of a flawed design
- added MPI-parallel version of otfmerge (otfmerge-mpi)
- otfprofile has a lite mode usefuly for highly parallel traces
- added option to otf[de]compress for specifying an output directory
- try to open files with 'O_NOATIME' for reading for increased speed
- try to handle ESTALE errors on NFS gracefully
- fixed OTF long format for several records
- fixed error handling in OTF reader
- fixed bug in otfshrink: a process number can be between
0 and 4294967296 now
1.6.5stingray
- enforce building position independent code (PIC) for the static
version of the OTF library
(so it's possible to add these objects to 3rd-party shared libraries)
- fixed and enhanced calculation of trace file size in otfinfo
- temporary disabled OpenMP support completely if the PGI compiler is
used to work around some uncleared compile errors
- patched libtool:
- to avoid a bug in detection of the PGI 10 C++ compiler
- to detect IBM cross compilers on BlueGene/P
1.6.4openmpi
1.6.4stingray
- enhanced reading of process group definition records
1.6.3stingray

2
ompi/contrib/vt/vt/extlib/otf/LICENSE
Просмотреть файл

@ -1,4 +1,4 @@
Copyright (c) 2005-2010, ZIH, Technische Universitaet Dresden,
Copyright (c) 2005-2011, ZIH, Technische Universitaet Dresden,
Federal Republic of Germany
All rights reserved.

13
ompi/contrib/vt/vt/extlib/otf/Makefile.am
Просмотреть файл

@ -1,24 +1,21 @@
ACLOCAL_AMFLAGS = -I config/m4
if AMHAVEPYTHONSWIG
if AMHAVESWIGPYTHON
OTFLIB_PY = otflib_py
else
OTFLIB_PY =
endif
SUBDIRS = \
vendor/jenkins_hash \
otflib \
otfauxlib \
$(OTFLIB_PY) \
tools \
tests \
docu
EXTRA_DIST= \
EXTRA_DIST = \
otf_vc08.sln \
config/otf_get_version.sh \
tests/hello/Makefile \
tests/hello/hello_otf.c \
tests/otf_python/groups.py \
tests/otf_python/test_read.py \
tests/otf_python/test_read_qt.py \
tests/otf_python/test_write.py \
VERSION

9
ompi/contrib/vt/vt/extlib/otf/VERSION
Просмотреть файл

@ -6,8 +6,8 @@
# <major>.<minor>.<sub>. If sub is zero, then it is omitted.
major=1
minor=6
sub=5
minor=9
sub=1
# string is used for alpha, beta, or release tags. If it is non-empty, it will
# be appended to the version number.
@ -20,6 +20,9 @@ sub=5
# 1.4.* shark
# 1.5.* dolphin
# 1.6.* stingray
# 1.7.* catfish
# 1.8.* sturgeon
# 1.9.* sawfish
#
string=openmpi
@ -44,5 +47,5 @@ string=openmpi
# release, age must be incremented. Otherwise, reset age
# to '0'.
library=0:1:0
library=3:1:2

4
ompi/contrib/vt/vt/extlib/otf/acinclude.m4
Просмотреть файл

@ -1,10 +1,10 @@
m4_include(config/m4/acinclude.debug.m4)
m4_include(config/m4/acinclude.math.m4)
m4_include(config/m4/acinclude.mpi.m4)
m4_include(config/m4/acinclude.omp.m4)
m4_include(config/m4/acinclude.pydev.m4)
m4_include(config/m4/acinclude.swig.m4)
m4_include(config/m4/acinclude.swig_python.m4)
m4_include(config/m4/acinclude.vtf3.m4)
m4_include(config/m4/acinclude.verbose.m4)
m4_include(config/m4/acinclude.zlib.m4)
m4_include(config/m4/acarchive/ax_mpi.m4)
m4_include(config/m4/acarchive/ax_openmp.m4)

186
ompi/contrib/vt/vt/extlib/otf/config/m4/acarchive/ax_mpi.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,186 @@
# ===========================================================================
# http://www.nongnu.org/autoconf-archive/ax_mpi.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
#
# DESCRIPTION
#
# This macro tries to find out how to compile programs that use MPI
# (Message Passing Interface), a standard API for parallel process
# communication (see http://www-unix.mcs.anl.gov/mpi/)
#
# On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
# to the name of the MPI compiler, depending upon the current language.
# (This may just be $CC/$CXX/$F77/$FC, but is more often something like
# mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
# are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
# MPICC/MPICXX/MPIF77/MPIFC was not found).
#
# If you want to compile everything with MPI, you should set:
#
# CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
# LIBS="$MPILIBS $LIBS"
#
# NOTE: The above assumes that you will use $CC (or whatever) for linking
# as well as for compiling. (This is the default for automake and most
# Makefiles.)
#
# The user can force a particular library/compiler by setting the
# MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
#
# ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
# found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
# found. If ACTION-IF-FOUND is not specified, the default action will
# define HAVE_MPI.
#
# LICENSE
#
# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
# Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Archive. When you make and distribute a
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
#serial 4
AU_ALIAS([ACX_MPI], [AX_MPI])
AC_DEFUN([AX_MPI], [
AC_PREREQ(2.50) dnl for AC_LANG_CASE
AC_LANG_CASE([C], [
AC_REQUIRE([AC_PROG_CC])
AC_ARG_VAR(MPICC,[MPI C compiler command])
AC_CHECK_PROGS(MPICC, mpicc hcc mpxlc_r mpxlc mpcc cmpicc)
ax_mpi_comp="$MPICC"
],
[C++], [
AC_REQUIRE([AC_PROG_CXX])
AC_ARG_VAR(MPICXX,[MPI C++ compiler command])
AC_CHECK_PROGS(MPICXX, mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++)
ax_mpi_comp="$MPICXX"
],
[Fortran 77], [
AC_REQUIRE([AC_PROG_F77])
AC_ARG_VAR(MPIF77,[MPI Fortran 77 compiler command])
AC_CHECK_PROGS(MPIF77, mpif77 hf77 mpxlf_r mpxlf mpf77 cmpifc)
ax_mpi_comp="$MPIF77"
],
[Fortran], [
AC_REQUIRE([AC_PROG_FC])
AC_ARG_VAR(MPIFC,[MPI Fortran compiler command])
AC_CHECK_PROGS(MPIFC, mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c)
ax_mpi_comp="$MPIFC"
])
if test x = x"$MPILIBS" -a x = x"$ax_mpi_comp"; then
AC_LANG_CASE([C], [AC_CHECK_FUNC(MPI_Init, [MPILIBS=" "])],
[C++], [AC_CHECK_FUNC(MPI_Init, [MPILIBS=" "])],
[Fortran 77], [AC_MSG_CHECKING([for MPI_Init])
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[ call MPI_Init])],[MPILIBS=" "
AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no)])],
[Fortran], [AC_MSG_CHECKING([for MPI_Init])
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[ call MPI_Init])],[MPILIBS=" "
AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no)])])
fi
if test x = x"$ax_mpi_comp"; then
AC_LANG_CASE([Fortran 77], [
if test x = x"$MPILIBS"; then
AC_CHECK_LIB(fmpi, MPI_Init, [MPILIBS="-lfmpi"])
fi
if test x = x"$MPILIBS"; then
AC_CHECK_LIB(fmpich, MPI_Init, [MPILIBS="-lfmpich"])
fi
],
[Fortran], [
if test x = x"$MPILIBS"; then
AC_CHECK_LIB(fmpi, MPI_Init, [MPILIBS="-lfmpi"])
fi
if test x = x"$MPILIBS"; then
AC_CHECK_LIB(mpichf90, MPI_Init, [MPILIBS="-lmpichf90"])
fi
])
if test x = x"$MPILIBS"; then
AC_CHECK_LIB(mpi, MPI_Init, [MPILIBS="-lmpi"])
fi
if test x = x"$MPILIBS"; then
AC_CHECK_LIB(mpich, MPI_Init, [MPILIBS="-lmpich"])
fi
dnl We have to use AC_TRY_COMPILE and not AC_CHECK_HEADER because the
dnl latter uses $CPP, not $CC (which may be mpicc).
AC_LANG_CASE([C], [if test x != x"$MPILIBS"; then
AC_MSG_CHECKING([for mpi.h])
AC_TRY_COMPILE([#include <mpi.h>],[],[AC_MSG_RESULT(yes)], [MPILIBS=""
AC_MSG_RESULT(no)])
fi],
[C++], [if test x != x"$MPILIBS"; then
AC_MSG_CHECKING([for mpi.h])
AC_TRY_COMPILE([#include <mpi.h>],[],[AC_MSG_RESULT(yes)], [MPILIBS=""
AC_MSG_RESULT(no)])
fi],
[Fortran 77], [if test x != x"$MPILIBS"; then
AC_MSG_CHECKING([for mpif.h])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[ include 'mpif.h'])],[AC_MSG_RESULT(yes)], [MPILIBS=""
AC_MSG_RESULT(no)])
fi],
[Fortran], [if test x != x"$MPILIBS"; then
AC_MSG_CHECKING([for mpif.h])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[ include 'mpif.h'])],[AC_MSG_RESULT(yes)], [MPILIBS=""
AC_MSG_RESULT(no)])
fi])
fi
AC_LANG_CASE([C], [if test x = x"$MPICC"; then
MPICC="$CC"
fi
AC_SUBST(MPICC)],
[C++], [if test x = x"$MPICXX"; then
MPICXX="$CXX"
fi
AC_SUBST(MPICXX)],
[Fortran 77], [if test x = x"$MPIF77"; then
MPIF77="$F77"
fi
AC_SUBST(MPIF77)],
[Fortran], [if test x = x"$MPIF90"; then
MPIFC="$FC"
fi
AC_SUBST(MPIFC)])
AC_SUBST(MPILIBS)
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x = x"$MPILIBS" -a x = x"$ax_mpi_comp"; then
$2
:
else
ifelse([$1],,[AC_DEFINE(HAVE_MPI,1,[Define if you have the MPI library.])],[$1])
:
fi
])dnl AX_MPI

94
ompi/contrib/vt/vt/extlib/otf/config/m4/acinclude.mpi.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,94 @@
AC_DEFUN([CHECK_MPI],
[
mpi_error="no"
check_mpi="yes"
force_mpi="no"
have_mpi="no"
AC_ARG_VAR([MPICFLAGS], [MPI C compiler flags])
AC_ARG_VAR([MPICXXFLAGS], [MPI CXX compiler flags])
MPICXXFLAGS="$MPICXXFLAGS -DMPICH_SKIP_MPICXX -DOMPI_SKIP_MPICXX -DMPI_NO_CPPBIND"
AC_ARG_WITH([mpi],
AC_HELP_STRING([--with-mpi],
[use MPI for some OTF tools, default: yes if found by configure]),
[if test "$withval" = "yes"; then force_mpi="yes"; else check_mpi="no"; fi])
AC_ARG_WITH([mpi-dir],
AC_HELP_STRING([--with-mpi-dir],
[give the path for MPI, default: /usr]),
[mpi_dir="$withval/"])
AC_ARG_WITH([mpi-inc-dir],
AC_HELP_STRING([--with-mpi-inc-dir],
[give the path dir MPI-include files, default: MPIDIR/include]),
[mpi_inc_dir="$withval/"],
[if test x"$mpi_dir" != x; then mpi_inc_dir="$mpi_dir"include/; fi])
AC_ARG_WITH([mpi-lib-dir],
AC_HELP_STRING([--with-mpi-lib-dir],
[give the path for MPI-libraries, default: MPIDIR/lib]),
[mpi_lib_dir="$withval/"],
[if test x"$mpi_dir" != x; then mpi_lib_dir="$mpi_dir"lib/; fi])
AC_ARG_WITH([mpi-lib],
AC_HELP_STRING([--with-mpi-lib],
[use given MPI]),
[mpi_lib="$withval"])
if test "$check_mpi" = "yes"; then
sav_LDFLAGS=$LDFLAGS
AS_IF([test x"$mpi_lib_dir" != x],
[LDFLAGS="$LDFLAGS -L$mpi_lib_dir"])
AS_IF([test x"$mpi_lib" != x],
[MPILIBS="$mpi_lib"])
sav_CPPFLAGS=$CPPFLAGS
AS_IF([test x"$mpi_inc_dir" != x],
[CPPFLAGS="$CPPFLAGS -I$mpi_inc_dir"])
CPPFLAGS="$CPPFLAGS $MPICFLAGS"
AX_MPI(
[
CPPFLAGS="$CPPFLAGS $MPICXXFLAGS"
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AX_MPI(
[
mpi_lib=$MPILIBS
have_mpi="yes"
],
[
mpi_error="yes"
])
AC_LANG_RESTORE
],
[
mpi_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
LDFLAGS=$sav_LDFLAGS
fi
MPI_LIB_DIR=$mpi_lib_dir
MPI_LIB_LINE=$mpi_lib
if test x"$mpi_lib_dir" != x; then
MPI_LIB_LINE="-L$mpi_lib_dir $MPI_LIB_LINE"
fi
MPI_INCLUDE_DIR=$mpi_inc_dir
MPI_INCLUDE_LINE=
if test x"$mpi_inc_dir" != x; then
MPI_INCLUDE_LINE="-I$mpi_inc_dir"
fi
AC_SUBST(MPICFLAGS)
AC_SUBST(MPICXXFLAGS)
AC_SUBST(MPI_LIB_DIR)
AC_SUBST(MPI_LIB_LINE)
AC_SUBST(MPI_INCLUDE_DIR)
AC_SUBST(MPI_INCLUDE_LINE)
])

44
ompi/contrib/vt/vt/extlib/otf/config/m4/acinclude.omp.m4
Просмотреть файл

@ -1,27 +1,41 @@
AC_DEFUN([CHECK_OMP],
[
omp_error="no"
check_omp="yes"
force_omp="no"
have_omp="no"
AC_ARG_VAR(OPENMP_CXXFLAGS, [C++ compiler flags to enable support for OpenMP])
dnl Disable OpenMP if the PGI compiler is used to work around the following errors:
dnl compiler version compiler error
dnl < 9.0-3 PGCC-S-0000-Internal compiler error. calc_dw_tag:no tag
dnl (see Technical Problem Report 4337 at http://www.pgroup.com/support/release_tprs_90.htm)
dnl 10.1 - 10.6 this kind of pragma may not be used here
dnl #pargma omp barrier
case `$CC -V 2>&1` in
*pgcc*)
check_omp="no"
;;
esac
AC_ARG_WITH([omp],
AC_HELP_STRING([--with-omp],
[use OpenMP for some OTF tools, default: yes if found by configure]),
[if test "$withval" = "yes"; then force_omp="yes"; else check_omp="no"; fi])
AS_IF([test "$check_omp" = "yes"],
[
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AX_OPENMP([have_omp="yes"])
AC_LANG_RESTORE
dnl Disable OpenMP if the PGI compiler is used to work around the following errors:
dnl compiler version compiler error
dnl < 9.0-3 PGCC-S-0000-Internal compiler error. calc_dw_tag:no tag
dnl (see Technical Problem Report 4337 at http://www.pgroup.com/support/release_tprs_90.htm)
dnl 10.1 - 10.6 this kind of pragma may not be used here
dnl #pargma omp barrier
case `$CC -V 2>&1` in
*pgcc*)
AS_IF([test "$force_omp" = "yes"],
[
AC_MSG_NOTICE([error: OpenMP support cannot be enabled due to not yet resolved issues with the PGI compiler])
])
omp_error="yes"
;;
esac
AS_IF([test "$omp_error" = "no"],
[
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AX_OPENMP([have_omp="yes"], [omp_error="yes"])
AC_LANG_RESTORE
])
])
])

152
ompi/contrib/vt/vt/extlib/otf/config/m4/acinclude.pydev.m4
Просмотреть файл

@ -1,152 +0,0 @@
AC_DEFUN([AC_PYTHON_DEVEL],[
#
# Allow the use of a (user set) custom python version
#
AC_ARG_VAR([PYTHON_VERSION],[The installed Python
version to use, for example '2.3'. This string
will be appended to the Python interpreter
canonical name.])
AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
if test -z "$PYTHON"; then
AC_MSG_WARN([Cannot find python$PYTHON_VERSION in your system path])
PYTHON_VERSION=""
else
#
# Check for Python include path
#
AC_MSG_CHECKING([for python include path])
if test -z "$PYTHON_CPPFLAGS"; then
python_path=`$PYTHON -c "import distutils.sysconfig; print distutils.sysconfig.get_python_inc();" 2> /dev/null`
if test -n "${python_path}"; then
python_path="-I$python_path"
fi
PYTHON_CPPFLAGS=$python_path
fi
if test -n "$PYTHON_CPPFLAGS"; then
AC_MSG_RESULT([$PYTHON_CPPFLAGS])
else
AC_MSG_RESULT([no])
fi
AC_SUBST([PYTHON_CPPFLAGS])
#
# Check for Python library path
#
AC_MSG_CHECKING([for python library path])
if test -z "$PYTHON_LDFLAGS"; then
# (makes two attempts to ensure we've got a version number
# from the interpreter)
py_version=`$PYTHON -c "from distutils.sysconfig import *; \
from string import join; \
print join(get_config_vars('VERSION'))" 2> /dev/null`
if test "$py_version" = "[None]" -o -z "$py_version"; then
if test -n "$PYTHON_VERSION"; then
py_version=$PYTHON_VERSION
else
py_version=`$PYTHON -c "import sys; \
print sys.version[[:3]]"`
fi
fi
PYTHON_LDFLAGS=`$PYTHON -c "from distutils.sysconfig import *; \
from string import join; \
print '-L' + get_python_lib(0,1), \
'-lpython';" 2> /dev/null`$py_version
fi
if test ! "$PYTHON_LDFLAGS" = "$py_version"; then
AC_MSG_RESULT([$PYTHON_LDFLAGS])
else
AC_MSG_RESULT([no])
fi
AC_SUBST([PYTHON_LDFLAGS])
#
# Check for site packages
#
AC_MSG_CHECKING([for python site-packages path])
if test -z "$PYTHON_SITE_PKG"; then
PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \
print distutils.sysconfig.get_python_lib(0,0);" 2> /dev/null`
fi
if test -n "$PYTHON_SITE_PKG"; then
AC_MSG_RESULT([$PYTHON_SITE_PKG])
else
AC_MSG_RESULT([no])
fi
AC_SUBST([PYTHON_SITE_PKG])
#
# libraries which must be linked in when embedding
#
AC_MSG_CHECKING(python extra libraries)
if test -z "$PYTHON_EXTRA_LIBS"; then
PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \
conf = distutils.sysconfig.get_config_var; \
print conf('LOCALMODLIBS'), conf('LIBS')" 2> /dev/null`
fi
if test -n "$PYTHON_EXTRA_LIBS"; then
AC_MSG_RESULT([$PYTHON_EXTRA_LIBS])
else
AC_MSG_RESULT([no])
fi
AC_SUBST(PYTHON_EXTRA_LIBS)
#
# linking flags needed when embedding
#
AC_MSG_CHECKING(python extra linking flags)
if test -z "$PYTHON_EXTRA_LDFLAGS"; then
PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \
conf = distutils.sysconfig.get_config_var; \
print conf('LINKFORSHARED')" 2> /dev/null`
fi
if test -n "$PYTHON_EXTRA_LDFLAGS"; then
AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS])
else
AC_MSG_RESULT([no])
fi
AC_SUBST(PYTHON_EXTRA_LDFLAGS)
#
# final check to see if everything compiles alright
#
AC_MSG_CHECKING([consistency of all components of python development environment])
AC_LANG_PUSH([C])
# save current global flags
LIBS="$ac_save_LIBS $PYTHON_LDFLAGS"
CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
AC_TRY_LINK([
#include <Python.h>
],[
Py_Initialize();
],[pythonexists=yes],[pythonexists=no])
AC_MSG_RESULT([$pythonexists])
if test ! "$pythonexists" = "yes"; then
AC_MSG_ERROR([Cannot find python development environment. You probably have to install the development version of the python package.])
PYTHON_VERSION=""
fi
AC_LANG_POP
# turn back to default flags
CPPFLAGS="$ac_save_CPPFLAGS"
LIBS="$ac_save_LIBS"
#get the paths where to install the package
AC_SUBST([pkgpythondir],
['${prefix}'/lib/python${py_version}/site-packages/otf])
AC_SUBST([pkgpyexecdir],
['${exec_prefix}'/lib/python${py_version}/site-packages/otf])
fi
])

57
ompi/contrib/vt/vt/extlib/otf/config/m4/acinclude.swig.m4
Просмотреть файл

@ -1,57 +0,0 @@
AC_DEFUN([AC_PROG_SWIG],[
AC_PATH_PROG([SWIG],[swig])
if test -z "$SWIG" ; then
AC_MSG_ERROR([Cannot find 'swig' program.])
elif test -n "$1" ; then
AC_MSG_CHECKING([for swig version])
[swig_version=`$SWIG -version 2>&1 | grep 'SWIG Version' | sed 's/.*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`]
AC_MSG_RESULT([$swig_version])
if test -n "$swig_version" ; then
# Calculate the required version number components
[required=$1]
[required_major=`echo $required | sed 's/[^0-9].*//'`]
if test -z "$required_major" ; then
[required_major=0]
fi
[required=`echo $required | sed 's/[0-9]*[^0-9]//'`]
[required_minor=`echo $required | sed 's/[^0-9].*//'`]
if test -z "$required_minor" ; then
[required_minor=0]
fi
[required=`echo $required | sed 's/[0-9]*[^0-9]//'`]
[required_patch=`echo $required | sed 's/[^0-9].*//'`]
if test -z "$required_patch" ; then
[required_patch=0]
fi
# Calculate the available version number components
[available=$swig_version]
[available_major=`echo $available | sed 's/[^0-9].*//'`]
if test -z "$available_major" ; then
[available_major=0]
fi
[available=`echo $available | sed 's/[0-9]*[^0-9]//'`]
[available_minor=`echo $available | sed 's/[^0-9].*//'`]
if test -z "$available_minor" ; then
[available_minor=0]
fi
[available=`echo $available | sed 's/[0-9]*[^0-9]//'`]
[available_patch=`echo $available | sed 's/[^0-9].*//'`]
if test -z "$available_patch" ; then
[available_patch=0]
fi
if test $available_major -ne $required_major \
-o $available_minor -ne $required_minor \
-o $available_patch -lt $required_patch ; then
AC_MSG_ERROR([swig version >= $1 is required. You have $swig_version.])
else
swigexists=yes
fi
else
AC_MSG_ERROR([Cannot determine swig version])
fi
fi
])

166
ompi/contrib/vt/vt/extlib/otf/config/m4/acinclude.swig_python.m4
Просмотреть файл

@ -1,51 +1,123 @@
AC_DEFUN([SWIG_PYTHON],[
AC_DEFUN([CHECK_SWIG_PYTHON],
[
swig_python_error="no"
check_swig_python="no"
force_swig_python="no"
have_swig_python="no"
#
#enable python bindings
#
AC_ARG_ENABLE([python-bindings],
AC_HELP_STRING([--enable-python-bindings],
[force generation of Python bindings]),
[enable_python_bindings="yes"],
[enable_python_bindings=""])
#
#with python version
#
AC_ARG_WITH([python-version],
AC_HELP_STRING([--with-python-version=VERSION],
[force a custom python version]),
[PYTHON_VERSION=$withval])
#
#only check if the user did --enable-python-bindings
#
if test x"$enable_python_bindings" = xyes; then
AC_ARG_VAR([PYTHON_VERSION], [The installed Python
version to use, for example '2.3'. This string
will be appended to the Python interpreter
canonical name.])
#
#test for swig >= 1.3
#
AC_PROG_SWIG(1.3)
#
#test for python-dev
#
AC_PYTHON_DEVEL
test "x$1" != "xno" || swig_shadow=" -noproxy"
#
#set the swig options
#
AC_SUBST([SWIG_PYTHON_OPT],[-python])
#
#set the python compiler flags
#
AC_SUBST([SWIG_PYTHON_CPPFLAGS],[$PYTHON_CPPFLAGS])
fi
AC_ARG_VAR([SWIG_PYTHON_OPTS], [SWIG options for generating Python wrappers, default: -python])
if test x"$SWIG_PYTHON_OPTS" = x; then
SWIG_PYTHON_OPTS="-python"
fi
AC_ARG_VAR([SWIG_PYTHON_CFLAGS], [C compiler flags for compiling SWIG generated Python wrappers])
AC_ARG_ENABLE([python-bindings],
AC_HELP_STRING([--enable-python-bindings],
[enable generation of Python bindings, default: no]),
[if test "$enableval" = "yes"; then check_swig_python="yes"; force_swig_python="yes"; fi])
if test "$check_swig_python" = "yes"; then
AC_CHECK_PROG([PYTHON],[python[$PYTHON_VERSION]], [python[$PYTHON_VERSION]])
if test x"$PYTHON" = x; then
AC_MSG_NOTICE([error: no python$PYTHON_VERSION found; check Python installation first...])
swig_python_error="yes"
fi
if test x"$SWIG_PYTHON_CFLAGS" = x -a "$swig_python_error" = "no"; then
AC_CHECK_PROG([python_config], [python[$PYTHON_VERSION]-config], [python[$PYTHON_VERSION]-config])
if test x"$python_config" != x; then
AC_MSG_CHECKING([for python compiler flags])
SWIG_PYTHON_CFLAGS=`$python_config --cflags`
AC_MSG_RESULT([$SWIG_PYTHON_CFLAGS])
fi
fi
if test "$swig_python_error" = "no"; then
sav_PACKAGE=$PACKAGE
PACKAGE=`echo $PACKAGE | tr '[A-Z]' '[a-z]'`
AM_PATH_PYTHON([], [], [swig_python_error="yes"])
PACKAGE=$sav_PACKAGE
fi
if test "$swig_python_error" = "no"; then
sav_CPPFLAGS=$CPPFLAGS
sav_CFLAGS=$CFLAGS
CPPFLAGS="$CPPFLAGS $SWIG_PYTHON_CFLAGS"
CFLAGS="$CFLAGS $SWIG_PYTHON_CFLAGS"
AC_CHECK_HEADER([Python.h], [],
[
AC_MSG_NOTICE([error: no Python.h found; check Python installation and PYTHON_CFLAGS first...])
swig_python_error="yes"
])
CPPFLAGS=$sav_CPPFLAGS
CFLAGS=$sav_CFLAGS
fi
if test "$swig_python_error" = "no"; then
AC_MSG_CHECKING([whether python version >= 3.0.0])
pyver_major=`echo $PYTHON_VERSION | cut -d '.' -f 1`
if test $pyver_major -ge 3; then
req_swig_version="1.3.37"
AC_MSG_RESULT([yes])
AC_MSG_NOTICE([required SWIG version >= $req_swig_version])
else
AC_MSG_RESULT([no])
fi
AC_CHECK_PROG([SWIG], [swig], [swig])
if test x"$SWIG" = x; then
AC_MSG_NOTICE([error: no swig found; check SWIG installation first...])
swig_python_error="yes"
fi
fi
if test x"$req_swig_version" != x -a "$swig_python_error" = "no"; then
AC_MSG_CHECKING([for SWIG version])
swig_version=`$SWIG -version 2>&1 | grep "SWIG Version" | cut -d ' ' -f 3`
AC_MSG_RESULT([$swig_version])
if test x"$swig_version" = x ; then
AC_MSG_NOTICE([error: cannot determine SWIG version])
swig_python_error="yes"
else
req_major=`echo $req_swig_version | cut -d '.' -f 1`
avail_major=`echo $swig_version | cut -d '.' -f 1`
req_minor=`echo $req_swig_version | cut -d '.' -f 2`
avail_minor=`echo $swig_version | cut -d '.' -f 2`
req_patch=`echo $req_swig_version | cut -d '.' -f 3`
avail_patch=`echo $swig_version | cut -d '.' -f 3`
swig_python_error="yes"
if test $avail_major -gt $req_major ; then
swig_python_error="no"
elif test $avail_major -eq $req_major ; then
if test $avail_minor -gt $req_minor ; then
swig_python_error="no"
elif test $avail_minor -eq $req_minor ; then
if test $avail_patch -ge $req_patch ; then
swig_python_error="no"
fi
fi
fi
if test "$swig_python_error" = "yes" ; then
AC_MSG_NOTICE([error: SWIG version >= $req_swig_version required])
fi
fi
fi
if test "$swig_python_error" = "no"; then
have_swig_python="yes"
fi
fi
AC_SUBST(SWIG)
AC_SUBST(SWIG_PYTHON_CFLAGS)
AC_SUBST(SWIG_PYTHON_OPTS)
])

56
ompi/contrib/vt/vt/extlib/otf/configure.in
Просмотреть файл

@ -23,8 +23,17 @@ AC_PROG_CXX
AC_PROG_CC
AC_PROG_LIBTOOL
AC_C_BIGENDIAN
# Own stuff
# Add -D_GNU_SOURCE to CPPFLAGS, if necessary
case "$host_os" in
*-gnu*)
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
;;
esac
# Do we want to build and install binaries?
AC_ARG_ENABLE(binaries,
AC_HELP_STRING([--enable-binaries],
@ -32,8 +41,14 @@ AC_ARG_ENABLE(binaries,
[enable_binaries="$enableval"], [enable_binaries="yes"])
AM_CONDITIONAL(AMBUILDBINARIES, test x"$enable_binaries" = "xyes")
# Checks for MPI.
CHECK_MPI
if test x"$force_mpi" = "xyes" -a x"$mpi_error" = "xyes"; then exit 1; fi
AM_CONDITIONAL(AMHAVEMPI, test x"$have_mpi" = xyes)
# Checks for OpenMP.
CHECK_OMP
if test x"$force_omp" = "xyes" -a x"$omp_error" = "xyes"; then exit 1; fi
AM_CONDITIONAL(AMHAVEOMP, test x"$have_omp" = xyes)
# Checks for VTF3.
@ -50,8 +65,9 @@ AM_CONDITIONAL(AMHAVEZLIB, test x"$have_zlib" = xyes)
CHECK_MATH
# Checks for swig and python-dev.
SWIG_PYTHON
AM_CONDITIONAL(AMHAVEPYTHONSWIG, [test "$pythonexists" = yes -a "$swigexists" = yes] )
CHECK_SWIG_PYTHON
if test x"$force_swig_python" = "xyes" -a x"$swig_python_error" = "xyes"; then exit 1; fi
AM_CONDITIONAL(AMHAVESWIGPYTHON, test x"$have_swig_python" = xyes)
WITH_DEBUG
@ -60,7 +76,7 @@ WITH_VERBOSE
# Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS([stddef.h stdlib.h string.h sys/param.h sys/time.h unistd.h])
AC_CHECK_HEADERS([fcntl.h stddef.h stdlib.h string.h sys/param.h sys/select.h sys/time.h unistd.h])
AC_CHECK_HEADER([stdint.h], [have_stdint_h=1], [have_stdint_h=0])
AC_CHECK_HEADER([inttypes.h], [have_inttypes_h=1], [have_inttypes_h=0])
AC_SUBST([have_stdint_h])
@ -73,30 +89,38 @@ AC_CHECK_DECL([va_copy],
AC_CHECK_DECL([__va_copy],
[AC_DEFINE([HAVE_UNDERSCORE_VA_COPY], [1], [Define to 1 if you have the `__va_copy' function.])],
[], [#include <stdarg.h>])
AC_CHECK_FUNCS([asprintf snprintf vasprintf vsnprintf strdup fseeko ftello])
AC_CHECK_FUNCS([asprintf snprintf vasprintf vsnprintf strdup gettimeofday])
AC_FUNC_FSEEKO
#AC_FUNC_MALLOC
#AC_FUNC_REALLOC
#AC_FUNC_STAT
# Checks for typedefs, structures, and compiler characteristics.
# AC_C_CONST ### do not use this if you want to do C++ programs because it might define 'const'
# to an empty string which produces a total mess later on!!!
AC_CHECK_DECLS([O_NOATIME], [], [], [[#include <fcntl.h>]])
AC_TYPE_SIZE_T
#AC_HEADER_TIME
# Checks for library functions.
# AC_FUNC_FSEEKO
#AC_FUNC_MALLOC
#AC_FUNC_REALLOC
#AC_FUNC_STAT
#AC_CHECK_FUNCS([gettimeofday memmove strdup])
# Checks for datatype sizes.
AC_CHECK_SIZEOF(long, 8)
sizeof_long=$ac_cv_sizeof_long
AC_SUBST([sizeof_long])
# check for library with clock_gettime
pre_clock_gettime_LIBS="$LIBS"
CLOCK_GETTIME_LIB=
AC_SEARCH_LIBS([clock_gettime], [rt],
[test "x$ac_cv_search_clock_gettime" = "xnone required" || CLOCK_GETTIME_LIB="$ac_cv_search_clock_gettime"])
AM_CONDITIONAL([AMHAVECLOCKGETTIME], [test "x$ac_cv_search_clock_gettime" != "xno"])
AC_SUBST([CLOCK_GETTIME_LIB])
LIBS="$pre_clock_gettime_LIBS"
AC_CONFIG_FILES([Makefile
vendor/jenkins_hash/Makefile
otflib/Makefile
otflib/OTF_inttypes_unix.h
otfauxlib/Makefile
otflib_py/Makefile
tools/Makefile
tools/otfaux/Makefile
@ -105,10 +129,18 @@ AC_CONFIG_FILES([Makefile
tools/otfdump/Makefile
tools/otfinfo/Makefile
tools/otfmerge/Makefile
tools/otfmerge-mpi/Makefile
tools/otfprofile/Makefile
tools/otfprofile-mpi/Makefile
tools/otfshrink/Makefile
tools/otf2vtf/Makefile
tools/vtf2otf/Makefile
tests/Makefile
tests/hello/Makefile
tests/generic_streams/Makefile
tests/generic_streams-mpi/Makefile
tests/progress/Makefile
tests/read_from_buffer/Makefile
docu/Makefile
])

3
ompi/contrib/vt/vt/extlib/otf/docu/Makefile.am
Просмотреть файл

@ -2,7 +2,8 @@ otfdoc_DATA = \
$(top_srcdir)/ChangeLog \
$(top_srcdir)/LICENSE \
api/specification.pdf \
tools/otftools.pdf
tools/otftools.pdf \
tools/otfprofile.pdf
otfdocdir = $(docdir)

Двоичные данные
ompi/contrib/vt/vt/extlib/otf/docu/tools/otfprofile.pdf Обычный файл
Просмотреть файл

Двоичный файл не отображается.

Двоичные данные
ompi/contrib/vt/vt/extlib/otf/docu/tools/otftools.pdf
Просмотреть файл

Двоичный файл не отображается.

19
ompi/contrib/vt/vt/extlib/otf/otfauxlib/Makefile.am Обычный файл
Просмотреть файл

@ -0,0 +1,19 @@
include_HEADERS = otfaux.h \
OTFAUX_MsgMatching.h
noinst_HEADERS =
lib_LTLIBRARIES = libotfaux.la
libotfaux_la_CPPFLAGS = $(AM_CPPFLAGS) \
-I$(top_builddir)/otflib \
-I$(top_srcdir)/otflib \
-I$(top_srcdir)/vendor/jenkins_hash
libotfaux_la_CFLAGS = -prefer-pic
#libotfaux_la_LDFLAGS = -version-info @OTF_VERSION_LIBRARY@
libotfaux_la_LIBADD = $(top_builddir)/vendor/jenkins_hash/libjenkins_hash.la
libotfaux_la_SOURCES = \
OTFAUX_MsgMatching.c
EXTRA_DIST =

295
ompi/contrib/vt/vt/extlib/otf/otfauxlib/OTFAUX_MsgMatching.c Обычный файл
Просмотреть файл

@ -0,0 +1,295 @@
#include <config.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <otf.h>
#include <jenkins_hash.h>
#include "otfaux.h"
typedef struct OTFAUX_MsgMatching_Recv {
/** next in queue */
struct OTFAUX_MsgMatching_Recv* next;
uint64_t time;
uint32_t size, scl;
} OTFAUX_MsgMatching_Recv;
typedef struct OTFAUX_MsgMatching_Queue {
/** for hash chaining */
struct OTFAUX_MsgMatching_Queue* next;
uint64_t sender, receiver;
uint32_t tag, comm;
/** cached hash value of this queue */
uint32_t hash;
/** queue of receives */
OTFAUX_MsgMatching_Recv* head;
OTFAUX_MsgMatching_Recv** tail;
} OTFAUX_MsgMatching_Queue;
#define QUEUE_HASH_SHIFT 10
#define QUEUE_HASH_SIZE (1 << QUEUE_HASH_SHIFT)
#define QUEUE_HASH_MASK (QUEUE_HASH_SIZE - 1)
struct OTFAUX_MsgMatching_Context {
/** The messages queues, identified by the quadtrupel
(sender, receiver, tag, comm) */
OTFAUX_MsgMatching_Queue* queues[ QUEUE_HASH_SIZE ];
/** unused OTFAUX_MsgMatching_Recv objects */
OTFAUX_MsgMatching_Recv* free_list;
};
OTFAUX_MsgMatching_Context*
OTFAUX_MsgMatching_create( void )
{
OTFAUX_MsgMatching_Context* new_context = calloc( 1, sizeof( *new_context ) );
/* nothing to initialize */
return new_context;
}
static void
free_recv_list( OTFAUX_MsgMatching_Recv** recv_list )
{
while ( *recv_list )
{
OTFAUX_MsgMatching_Recv* next = ( *recv_list )->next;
free( *recv_list );
*recv_list = next;
}
}
void
OTFAUX_MsgMatching_destroy( OTFAUX_MsgMatching_Context* mm_context )
{
int i;
for ( i = 0; i < QUEUE_HASH_SIZE; i++ )
{
while ( mm_context->queues[ i ] )
{
OTFAUX_MsgMatching_Queue* next = mm_context->queues[ i ]->next;
free_recv_list( &mm_context->queues[ i ]->head );
free( mm_context->queues[ i ] );
mm_context->queues[ i ] = next;
}
}
free_recv_list( &mm_context->free_list );
free( mm_context );
}
/* hashing of queues */
static uint32_t
hash_queue( uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm )
{
uint32_t queue_hash = 0;
queue_hash += hash( &sender, sizeof( sender ), queue_hash );
queue_hash += hash( &receiver, sizeof( receiver ), queue_hash );
queue_hash += hash( &tag, sizeof( tag ), queue_hash );
queue_hash += hash( &comm, sizeof( comm ), queue_hash );
return queue_hash;
}
static OTFAUX_MsgMatching_Queue*
create_queue( uint32_t queue_hash,
uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm )
{
OTFAUX_MsgMatching_Queue* new_queue = calloc( 1, sizeof( *new_queue ) );
if ( new_queue )
{
/* store queue atttributes */
new_queue->sender = sender;
new_queue->receiver = receiver;
new_queue->tag = tag;
new_queue->comm = comm;
/* cache hash value for this queue */
new_queue->hash = queue_hash;
/* initialize the recv queue */
new_queue->tail = &new_queue->head;
}
return new_queue;
}
static OTFAUX_MsgMatching_Queue*
get_queue( OTFAUX_MsgMatching_Context* mm_context,
uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm,
int create )
{
uint32_t queue_hash = hash_queue( sender, receiver, tag, comm );
OTFAUX_MsgMatching_Queue** queue_bucket = &mm_context->queues[ queue_hash & QUEUE_HASH_MASK ];
OTFAUX_MsgMatching_Queue* queue = *queue_bucket;
/* search in hash chain */
while ( queue )
{
if ( queue->hash == queue_hash
&& queue->sender == sender
&& queue->receiver == receiver
&& queue->tag == tag
&& queue->comm == comm )
{
/* found */
return queue;
}
queue = queue->next;
}
if ( create )
{
queue = create_queue( queue_hash, sender, receiver, tag, comm );
if ( !queue )
{
return NULL;
}
/* chain into hash table */
queue->next = *queue_bucket;
*queue_bucket = queue;
}
return queue;
}
void
OTFAUX_MsgMatching_enqueueRecv( OTFAUX_MsgMatching_Context* mm_context,
uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm,
uint64_t time,
uint32_t size,
uint32_t scl )
{
OTFAUX_MsgMatching_Queue* queue;
OTFAUX_MsgMatching_Recv* new_recv;
/* create this queue if its not present */
queue = get_queue( mm_context, sender, receiver, tag, comm, 1 );
/* create new recv entry, use free_list if possible */
if ( mm_context->free_list )
{
new_recv = mm_context->free_list;
mm_context->free_list = new_recv->next;
new_recv->next = NULL;
} else {
new_recv = calloc( 1, sizeof( *new_recv ) );
if ( !new_recv )
{
return;
}
}
new_recv->time = time;
new_recv->size = size;
new_recv->scl = scl;
/* enqueue recv into queue */
*queue->tail = new_recv;
queue->tail = &new_recv->next;
}
int
OTFAUX_MsgMatching_matchSend( OTFAUX_MsgMatching_Context* mm_context,
uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm,
uint64_t* ptime,
uint32_t* psize,
uint32_t* pscl )
{
OTFAUX_MsgMatching_Queue* queue;
OTFAUX_MsgMatching_Recv* recv;
/* don't create this queue if its not present */
queue = get_queue( mm_context, sender, receiver, tag, comm, 0 );
/* no queue -> no recv || no recv in queue */
if ( !queue || !queue->head )
{
return 0;
}
/* unqeue recv */
recv = queue->head;
queue->head = recv->next;
if ( !queue->head )
{
queue->tail = &queue->head;
}
if ( ptime )
{
*ptime = recv->time;
}
if ( psize )
{
*psize = recv->size;
}
if ( pscl )
{
*pscl = recv->scl;
}
/* put the now unused recv object into free list */
recv->next = mm_context->free_list;
mm_context->free_list = recv;
return 1;
}
/** release empty queues and recv in free list */
void
OTFAUX_MsgMatching_releaseMemory( OTFAUX_MsgMatching_Context* mm_context )
{
int i;
for ( i = 0; i < QUEUE_HASH_SIZE; i++ )
{
OTFAUX_MsgMatching_Queue* full_queue = NULL;
OTFAUX_MsgMatching_Queue* queue = mm_context->queues[ i ];
while ( queue )
{
OTFAUX_MsgMatching_Queue* next = queue->next;
/* release this queue if no recv are enqueued */
if ( queue->head )
{
queue->next = full_queue;
full_queue = queue;
}
else
{
free( queue );
}
queue = next;
}
mm_context->queues[ i ] = full_queue;
}
free_recv_list( &mm_context->free_list );
}

92
ompi/contrib/vt/vt/extlib/otf/otfauxlib/OTFAUX_MsgMatching.h Обычный файл
Просмотреть файл

@ -0,0 +1,92 @@
#ifndef OTFAUX_MSGMATCHING_H
#define OTFAUX_MSGMATCHING_H
#include <otf.h>
/**
* @file otfauxlib/OTFAUX_MsgMatching.h
*
* @brief Provides a module to match MPI P2P massages.
*/
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @defgroup msgmatch Module to match messages.
*
* @{
*/
/** Opaque type for using the matching module. */
typedef struct OTFAUX_MsgMatching_Context OTFAUX_MsgMatching_Context;
/** Create a context for matching messages. */
OTFAUX_MsgMatching_Context* OTFAUX_MsgMatching_create( void );
/** Destroy a context previously created with @a OTFAUX_MsgMatching_Create. */
void OTFAUX_MsgMatching_destroy( OTFAUX_MsgMatching_Context* mm_context );
/** Provide a recv event for matching. */
void OTFAUX_MsgMatching_enqueueRecv( OTFAUX_MsgMatching_Context* mm_context,
uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm,
uint64_t time,
uint32_t size,
uint32_t scl );
/**
* Try to match a send with the corresponding recv.
*
* @return 1 for success
* 0 for no recv
*/
int OTFAUX_MsgMatching_matchSend( OTFAUX_MsgMatching_Context* mm_context,
uint64_t sender,
uint64_t receiver,
uint32_t tag,
uint32_t comm,
uint64_t* ptime,
uint32_t* psize,
uint32_t* pscl );
/**
* If you think the OTFAUX_MsgMatching_Context holds to much memory, you can
* order him to release unused memory.
*
*/
void OTFAUX_MsgMatching_releaseMemory( OTFAUX_MsgMatching_Context* mm_context );
/**
* @}
*/
/**
* @defgroup otfauxtud Special KeyValue names/types for messages matching used
* by the TU Dresden
*
* @{
*/
#define OTFAUX_KEYVALUE_TUD_P2P_RECEIVED_TIME_NAME "TUD::p2p-received-time"
#define OTFAUX_KEYVALUE_TUD_P2P_RECEIVED_TIME_TYPE OTF_UINT64
#define OTFAUX_KEYVALUE_TUD_P2P_RECEIVED_SIZE_NAME "TUD::p2p-received-size"
#define OTFAUX_KEYVALUE_TUD_P2P_RECEIVED_SIZE_TYPE OTF_UINT32
#define OTFAUX_KEYVALUE_TUD_P2P_RECEIVED_SCL_NAME "TUD::p2p-received-scl"
#define OTFAUX_KEYVALUE_TUD_P2P_RECEIVED_SCL_TYPE OTF_UINT32
/**
* @}
*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OTFAUX_MSGMATCHING_H */

13
ompi/contrib/vt/vt/extlib/otf/otfauxlib/otfaux.h Обычный файл
Просмотреть файл

@ -0,0 +1,13 @@
#ifndef OTFAUX_H
#define OTFAUX_H
#include <otf.h>
/**
* @file otfauxlib/otfaux.h
*
*/
#include <OTFAUX_MsgMatching.h>
#endif /* OTFAUX_H */

4
ompi/contrib/vt/vt/extlib/otf/otflib/Makefile.am
Просмотреть файл

@ -2,6 +2,7 @@ INCLUDES = $(ZLIB_INCLUDE_LINE)
include_HEADERS = otf.h \
OTF_CopyHandler.h \
OTF_CopyHandler_stream.h \
OTF_Definitions.h \
OTF_Errno.h \
OTF_File.h \
@ -9,6 +10,7 @@ include_HEADERS = otf.h \
OTF_Filenames.h \
OTF_HandlerArray.h \
OTF_inttypes.h \
OTF_KeyValue.h \
OTF_MasterControl.h \
OTF_RBuffer.h \
OTF_RStream.h \
@ -33,11 +35,13 @@ libotf_la_LDFLAGS = -version-info @OTF_VERSION_LIBRARY@
libotf_la_LIBADD = $(ZLIB_LIB_LINE)
libotf_la_SOURCES = \
OTF_CopyHandler.c \
OTF_CopyHandler_stream.c \
OTF_Errno.c \
OTF_File.c \
OTF_FileManager.c \
OTF_Filenames.c \
OTF_HandlerArray.c \
OTF_KeyValue.c \
OTF_MasterControl.c \
OTF_Parse.c \
OTF_Platform.c \

391
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_CopyHandler.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -16,103 +16,118 @@
/* *** Definition handlers *** ************************************* */
int OTF_CopyHandler_DefinitionComment( void* userData, uint32_t stream,
const char* comment ) {
const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefinitionComment( (OTF_Writer*)userData, stream,
comment ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefinitionCommentKV( (OTF_Writer*)userData, stream,
comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefTimerResolution( void* userData,
uint32_t stream, uint64_t ticksPerSecond ) {
int OTF_CopyHandler_DefTimerResolution( void* userData, uint32_t stream,
uint64_t ticksPerSecond, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefTimerResolution( (OTF_Writer*)userData, stream,
ticksPerSecond ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefTimerResolutionKV( (OTF_Writer*)userData, stream,
ticksPerSecond, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefProcess( void* userData, uint32_t stream,
uint32_t deftoken, const char* name, uint32_t parent ) {
int OTF_CopyHandler_DefProcess( void* userData, uint32_t stream, uint32_t deftoken,
const char* name, uint32_t parent, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefProcess( (OTF_Writer*)userData, stream,
deftoken, name, parent ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefProcessKV( (OTF_Writer*)userData, stream,
deftoken, name, parent, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefProcessGroup( void* userData, uint32_t stream,
uint32_t deftoken, const char* name, uint32_t n, const uint32_t* procs ) {
int OTF_CopyHandler_DefProcessGroup( void* userData, uint32_t stream, uint32_t deftoken,
const char* name, uint32_t n, const uint32_t* procs, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefProcessGroup( (OTF_Writer*)userData, stream, deftoken,
name, n, procs ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefProcessGroupKV( (OTF_Writer*)userData, stream, deftoken,
name, n, procs, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefAttributeList( void* userData, uint32_t stream, uint32_t attr_token,
uint32_t num, OTF_ATTR_TYPE* array, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefAttributeListKV( (OTF_Writer*)userData, stream, attr_token,
num, array, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefProcessOrGroupAttributes( void* userData, uint32_t stream, uint32_t proc_token,
uint32_t attr_token, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefProcessOrGroupAttributesKV( (OTF_Writer*)userData, stream, proc_token,
attr_token, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefFunction( void* userData, uint32_t stream,
uint32_t deftoken, const char* name,
uint32_t group, uint32_t scltoken ) {
uint32_t group, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefFunction( (OTF_Writer*)userData, stream, deftoken,
name, group, scltoken ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefFunctionKV( (OTF_Writer*)userData, stream, deftoken,
name, group, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefFunctionGroup( void* userData, uint32_t stream,
uint32_t deftoken, const char* name ) {
uint32_t deftoken, const char* name, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefFunctionGroup( (OTF_Writer*)userData, stream,
deftoken, name ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefFunctionGroupKV( (OTF_Writer*)userData, stream,
deftoken, name, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefCollectiveOperation( void* userData, uint32_t stream,
uint32_t collOp, const char* name, uint32_t type ) {
uint32_t collOp, const char* name, uint32_t type, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefCollectiveOperation( (OTF_Writer*)userData, stream,
collOp, name, type ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefCollectiveOperationKV( (OTF_Writer*)userData, stream,
collOp, name, type, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefCounter( void* userData, uint32_t stream,
uint32_t deftoken, const char* name, uint32_t properties,
uint32_t countergroup, const char* unit ) {
uint32_t countergroup, const char* unit, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefCounter( (OTF_Writer*)userData, stream,
deftoken, name, properties, countergroup, unit ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefCounterKV( (OTF_Writer*)userData, stream,
deftoken, name, properties, countergroup, unit, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefCounterGroup( void* userData, uint32_t stream,
uint32_t deftoken, const char* name ) {
uint32_t deftoken, const char* name, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefCounterGroup( (OTF_Writer*)userData, stream,
deftoken, name ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefCounterGroupKV( (OTF_Writer*)userData, stream,
deftoken, name, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefScl( void* userData, uint32_t stream,
uint32_t deftoken, uint32_t sclfile, uint32_t sclline ) {
int OTF_CopyHandler_DefScl( void* userData, uint32_t stream, uint32_t deftoken,
uint32_t sclfile, uint32_t sclline, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefScl( (OTF_Writer*)userData, stream, deftoken,
sclfile, sclline ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefSclKV( (OTF_Writer*)userData, stream, deftoken,
sclfile, sclline, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefSclFile( void* userData, uint32_t stream,
uint32_t deftoken, const char* filename ) {
uint32_t deftoken, const char* filename, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefSclFile( (OTF_Writer*)userData, stream,
deftoken, filename ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefSclFileKV( (OTF_Writer*)userData, stream,
deftoken, filename, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
@ -127,211 +142,262 @@ int OTF_CopyHandler_DefVersion( void* userData, uint32_t stream,
int OTF_CopyHandler_DefCreator( void* userData, uint32_t stream,
const char* creator ) {
const char* creator, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefCreator( (OTF_Writer*)userData, stream, creator )
return ( 0 == OTF_Writer_writeDefCreatorKV( (OTF_Writer*)userData, stream, creator, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefFile( void* userData, uint32_t stream, uint32_t token,
const char* name, uint32_t group ) {
const char* name, uint32_t group, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefFile( (OTF_Writer*)userData, stream, token,
name, group ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefFileKV( (OTF_Writer*)userData, stream, token,
name, group, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefFileGroup( void* userData, uint32_t stream,
uint32_t token, const char* name ) {
uint32_t token, const char* name, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefFileGroup( (OTF_Writer*)userData, stream, token,
name ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeDefFileGroupKV( (OTF_Writer*)userData, stream, token,
name, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefKeyValue( void* userData, uint32_t stream, uint32_t key,
OTF_Type type, const char* name, const char *description, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefKeyValueKV( (OTF_Writer*)userData, stream, key,
type, name, description, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefTimeRange( void* userData,
uint32_t stream,
uint64_t minTime,
uint64_t maxTime,
OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefTimeRange( (OTF_Writer*)userData,
stream,
minTime,
maxTime,
list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefCounterAssignments( void* userData,
uint32_t stream,
uint32_t counter,
uint32_t number_of_members,
const uint32_t* procs_or_groups,
OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeDefCounterAssignments( (OTF_Writer*)userData,
stream,
counter,
number_of_members,
procs_or_groups,
list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
/* *** Event handlers *** ****************************************** */
int OTF_CopyHandler_NoOp( void* userData, uint64_t time, uint32_t process,
OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeNoOpKV( (OTF_Writer*)userData, time,
process, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_EventComment( void* userData, uint64_t time, uint32_t process,
const char* comment ) {
const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeEventComment( (OTF_Writer*)userData, time,
process, comment ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeEventCommentKV( (OTF_Writer*)userData, time,
process, comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_Counter( void* userData, uint64_t time,
uint32_t process, uint32_t counter_token, uint64_t value ) {
int OTF_CopyHandler_Counter( void* userData, uint64_t time, uint32_t process,
uint32_t counter_token, uint64_t value, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeCounter( (OTF_Writer*)userData, time,
process, counter_token, value ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeCounterKV( (OTF_Writer*)userData, time,
process, counter_token, value, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_Enter( void* userData, uint64_t time,
uint32_t statetoken, uint32_t cpuid, uint32_t scltoken ) {
int OTF_CopyHandler_Enter( void* userData, uint64_t time, uint32_t statetoken,
uint32_t cpuid, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeEnter( (OTF_Writer*)userData, time,
statetoken, cpuid, scltoken ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeEnterKV( (OTF_Writer*)userData, time,
statetoken, cpuid, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_CollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t functionToken, uint32_t communicator,
uint32_t rootprocess, uint32_t sent, uint32_t received,
uint64_t duration, uint32_t scltoken ) {
uint64_t duration, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeCollectiveOperation( (OTF_Writer*)userData, time,
return ( 0 == OTF_Writer_writeCollectiveOperationKV( (OTF_Writer*)userData, time,
process, functionToken, communicator, rootprocess,
sent, received, duration, scltoken ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
sent, received, duration, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_BeginCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t collOp, uint64_t matchingId,
uint32_t procGroup, uint32_t rootProc, uint64_t sent,
uint64_t received, uint32_t scltoken )
uint64_t received, uint32_t scltoken, OTF_KeyValueList* list )
{
return (0 == OTF_Writer_writeBeginCollectiveOperation(
return (0 == OTF_Writer_writeBeginCollectiveOperationKV(
(OTF_Writer*) userData, time, process, collOp,
matchingId, procGroup, rootProc, sent, received,
scltoken )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
scltoken, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_EndCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint64_t matchingId )
uint32_t process, uint64_t matchingId, OTF_KeyValueList* list )
{
return (0 == OTF_Writer_writeEndCollectiveOperation(
return (0 == OTF_Writer_writeEndCollectiveOperationKV(
(OTF_Writer*) userData, time, process,
matchingId )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
matchingId, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_RecvMsg( void* userData, uint64_t time,
uint32_t receiver, uint32_t sender, uint32_t communicator,
uint32_t msgtype, uint32_t msglength, uint32_t scltoken ) {
uint32_t msgtype, uint32_t msglength, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeRecvMsg( (OTF_Writer*)userData, time, receiver,
sender, communicator, msgtype, msglength, scltoken ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeRecvMsgKV( (OTF_Writer*)userData, time, receiver,
sender, communicator, msgtype, msglength, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_SendMsg( void* userData, uint64_t time,
uint32_t sender, uint32_t receiver, uint32_t communicator,
uint32_t msgtype, uint32_t msglength, uint32_t scltoken ) {
uint32_t msgtype, uint32_t msglength, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeSendMsg( (OTF_Writer*)userData, time, sender,
receiver, communicator, msgtype, msglength, scltoken ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeSendMsgKV( (OTF_Writer*)userData, time, sender,
receiver, communicator, msgtype, msglength, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_Leave( void* userData, uint64_t time,
uint32_t statetoken, uint32_t cpuid, uint32_t scltoken ) {
int OTF_CopyHandler_Leave( void* userData, uint64_t time, uint32_t statetoken,
uint32_t cpuid, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeLeave( (OTF_Writer*)userData, time, statetoken,
cpuid, scltoken ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeLeaveKV( (OTF_Writer*)userData, time, statetoken,
cpuid, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_BeginProcess( void* userData, uint64_t time,
uint32_t process ) {
uint32_t process, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeBeginProcess( (OTF_Writer*)userData, time,
process ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeBeginProcessKV( (OTF_Writer*)userData, time,
process, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_EndProcess( void* userData, uint64_t time,
uint32_t process ) {
uint32_t process, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeEndProcess( (OTF_Writer*)userData, time,
process ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeEndProcessKV( (OTF_Writer*)userData, time,
process, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_FileOperation( void* userData, uint64_t time, uint32_t fileid,
uint32_t process, uint64_t handleid, uint32_t operation, uint64_t bytes,
uint64_t duration, uint32_t source ) {
uint64_t duration, uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeFileOperation( (OTF_Writer*)userData, time, fileid,
process, handleid, operation, bytes, duration, source )
return ( 0 == OTF_Writer_writeFileOperationKV( (OTF_Writer*)userData, time, fileid,
process, handleid, operation, bytes, duration, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_BeginFileOperation( void* userData, uint64_t time,
uint32_t process, uint64_t handleid, uint32_t scltoken )
uint32_t process, uint64_t matchingId, uint32_t scltoken,
OTF_KeyValueList* list )
{
return (0 == OTF_Writer_writeBeginFileOperation(
(OTF_Writer*) userData, time, process, handleid,
scltoken )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return (0 == OTF_Writer_writeBeginFileOperationKV(
(OTF_Writer*) userData, time, process, matchingId,
scltoken, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_EndFileOperation( void* userData, uint64_t time,
uint32_t process, uint32_t fileid, uint64_t handleid,
uint32_t operation, uint64_t bytes, uint32_t scltoken )
uint32_t process, uint32_t fileid, uint64_t matchingId,
uint64_t handleId, uint32_t operation, uint64_t bytes,
uint32_t scltoken, OTF_KeyValueList* list )
{
return (0 == OTF_Writer_writeEndFileOperation( (OTF_Writer*) userData,
time, process, fileid, handleid, operation, bytes,
scltoken )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return (0 == OTF_Writer_writeEndFileOperationKV( (OTF_Writer*) userData,
time, process, fileid, matchingId, handleId, operation, bytes,
scltoken, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_RMAPut( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken ) {
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeRMAPut( (OTF_Writer*)userData, time,
process, origin, target, communicator, tag, bytes, scltoken )
return ( 0 == OTF_Writer_writeRMAPutKV( (OTF_Writer*)userData, time,
process, origin, target, communicator, tag, bytes, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_RMAPutRemoteEnd( void* userData, uint64_t time,
uint32_t process, uint32_t origin, uint32_t target, uint32_t communicator,
uint32_t tag, uint64_t bytes, uint32_t scltoken ) {
uint32_t tag, uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeRMAPutRemoteEnd( (OTF_Writer*)userData,
time, process, origin, target, communicator, tag, bytes, scltoken )
return ( 0 == OTF_Writer_writeRMAPutRemoteEndKV( (OTF_Writer*)userData,
time, process, origin, target, communicator, tag, bytes, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_RMAGet( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken) {
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeRMAGet( (OTF_Writer*)userData, time,
process, origin, target, communicator, tag, bytes, scltoken )
return ( 0 == OTF_Writer_writeRMAGetKV( (OTF_Writer*)userData, time,
process, origin, target, communicator, tag, bytes, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_RMAEnd( void* userData, uint64_t time, uint32_t process,
uint32_t remote, uint32_t communicator, uint32_t tag, uint32_t scltoken ) {
int OTF_CopyHandler_RMAEnd( void* userData, uint64_t time, uint32_t process, uint32_t remote,
uint32_t communicator, uint32_t tag, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeRMAEnd( (OTF_Writer*)userData, time,
process, remote, communicator, tag, scltoken )
return ( 0 == OTF_Writer_writeRMAEndKV( (OTF_Writer*)userData, time,
process, remote, communicator, tag, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
@ -340,73 +406,102 @@ int OTF_CopyHandler_RMAEnd( void* userData, uint64_t time, uint32_t process,
int OTF_CopyHandler_SnapshotComment( void* userData, uint64_t time,
uint32_t process, const char* comment ) {
uint32_t process, const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeSnapshotComment( (OTF_Writer*)userData,
time, process, comment ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeSnapshotCommentKV( (OTF_Writer*)userData,
time, process, comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_EnterSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t function, uint32_t process,
uint32_t source ) {
uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeEnterSnapshot( (OTF_Writer*)userData,
time, originaltime, function, process, source )
return ( 0 == OTF_Writer_writeEnterSnapshotKV( (OTF_Writer*)userData,
time, originaltime, function, process, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_SendSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t sender, uint32_t receiver,
uint32_t procGroup, uint32_t tag, uint32_t source ) {
uint32_t procGroup, uint32_t tag, uint32_t length,
uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeSendSnapshot( (OTF_Writer*)userData,
time, originaltime, sender, receiver, procGroup, tag, source )
return ( 0 == OTF_Writer_writeSendSnapshotKV( (OTF_Writer*)userData,
time, originaltime, sender, receiver, procGroup, tag, length, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_OpenFileSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t fileid, uint32_t process, uint64_t handleid,
uint32_t source ) {
uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeOpenFileSnapshot( (OTF_Writer*)userData, time,
originaltime, fileid, process, handleid, source )
return ( 0 == OTF_Writer_writeOpenFileSnapshotKV( (OTF_Writer*)userData, time,
originaltime, fileid, process, handleid, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_BeginCollopSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint32_t collOp,
uint64_t matchingId, uint32_t procGroup, uint32_t rootProc,
uint64_t sent, uint64_t received, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeBeginCollopSnapshotKV( (OTF_Writer*)userData, time,
originaltime, process, collOp, matchingId, procGroup, rootProc, sent, received,
scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_BeginFileOpSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint64_t matchingId,
uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeBeginFileOpSnapshotKV( (OTF_Writer*)userData, time,
originaltime, process, matchingId, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
/* *** summary handlers ********************************************** */
int OTF_CopyHandler_SummaryComment( void * userData, uint64_t time,
uint32_t process, const char* comment ) {
uint32_t process, const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeSummaryComment( (OTF_Writer*)userData,
time, process, comment ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeSummaryCommentKV( (OTF_Writer*)userData,
time, process, comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_FunctionSummary( void* userData,
uint64_t time, uint32_t function, uint32_t process,
uint64_t count, uint64_t excltime, uint64_t incltime ) {
uint64_t count, uint64_t excltime, uint64_t incltime,
OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeFunctionSummary( (OTF_Writer*)userData,
time, function, process, count, excltime, incltime )
return ( 0 == OTF_Writer_writeFunctionSummaryKV( (OTF_Writer*)userData,
time, function, process, count, excltime, incltime, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_FunctionGroupSummary( void* userData,
uint64_t time, uint32_t functiongroup, uint32_t process,
uint64_t count, uint64_t excltime, uint64_t incltime ) {
uint64_t count, uint64_t excltime, uint64_t incltime,
OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeFunctionGroupSummary( (OTF_Writer*)userData,
time, functiongroup, process, count, excltime, incltime )
return ( 0 == OTF_Writer_writeFunctionGroupSummaryKV( (OTF_Writer*)userData,
time, functiongroup, process, count, excltime, incltime, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
@ -414,66 +509,68 @@ int OTF_CopyHandler_FunctionGroupSummary( void* userData,
int OTF_CopyHandler_MessageSummary( void* userData, uint64_t time,
uint32_t process, uint32_t peer, uint32_t comm, uint32_t type,
uint64_t sentNumber, uint64_t receivedNumber, uint64_t sentBytes,
uint64_t receivedBytes ) {
uint64_t receivedBytes, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeMessageSummary((OTF_Writer*) userData,
return ( 0 == OTF_Writer_writeMessageSummaryKV((OTF_Writer*) userData,
time, process, peer, comm, type, sentNumber, receivedNumber, sentBytes,
receivedBytes ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
receivedBytes, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_CollopSummary( void *userData, uint64_t time,
uint32_t process, uint32_t comm, uint32_t collective, uint64_t sentNumber,
uint64_t receivedNumber, uint64_t sentBytes, uint64_t receivedBytes ) {
uint64_t receivedNumber, uint64_t sentBytes, uint64_t receivedBytes,
OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeCollopSummary((OTF_Writer*) userData,
return ( 0 == OTF_Writer_writeCollopSummaryKV((OTF_Writer*) userData,
time, process, comm, collective, sentNumber, receivedNumber, sentBytes,
receivedBytes ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
receivedBytes, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_FileOperationSummary( void* userData, uint64_t time,
uint32_t fileid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite ) {
uint64_t byteswrite, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeFileOperationSummary( (OTF_Writer*) userData,
return ( 0 == OTF_Writer_writeFileOperationSummaryKV( (OTF_Writer*) userData,
time, fileid, process, nopen, nclose, nread, nwrite, nseek,
bytesread, byteswrite ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
bytesread, byteswrite, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_FileGroupOperationSummary( void* userData, uint64_t time,
uint32_t groupid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite ) {
uint64_t byteswrite, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeFileGroupOperationSummary( (OTF_Writer*) userData,
return ( 0 == OTF_Writer_writeFileGroupOperationSummaryKV( (OTF_Writer*) userData,
time, groupid, process, nopen, nclose, nread, nwrite, nseek,
bytesread, byteswrite ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
bytesread, byteswrite, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_DefMarker( void *userData, uint32_t stream,
uint32_t token, const char* name, uint32_t type ) {
uint32_t token, const char* name, uint32_t type, OTF_KeyValueList* list ) {
/* even if marker definitions could be read from many streams, they are
written to stream 0 forcedly, because this is where all markers belong. */
stream= 0;
return ( 0 == OTF_Writer_writeDefMarker( (OTF_Writer*) userData,
stream, token, name, type ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;;
return ( 0 == OTF_Writer_writeDefMarkerKV( (OTF_Writer*) userData,
stream, token, name, type, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;;
}
int OTF_CopyHandler_Marker( void *userData, uint64_t time,
uint32_t process, uint32_t token, const char* text ) {
uint32_t process, uint32_t token, const char* text, OTF_KeyValueList* list ) {
return ( 0 == OTF_Writer_writeMarker( (OTF_Writer*) userData,
time, process, token, text ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
return ( 0 == OTF_Writer_writeMarkerKV( (OTF_Writer*) userData,
time, process, token, text, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}

141
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_CopyHandler.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -11,185 +11,220 @@
* \ingroup internal
*/
#ifndef OTF_COPYOTF_CopyHandler_R_H
#define OTF_COPYOTF_CopyHandler_R_H
#ifndef OTF_COPYHANDLER_H
#define OTF_COPYHANDLER_H
#include "OTF_inttypes.h"
#include "OTF_Definitions.h"
#include "OTF_KeyValue.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/* *** Definition OTF_CopyHandler_r *** ************************************* */
int OTF_CopyHandler_DefinitionComment( void* userData, uint32_t stream,
const char* comment );
const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_DefTimerResolution( void* userData, uint32_t stream,
uint64_t ticksPerSecond );
uint64_t ticksPerSecond, OTF_KeyValueList* list );
int OTF_CopyHandler_DefProcess( void* userData, uint32_t stream, uint32_t process,
const char* name, uint32_t parent );
const char* name, uint32_t parent, OTF_KeyValueList* list );
int OTF_CopyHandler_DefProcessGroup( void* userData, uint32_t stream,
uint32_t procGroup, const char* name, uint32_t numberOfProcs,
const uint32_t* procs );
const uint32_t* procs, OTF_KeyValueList* list );
int OTF_CopyHandler_DefAttributeList( void* userData, uint32_t stream,
uint32_t attr_token, uint32_t num, OTF_ATTR_TYPE* array, OTF_KeyValueList* list );
int OTF_CopyHandler_DefProcessOrGroupAttributes( void* userData, uint32_t stream,
uint32_t proc_token, uint32_t attr_token, OTF_KeyValueList* list );
int OTF_CopyHandler_DefFunction( void* userData, uint32_t stream, uint32_t func,
const char* name, uint32_t funcGroup, uint32_t source );
const char* name, uint32_t funcGroup, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_DefFunctionGroup( void* userData, uint32_t stream,
uint32_t funcGroup, const char* name );
uint32_t funcGroup, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_DefCollectiveOperation( void* userData, uint32_t stream,
uint32_t collOp, const char* name, uint32_t type );
uint32_t collOp, const char* name, uint32_t type, OTF_KeyValueList* list );
int OTF_CopyHandler_DefCounter( void* userData, uint32_t stream, uint32_t counter,
const char* name, uint32_t properties, uint32_t counterGroup,
const char* unit );
const char* unit, OTF_KeyValueList* list );
int OTF_CopyHandler_DefCounterGroup( void* userData, uint32_t stream,
uint32_t counterGroup, const char* name );
uint32_t counterGroup, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_DefScl( void* userData, uint32_t stream, uint32_t source,
uint32_t sourceFile, uint32_t line );
uint32_t sourceFile, uint32_t line, OTF_KeyValueList* list );
int OTF_CopyHandler_DefSclFile( void* userData, uint32_t stream,
uint32_t sourceFile, const char* name );
uint32_t sourceFile, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_DefVersion( void* userData, uint32_t stream,
uint8_t major, uint8_t minor, uint8_t sub, const char* string );
int OTF_CopyHandler_DefCreator( void* userData, uint32_t stream,
const char* creator );
const char* creator, OTF_KeyValueList* list );
int OTF_CopyHandler_DefFile( void* userData, uint32_t stream, uint32_t token,
const char* name, uint32_t group );
const char* name, uint32_t group, OTF_KeyValueList* list );
int OTF_CopyHandler_DefFileGroup( void* userData, uint32_t stream,
uint32_t token, const char* name );
uint32_t token, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_DefKeyValue( void* userData, uint32_t stream, uint32_t key,
OTF_Type type, const char* name, const char* description, OTF_KeyValueList* list );
int OTF_CopyHandler_DefTimeRange( void* userData,
uint32_t stream,
uint64_t minTime,
uint64_t maxTime,
OTF_KeyValueList* list );
int OTF_CopyHandler_DefCounterAssignments( void* userData,
uint32_t stream,
uint32_t counter,
uint32_t number_of_members,
const uint32_t* procs_or_groups,
OTF_KeyValueList* list );
int OTF_CopyHandler_NoOp( void* userData, uint64_t time, uint32_t process,
OTF_KeyValueList* list );
int OTF_CopyHandler_Enter( void* userData, uint64_t time, uint32_t function,
uint32_t process, uint32_t source );
uint32_t process, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_Leave( void* userData, uint64_t time, uint32_t function,
uint32_t process, uint32_t source );
uint32_t process, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_SendMsg( void* userData, uint64_t time, uint32_t sender,
uint32_t receiver, uint32_t group, uint32_t type, uint32_t length,
uint32_t source );
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_RecvMsg( void* userData, uint64_t time, uint32_t recvProc,
uint32_t sendProc, uint32_t group, uint32_t type, uint32_t length,
uint32_t source );
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_Counter( void* userData, uint64_t time, uint32_t process,
uint32_t counter, uint64_t value );
uint32_t counter, uint64_t value, OTF_KeyValueList* list );
int OTF_CopyHandler_CollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t collective, uint32_t procGroup,
uint32_t rootProc, uint32_t sent, uint32_t received, uint64_t duration,
uint32_t source );
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_BeginCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t collOp, uint64_t matchingId,
uint32_t procGroup, uint32_t rootProc, uint64_t sent,
uint64_t received, uint32_t scltoken );
uint64_t received, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_EndCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint64_t matchingId );
uint32_t process, uint64_t matchingId, OTF_KeyValueList* list );
int OTF_CopyHandler_EventComment( void* userData, uint64_t time, uint32_t process,
const char* comment );
const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_BeginProcess( void* userData, uint64_t time, uint32_t process );
int OTF_CopyHandler_BeginProcess( void* userData, uint64_t time, uint32_t process, OTF_KeyValueList* list );
int OTF_CopyHandler_EndProcess( void* userData, uint64_t time, uint32_t process );
int OTF_CopyHandler_EndProcess( void* userData, uint64_t time, uint32_t process, OTF_KeyValueList* list );
int OTF_CopyHandler_SnapshotComment( void* userData, uint64_t time,
uint32_t process, const char* comment );
uint32_t process, const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_FileOperation( void* userData, uint64_t time, uint32_t fileid,
uint32_t process, uint64_t handleid, uint32_t operation, uint64_t bytes,
uint64_t duration, uint32_t source );
uint64_t duration, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_BeginFileOperation( void* userData, uint64_t time,
uint32_t process, uint64_t handleid, uint32_t scltoken );
uint32_t process, uint64_t matchingId, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_EndFileOperation( void* userData, uint64_t time,
uint32_t process, uint32_t fileid, uint64_t handleid,
uint32_t operation, uint64_t bytes, uint32_t scltoken );
uint32_t process, uint32_t fileid, uint64_t matchingId, uint64_t handleId,
uint32_t operation, uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_RMAPut( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken );
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_RMAPutRemoteEnd( void* userData, uint64_t time,
uint32_t process, uint32_t origin, uint32_t target, uint32_t communicator,
uint32_t tag, uint64_t bytes, uint32_t scltoken );
uint32_t tag, uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_RMAGet( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken );
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_RMAEnd( void* userData, uint64_t time, uint32_t process,
uint32_t remote, uint32_t communicator, uint32_t tag, uint32_t scltoken );
uint32_t remote, uint32_t communicator, uint32_t tag, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_EnterSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t function, uint32_t process,
uint32_t source );
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_SendSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t sender, uint32_t receiver,
uint32_t procGroup, uint32_t tag, uint32_t source );
uint32_t procGroup, uint32_t tag, uint32_t length,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_OpenFileSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t fileid, uint32_t process, uint64_t handleid,
uint32_t source );
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_BeginCollopSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint32_t collOp,
uint64_t matchingId, uint32_t procGroup, uint32_t rootProc,
uint64_t sent, uint64_t received, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_BeginFileOpSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint64_t matchingId,
uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_SummaryComment( void * userData, uint64_t time,
uint32_t process, const char* comment );
uint32_t process, const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_FunctionSummary( void* userData, uint64_t time,
uint32_t function, uint32_t process, uint64_t invocations,
uint64_t exclTime, uint64_t inclTime );
uint64_t exclTime, uint64_t inclTime, OTF_KeyValueList* list );
int OTF_CopyHandler_FunctionGroupSummary( void* userData, uint64_t time,
uint32_t funcGroup, uint32_t process, uint64_t invocations,
uint64_t exclTime, uint64_t inclTime );
uint64_t exclTime, uint64_t inclTime, OTF_KeyValueList* list );
int OTF_CopyHandler_MessageSummary( void* userData, uint64_t time, uint32_t process,
uint32_t peer, uint32_t comm, uint32_t type, uint64_t sentNumber,
uint64_t receivedNumber, uint64_t sentBytes, uint64_t receivedBytes );
uint64_t receivedNumber, uint64_t sentBytes, uint64_t receivedBytes, OTF_KeyValueList* list );
int OTF_CopyHandler_CollopSummary(void *userData, uint64_t time, uint32_t process, uint32_t comm,
uint32_t collective, uint64_t sentNumber, uint64_t receivedNumber, uint64_t sentBytes,
uint64_t receivedBytes);
uint64_t receivedBytes, OTF_KeyValueList* list );
int OTF_CopyHandler_FileOperationSummary( void* userData, uint64_t time,
uint32_t fileid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite );
uint64_t byteswrite, OTF_KeyValueList* list );
int OTF_CopyHandler_FileGroupOperationSummary( void* userData, uint64_t time,
uint32_t groupid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite );
uint64_t byteswrite, OTF_KeyValueList* list );
int OTF_CopyHandler_DefMarker( void *userData, uint32_t stream,
uint32_t token, const char* name, uint32_t type );
uint32_t token, const char* name, uint32_t type, OTF_KeyValueList* list );
int OTF_CopyHandler_Marker( void *userData, uint64_t time,
uint32_t process, uint32_t token, const char* text );
uint32_t process, uint32_t token, const char* text, OTF_KeyValueList* list );
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OTF_COPYOTF_CopyHandler_R_H */
#endif /* OTF_COPYHANDLER_H */

570
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_CopyHandler_stream.c Обычный файл
Просмотреть файл

@ -0,0 +1,570 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "OTF_Platform.h"
#include "OTF_CopyHandler_stream.h"
#include "OTF_WStream.h"
/* *** Definition handlers *** ************************************* */
int OTF_CopyHandler_stream_DefinitionComment( void* userData, uint32_t stream,
const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefinitionCommentKV( (OTF_WStream*)userData,
comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefTimerResolution( void* userData, uint32_t stream,
uint64_t ticksPerSecond, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefTimerResolutionKV( (OTF_WStream*)userData,
ticksPerSecond, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefProcess( void* userData, uint32_t stream, uint32_t deftoken,
const char* name, uint32_t parent, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefProcessKV( (OTF_WStream*)userData,
deftoken, name, parent, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefProcessGroup( void* userData, uint32_t stream, uint32_t deftoken,
const char* name, uint32_t n, const uint32_t* procs, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefProcessGroupKV( (OTF_WStream*)userData, deftoken,
name, n, procs, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefAttributeList( void* userData, uint32_t stream, uint32_t attr_token,
uint32_t num, OTF_ATTR_TYPE* array, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefAttributeListKV( (OTF_WStream*)userData, attr_token,
num, array, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefProcessOrGroupAttributes( void* userData, uint32_t stream, uint32_t proc_token,
uint32_t attr_token, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefProcessOrGroupAttributesKV( (OTF_WStream*)userData, proc_token,
attr_token, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefFunction( void* userData, uint32_t stream,
uint32_t deftoken, const char* name,
uint32_t group, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefFunctionKV( (OTF_WStream*)userData, deftoken,
name, group, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefFunctionGroup( void* userData, uint32_t stream,
uint32_t deftoken, const char* name, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefFunctionGroupKV( (OTF_WStream*)userData,
deftoken, name, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefCollectiveOperation( void* userData, uint32_t stream,
uint32_t collOp, const char* name, uint32_t type, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefCollectiveOperationKV( (OTF_WStream*)userData,
collOp, name, type, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefCounter( void* userData, uint32_t stream,
uint32_t deftoken, const char* name, uint32_t properties,
uint32_t countergroup, const char* unit, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefCounterKV( (OTF_WStream*)userData,
deftoken, name, properties, countergroup, unit, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefCounterGroup( void* userData, uint32_t stream,
uint32_t deftoken, const char* name, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefCounterGroupKV( (OTF_WStream*)userData,
deftoken, name, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefScl( void* userData, uint32_t stream, uint32_t deftoken,
uint32_t sclfile, uint32_t sclline, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefSclKV( (OTF_WStream*)userData, deftoken,
sclfile, sclline, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefSclFile( void* userData, uint32_t stream,
uint32_t deftoken, const char* filename, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefSclFileKV( (OTF_WStream*)userData,
deftoken, filename, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefVersion( void* userData, uint32_t stream,
uint8_t major, uint8_t minor, uint8_t sub, const char* string ) {
/* update version record */
return ( 0 == OTF_WStream_writeOtfVersion( (OTF_WStream*)userData ) ) ?
OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefCreator( void* userData, uint32_t stream,
const char* creator, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefCreatorKV( (OTF_WStream*)userData, creator, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefFile( void* userData, uint32_t stream, uint32_t token,
const char* name, uint32_t group, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefFileKV( (OTF_WStream*)userData, token,
name, group, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefFileGroup( void* userData, uint32_t stream,
uint32_t token, const char* name, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefFileGroupKV( (OTF_WStream*)userData, token,
name, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefKeyValue( void* userData, uint32_t stream, uint32_t key,
OTF_Type type, const char* name, const char *description, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefKeyValueKV( (OTF_WStream*)userData, key,
type, name, description, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefTimeRange( void* userData,
uint32_t stream,
uint64_t minTime,
uint64_t maxTime,
OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefTimeRange( (OTF_WStream*)userData,
minTime,
maxTime,
list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefCounterAssignments( void* userData,
uint32_t stream,
uint32_t counter,
uint32_t number_of_members,
const uint32_t* procs_or_groups,
OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefCounterAssignments( (OTF_WStream*)userData,
counter,
number_of_members,
procs_or_groups,
list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
/* *** Event handlers *** ****************************************** */
int OTF_CopyHandler_stream_NoOp( void* userData, uint64_t time, uint32_t process,
OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeNoOpKV( (OTF_WStream*)userData, time,
process, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_EventComment( void* userData, uint64_t time, uint32_t process,
const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeEventCommentKV( (OTF_WStream*)userData, time,
process, comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_Counter( void* userData, uint64_t time, uint32_t process,
uint32_t counter_token, uint64_t value, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeCounterKV( (OTF_WStream*)userData, time,
process, counter_token, value, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_Enter( void* userData, uint64_t time, uint32_t statetoken,
uint32_t cpuid, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeEnterKV( (OTF_WStream*)userData, time,
statetoken, cpuid, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_CollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t functionToken, uint32_t communicator,
uint32_t rootprocess, uint32_t sent, uint32_t received,
uint64_t duration, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeCollectiveOperationKV( (OTF_WStream*)userData, time,
process, functionToken, communicator, rootprocess,
sent, received, duration, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_BeginCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t collOp, uint64_t matchingId,
uint32_t procGroup, uint32_t rootProc, uint64_t sent,
uint64_t received, uint32_t scltoken, OTF_KeyValueList* list )
{
return (0 == OTF_WStream_writeBeginCollectiveOperationKV(
(OTF_WStream*) userData, time, process, collOp,
matchingId, procGroup, rootProc, sent, received,
scltoken, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_EndCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint64_t matchingId, OTF_KeyValueList* list )
{
return (0 == OTF_WStream_writeEndCollectiveOperationKV(
(OTF_WStream*) userData, time, process,
matchingId, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_RecvMsg( void* userData, uint64_t time,
uint32_t receiver, uint32_t sender, uint32_t communicator,
uint32_t msgtype, uint32_t msglength, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeRecvMsgKV( (OTF_WStream*)userData, time, receiver,
sender, communicator, msgtype, msglength, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_SendMsg( void* userData, uint64_t time,
uint32_t sender, uint32_t receiver, uint32_t communicator,
uint32_t msgtype, uint32_t msglength, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeSendMsgKV( (OTF_WStream*)userData, time, sender,
receiver, communicator, msgtype, msglength, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_Leave( void* userData, uint64_t time, uint32_t statetoken,
uint32_t cpuid, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeLeaveKV( (OTF_WStream*)userData, time, statetoken,
cpuid, scltoken, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_BeginProcess( void* userData, uint64_t time,
uint32_t process, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeBeginProcessKV( (OTF_WStream*)userData, time,
process, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_EndProcess( void* userData, uint64_t time,
uint32_t process, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeEndProcessKV( (OTF_WStream*)userData, time,
process, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_FileOperation( void* userData, uint64_t time, uint32_t fileid,
uint32_t process, uint64_t handleid, uint32_t operation, uint64_t bytes,
uint64_t duration, uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeFileOperationKV( (OTF_WStream*)userData, time, fileid,
process, handleid, operation, bytes, duration, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_BeginFileOperation( void* userData, uint64_t time,
uint32_t process, uint64_t matchingId, uint32_t scltoken,
OTF_KeyValueList* list )
{
return (0 == OTF_WStream_writeBeginFileOperationKV(
(OTF_WStream*) userData, time, process, matchingId,
scltoken, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_EndFileOperation( void* userData, uint64_t time,
uint32_t process, uint32_t fileid, uint64_t matchingId,
uint64_t handleId, uint32_t operation, uint64_t bytes,
uint32_t scltoken, OTF_KeyValueList* list )
{
return (0 == OTF_WStream_writeEndFileOperationKV( (OTF_WStream*) userData,
time, process, fileid, matchingId, handleId, operation, bytes,
scltoken, list )) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_RMAPut( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeRMAPutKV( (OTF_WStream*)userData, time,
process, origin, target, communicator, tag, bytes, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_RMAPutRemoteEnd( void* userData, uint64_t time,
uint32_t process, uint32_t origin, uint32_t target, uint32_t communicator,
uint32_t tag, uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeRMAPutRemoteEndKV( (OTF_WStream*)userData,
time, process, origin, target, communicator, tag, bytes, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_RMAGet( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeRMAGetKV( (OTF_WStream*)userData, time,
process, origin, target, communicator, tag, bytes, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_RMAEnd( void* userData, uint64_t time, uint32_t process, uint32_t remote,
uint32_t communicator, uint32_t tag, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeRMAEndKV( (OTF_WStream*)userData, time,
process, remote, communicator, tag, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
/* *** snapshot handlers ********************************************** */
int OTF_CopyHandler_stream_SnapshotComment( void* userData, uint64_t time,
uint32_t process, const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeSnapshotCommentKV( (OTF_WStream*)userData,
time, process, comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_EnterSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t function, uint32_t process,
uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeEnterSnapshotKV( (OTF_WStream*)userData,
time, originaltime, function, process, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_SendSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t sender, uint32_t receiver,
uint32_t procGroup, uint32_t tag, uint32_t length,
uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeSendSnapshotKV( (OTF_WStream*)userData,
time, originaltime, sender, receiver, procGroup, tag, length, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_OpenFileSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t fileid, uint32_t process, uint64_t handleid,
uint32_t source, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeOpenFileSnapshotKV( (OTF_WStream*)userData, time,
originaltime, fileid, process, handleid, source, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_BeginCollopSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint32_t collOp,
uint64_t matchingId, uint32_t procGroup, uint32_t rootProc,
uint64_t sent, uint64_t received, uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeBeginCollopSnapshotKV( (OTF_WStream*)userData, time,
originaltime, process, collOp, matchingId, procGroup, rootProc, sent, received,
scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_BeginFileOpSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint64_t matchingId,
uint32_t scltoken, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeBeginFileOpSnapshotKV( (OTF_WStream*)userData, time,
originaltime, process, matchingId, scltoken, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
/* *** summary handlers ********************************************** */
int OTF_CopyHandler_stream_SummaryComment( void * userData, uint64_t time,
uint32_t process, const char* comment, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeSummaryCommentKV( (OTF_WStream*)userData,
time, process, comment, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_FunctionSummary( void* userData,
uint64_t time, uint32_t function, uint32_t process,
uint64_t count, uint64_t excltime, uint64_t incltime,
OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeFunctionSummaryKV( (OTF_WStream*)userData,
time, function, process, count, excltime, incltime, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_FunctionGroupSummary( void* userData,
uint64_t time, uint32_t functiongroup, uint32_t process,
uint64_t count, uint64_t excltime, uint64_t incltime,
OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeFunctionGroupSummaryKV( (OTF_WStream*)userData,
time, functiongroup, process, count, excltime, incltime, list )
) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_MessageSummary( void* userData, uint64_t time,
uint32_t process, uint32_t peer, uint32_t comm, uint32_t type,
uint64_t sentNumber, uint64_t receivedNumber, uint64_t sentBytes,
uint64_t receivedBytes, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeMessageSummaryKV((OTF_WStream*) userData,
time, process, peer, comm, type, sentNumber, receivedNumber, sentBytes,
receivedBytes, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_CollopSummary( void *userData, uint64_t time,
uint32_t process, uint32_t comm, uint32_t collective, uint64_t sentNumber,
uint64_t receivedNumber, uint64_t sentBytes, uint64_t receivedBytes,
OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeCollopSummaryKV((OTF_WStream*) userData,
time, process, comm, collective, sentNumber, receivedNumber, sentBytes,
receivedBytes, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_FileOperationSummary( void* userData, uint64_t time,
uint32_t fileid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeFileOperationSummaryKV( (OTF_WStream*) userData,
time, fileid, process, nopen, nclose, nread, nwrite, nseek,
bytesread, byteswrite, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_FileGroupOperationSummary( void* userData, uint64_t time,
uint32_t groupid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeFileGroupOperationSummaryKV( (OTF_WStream*) userData,
time, groupid, process, nopen, nclose, nread, nwrite, nseek,
bytesread, byteswrite, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}
int OTF_CopyHandler_stream_DefMarker( void *userData, uint32_t stream,
uint32_t token, const char* name, uint32_t type, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeDefMarkerKV( (OTF_WStream*) userData,
token, name, type, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;;
}
int OTF_CopyHandler_stream_Marker( void *userData, uint64_t time,
uint32_t process, uint32_t token, const char* text, OTF_KeyValueList* list ) {
return ( 0 == OTF_WStream_writeMarkerKV( (OTF_WStream*) userData,
time, process, token, text, list ) ) ? OTF_RETURN_ABORT : OTF_RETURN_OK;
}

230
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_CopyHandler_stream.h Обычный файл
Просмотреть файл

@ -0,0 +1,230 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
/**
* @file OTF_CopyHandler.h
*
* @brief Provides handlers for copying a trace.
*
* \ingroup internal
*/
#ifndef OTF_COPYHANDLER_STREAM_H
#define OTF_COPYHANDLER_STREAM_H
#include "OTF_inttypes.h"
#include "OTF_Definitions.h"
#include "OTF_KeyValue.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
int OTF_CopyHandler_stream_DefinitionComment( void* userData, uint32_t stream,
const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefTimerResolution( void* userData, uint32_t stream,
uint64_t ticksPerSecond, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefProcess( void* userData, uint32_t stream, uint32_t process,
const char* name, uint32_t parent, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefProcessGroup( void* userData, uint32_t stream,
uint32_t procGroup, const char* name, uint32_t numberOfProcs,
const uint32_t* procs, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefAttributeList( void* userData, uint32_t stream,
uint32_t attr_token, uint32_t num, OTF_ATTR_TYPE* array, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefProcessOrGroupAttributes( void* userData, uint32_t stream,
uint32_t proc_token, uint32_t attr_token, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefFunction( void* userData, uint32_t stream, uint32_t func,
const char* name, uint32_t funcGroup, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefFunctionGroup( void* userData, uint32_t stream,
uint32_t funcGroup, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefCollectiveOperation( void* userData, uint32_t stream,
uint32_t collOp, const char* name, uint32_t type, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefCounter( void* userData, uint32_t stream, uint32_t counter,
const char* name, uint32_t properties, uint32_t counterGroup,
const char* unit, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefCounterGroup( void* userData, uint32_t stream,
uint32_t counterGroup, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefScl( void* userData, uint32_t stream, uint32_t source,
uint32_t sourceFile, uint32_t line, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefSclFile( void* userData, uint32_t stream,
uint32_t sourceFile, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefVersion( void* userData, uint32_t stream,
uint8_t major, uint8_t minor, uint8_t sub, const char* string );
int OTF_CopyHandler_stream_DefCreator( void* userData, uint32_t stream,
const char* creator, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefFile( void* userData, uint32_t stream, uint32_t token,
const char* name, uint32_t group, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefFileGroup( void* userData, uint32_t stream,
uint32_t token, const char* name, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefKeyValue( void* userData, uint32_t stream, uint32_t key,
OTF_Type type, const char* name, const char* description, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefTimeRange( void* userData,
uint32_t stream,
uint64_t minTime,
uint64_t maxTime,
OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefCounterAssignments( void* userData,
uint32_t stream,
uint32_t counter,
uint32_t number_of_members,
const uint32_t* procs_or_groups,
OTF_KeyValueList* list );
int OTF_CopyHandler_stream_NoOp( void* userData, uint64_t time, uint32_t process,
OTF_KeyValueList* list );
int OTF_CopyHandler_stream_Enter( void* userData, uint64_t time, uint32_t function,
uint32_t process, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_Leave( void* userData, uint64_t time, uint32_t function,
uint32_t process, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_SendMsg( void* userData, uint64_t time, uint32_t sender,
uint32_t receiver, uint32_t group, uint32_t type, uint32_t length,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_RecvMsg( void* userData, uint64_t time, uint32_t recvProc,
uint32_t sendProc, uint32_t group, uint32_t type, uint32_t length,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_Counter( void* userData, uint64_t time, uint32_t process,
uint32_t counter, uint64_t value, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_CollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t collective, uint32_t procGroup,
uint32_t rootProc, uint32_t sent, uint32_t received, uint64_t duration,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_BeginCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint32_t collOp, uint64_t matchingId,
uint32_t procGroup, uint32_t rootProc, uint64_t sent,
uint64_t received, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_EndCollectiveOperation( void* userData, uint64_t time,
uint32_t process, uint64_t matchingId, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_EventComment( void* userData, uint64_t time, uint32_t process,
const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_BeginProcess( void* userData, uint64_t time, uint32_t process, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_EndProcess( void* userData, uint64_t time, uint32_t process, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_SnapshotComment( void* userData, uint64_t time,
uint32_t process, const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_FileOperation( void* userData, uint64_t time, uint32_t fileid,
uint32_t process, uint64_t handleid, uint32_t operation, uint64_t bytes,
uint64_t duration, uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_BeginFileOperation( void* userData, uint64_t time,
uint32_t process, uint64_t matchingId, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_EndFileOperation( void* userData, uint64_t time,
uint32_t process, uint32_t fileid, uint64_t matchingId, uint64_t handleId,
uint32_t operation, uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_RMAPut( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_RMAPutRemoteEnd( void* userData, uint64_t time,
uint32_t process, uint32_t origin, uint32_t target, uint32_t communicator,
uint32_t tag, uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_RMAGet( void* userData, uint64_t time, uint32_t process,
uint32_t origin, uint32_t target, uint32_t communicator, uint32_t tag,
uint64_t bytes, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_RMAEnd( void* userData, uint64_t time, uint32_t process,
uint32_t remote, uint32_t communicator, uint32_t tag, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_EnterSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t function, uint32_t process,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_SendSnapshot( void *userData, uint64_t time,
uint64_t originaltime, uint32_t sender, uint32_t receiver,
uint32_t procGroup, uint32_t tag, uint32_t length,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_OpenFileSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t fileid, uint32_t process, uint64_t handleid,
uint32_t source, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_BeginCollopSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint32_t collOp,
uint64_t matchingId, uint32_t procGroup, uint32_t rootProc,
uint64_t sent, uint64_t received, uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_BeginFileOpSnapshot( void* userData, uint64_t time,
uint64_t originaltime, uint32_t process, uint64_t matchingId,
uint32_t scltoken, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_SummaryComment( void * userData, uint64_t time,
uint32_t process, const char* comment, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_FunctionSummary( void* userData, uint64_t time,
uint32_t function, uint32_t process, uint64_t invocations,
uint64_t exclTime, uint64_t inclTime, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_FunctionGroupSummary( void* userData, uint64_t time,
uint32_t funcGroup, uint32_t process, uint64_t invocations,
uint64_t exclTime, uint64_t inclTime, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_MessageSummary( void* userData, uint64_t time, uint32_t process,
uint32_t peer, uint32_t comm, uint32_t type, uint64_t sentNumber,
uint64_t receivedNumber, uint64_t sentBytes, uint64_t receivedBytes, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_CollopSummary(void *userData, uint64_t time, uint32_t process, uint32_t comm,
uint32_t collective, uint64_t sentNumber, uint64_t receivedNumber, uint64_t sentBytes,
uint64_t receivedBytes, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_FileOperationSummary( void* userData, uint64_t time,
uint32_t fileid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_FileGroupOperationSummary( void* userData, uint64_t time,
uint32_t groupid, uint32_t process, uint64_t nopen, uint64_t nclose,
uint64_t nread, uint64_t nwrite, uint64_t nseek, uint64_t bytesread,
uint64_t byteswrite, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_DefMarker( void *userData, uint32_t stream,
uint32_t token, const char* name, uint32_t type, OTF_KeyValueList* list );
int OTF_CopyHandler_stream_Marker( void *userData, uint64_t time,
uint32_t process, uint32_t token, const char* text, OTF_KeyValueList* list );
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OTF_COPYHANDLER_STREAM_H */

44
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Definitions.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -18,7 +18,6 @@
#include "OTF_Version.h"
/* definitions of record type identifiers */
@ -31,6 +30,8 @@ yet it breaks the link compatibility of library versions.*/
#define OTF_COUNTER_RECORD 1
#define OTF_ENTER_RECORD 2
#define OTF_NOOP_RECORD 58
#define OTF_COLLOP_RECORD 5
#define OTF_RECEIVE_RECORD 10
@ -58,6 +59,8 @@ yet it breaks the link compatibility of library versions.*/
#define OTF_DEFTIMERRESOLUTION_RECORD 13
#define OTF_DEFPROCESS_RECORD 14
#define OTF_DEFPROCESSGROUP_RECORD 15
#define OTF_DEFATTRLIST_RECORD 55
#define OTF_DEFPROCESSORGROUPATTR_RECORD 56
#define OTF_DEFFUNCTION_RECORD 16
#define OTF_DEFFUNCTIONGROUP_RECORD 17
#define OTF_DEFCOUNTER_RECORD 18
@ -69,6 +72,10 @@ yet it breaks the link compatibility of library versions.*/
#define OTF_DEFCREATOR_RECORD 24
#define OTF_DEFFILE_RECORD 25
#define OTF_DEFFILEGROUP_RECORD 26
#define OTF_DEFTIMERANGE_RECORD 61
#define OTF_DEFCOUNTERASSIGNMENTS_RECORD 62
#define OTF_DEFKEYVALUE_RECORD 57
#define OTF_FUNCTIONSUMMARY_RECORD 28
@ -86,6 +93,8 @@ yet it breaks the link compatibility of library versions.*/
#define OTF_SUMMARYCOMMENT_RECORD 39
#define OTF_SNAPSHOTCOMMENT_RECORD 40
#define OTF_OPENFILESNAPSHOT_RECORD 43
#define OTF_BEGINCOLLOPSNAPSHOT_RECORD 59
#define OTF_BEGINFILEOPSNAPSHOT_RECORD 60
#define OTF_UNKNOWN_RECORD 41
@ -93,7 +102,7 @@ yet it breaks the link compatibility of library versions.*/
#define OTF_MARKER_RECORD 46
/* Number of records */
#define OTF_NRECORDS 55
#define OTF_NRECORDS 63
/* Stream format definition */
@ -182,7 +191,12 @@ could be added for convenience.
#define OTF_COLLECTIVE_TYPE_ALL2ALL 4
/* File Operations */
/*
File Operations - 32-bit
The bits 0-4 contain the identifier of the file operation that has happened.
The bits 5-31 are bit flags that carry additional information on the operation.
A macro allows for accessing the file operation in a convenient way.
*/
#define OTF_FILEOP_BITS 0x0000001f
#define OTF_FILEOP_OPEN 0
#define OTF_FILEOP_CLOSE 1
@ -203,6 +217,7 @@ could be added for convenience.
#define OTF_IOFLAG_DIRECT 256
#define OTF_IOFLAG_SYNC 512
#define OTF_IOFLAG_ISREADLOCK 1024
#define OTF_FILEOP(x) (x & OTF_FILEOP_BITS)
/* Types of markers */
@ -219,6 +234,27 @@ could be added for convenience.
extern char otf_strerr[OTF_ERR_LEN];
extern int otf_errno;
/* OTF_KeyValueList related defines */
/* This macro defines the maximum length of a byte array that can be
appended internally to an OTF_KeyValueList() --> internal use only
For the user a byte array can contain an unlimited number of bytes.
NOTE: Do not edit this constant unless you know exactly what you do! */
#define OTF_KEYVALUE_MAX_ARRAY_LEN 100
/* enum used for DefAttributeList record */
/** An enum which holds all values that are possible to set with datatype OTF_ATTR_TYPE().*/
typedef enum OTF_ATTR_TYPE_enum {
OTF_ATTR_UNKNOWN = 0, /**< */
OTF_ATTR_IsMPIRank = 1, /**< */
OTF_ATTR_IsPThread = 2, /**< */
OTF_ATTR_IsOMPThread = 3, /**< */
OTF_ATTR_IsCellSPUThread = 4, /**< */
OTF_ATTR_hasGroupCounters = 5, /**< */
OTF_ATTR_hasEnterLeaveRecords = 6 /**< */
} OTF_ATTR_TYPE;
/* return values for handlers. they are not yet evaluated!!! */
/** When writing an own handler, use these macros to tell OTF, what to do.

2
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Errno.c
Просмотреть файл

@ -16,7 +16,7 @@ int otf_errno = OTF_NO_ERROR;
vsnprintf( otf_strerr, OTF_ERR_LEN, format, ap );
otf_errno = OTF_ERROR;
vfprintf( stream, format, ap);
fprintf( stream, "%s", otf_strerr );
va_end(ap);
}

2
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Errno.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/

412
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_File.c
Просмотреть файл

@ -1,35 +1,52 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
also: patches by Rainer Keller, thanks a lot!
*/
/* macros to enable 64 bit file access. make sure all std headers are
included AFTER this macro definitions */
/* config.h handles this now: #define _LARGEFILE_SOURCE */
/* config.h handles this now: #define _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE
#define _LARGE_FILES
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "OTF_Platform.h"
#include "OTF_inttypes.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#if !(defined(HAVE_DECL_O_NOATIME) && HAVE_DECL_O_NOATIME)
#define O_NOATIME 0
#endif
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
@ -88,6 +105,17 @@ struct struct_OTF_File {
OTF_FileMode mode;
OTF_FileManager* manager;
/** Reference to external buffer to read from instead of a real file.
This is for reading of definitions only and has some limitations. */
const char* externalbuffer;
/** the current position in the 'externalbuffer' */
uint64_t externalpos;
/** the total length of the 'externalbuffer' */
uint64_t externallen;
};
@ -105,6 +133,10 @@ void OTF_File_init( OTF_File* file ) {
file->pos= 0;
file->mode= OTF_FILEMODE_NOTHING;
file->manager= NULL;
file->externalbuffer= NULL;
file->externalpos= 0;
file->externallen= 0;
}
@ -122,6 +154,10 @@ void OTF_File_finalize( OTF_File* file ) {
file->pos= 0;
file->mode= OTF_FILEMODE_NOTHING;
file->manager= NULL;
file->externalbuffer= NULL;
file->externalpos= 0;
file->externallen= 0;
}
@ -133,6 +169,97 @@ OTF_File* OTF_File_open( const char* filename,
}
OTF_File* OTF_File_open_with_external_buffer( uint32_t len, const char* buffer,
uint8_t is_compressed, OTF_FileMode mode ) {
OTF_File* ret;
ret= (OTF_File*) malloc( sizeof(OTF_File) );
if( NULL == ret ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n",
__FUNCTION__, __FILE__, __LINE__ );
return NULL;
}
OTF_File_init( ret );
ret->externalbuffer= buffer;
ret->externalpos= 0;
ret->externallen= (uint64_t) len;
ret->mode = mode;
if ( is_compressed ) {
#ifdef HAVE_ZLIB
/* alloc zlib stuff */
ret->z= malloc( sizeof(z_stream) );
if( NULL == ret->z ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n", __FUNCTION__, __FILE__, __LINE__ );
free( ret );
ret= NULL;
return NULL;
}
ret->z->next_in= NULL;
ret->z->avail_in= 0;
ret->z->zalloc= NULL;
ret->z->zfree= NULL;
ret->z->opaque= NULL;
inflateInit( ret->z );
ret->zbuffer= malloc( ret->zbuffersize );
ret->ybuffer= malloc( ret->zbuffersize );
if( NULL == ret->zbuffer || NULL == ret->ybuffer) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n", __FUNCTION__, __FILE__, __LINE__ );
free( ret->zbuffer );
free( ret->ybuffer );
ret->zbuffer= NULL;
ret->ybuffer= NULL;
free( ret->z );
ret->z= NULL;
free( ret );
ret= NULL;
return NULL;
}
#else /* HAVE_ZLIB */
free( ret );
ret= NULL;
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"built without HAVE_ZLIB, still trying to open with compressed buffer.\n",
__FUNCTION__, __FILE__, __LINE__ );
return NULL;
#endif /* HAVE_ZLIB */
} else {
/* normal, don't need any special setup */
}
ret->manager= NULL;
return ret;
}
size_t OTF_File_write( OTF_File* file, const void* ptr, size_t size ) {
@ -143,7 +270,17 @@ size_t OTF_File_write( OTF_File* file, const void* ptr, size_t size ) {
int rest = (int) size;
int status;
#endif/* HAVE_ZLIB */
if ( NULL != file->externalbuffer ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"not yet supported in 'external buffer' mode.\n",
__FUNCTION__, __FILE__, __LINE__ );
return (size_t) -1;
}
if( OTF_FILEMODE_WRITE != file->mode ) {
OTF_fprintf ( stderr, "ERROR in function %s, file: %s, line: %i:\n "
@ -355,7 +492,10 @@ size_t OTF_File_read( OTF_File* file, void* ptr, size_t size ) {
if ( 0 == file->z->avail_in ) {
/* OLD:
file->z->avail_in= (uInt) fread( file->zbuffer, 1, file->zbuffersize, file->file );
*/
file->z->avail_in= (uInt) OTF_File_read_internal( file, file->zbuffer, file->zbuffersize );
file->z->next_in= file->zbuffer;
}
@ -379,12 +519,18 @@ size_t OTF_File_read( OTF_File* file, void* ptr, size_t size ) {
} else {
/* OLD
return fread( ptr, 1, size, file->file );
*/
return OTF_File_read_internal( file, ptr, size );
}
#else /* HAVE_ZLIB */
return fread( ptr, 1, size, file->file );
/* OLD
return fread( ptr, 1, size, file->file );
*/
return OTF_File_read_internal( file, ptr, size );
#endif /* HAVE_ZLIB */
}
@ -400,6 +546,16 @@ int OTF_File_seek( OTF_File* file, uint64_t pos ) {
uint64_t read;
#endif /* HAVE_ZLIB */
if ( NULL != file->externalbuffer ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"not yet supported in 'external buffer' mode.\n",
__FUNCTION__, __FILE__, __LINE__ );
return -1;
}
if( OTF_FILEMODE_WRITE == file->mode ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
@ -433,7 +589,11 @@ int OTF_File_seek( OTF_File* file, uint64_t pos ) {
(unsigned long long) pos );
*/
/* OLD:
read= fread( file->zbuffer, 1, file->zbuffersize, file->file );
*/
read= OTF_File_read_internal( file, file->zbuffer, file->zbuffersize );
/*
OTF_fprintf( stderr, "OTF_File_seek() with zlib: read %llu bytes\n",
@ -496,6 +656,15 @@ int OTF_File_seek( OTF_File* file, uint64_t pos ) {
uint64_t OTF_File_tell( OTF_File* file ) {
if ( NULL != file->externalbuffer ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"not yet supported in 'external buffer' mode.\n",
__FUNCTION__, __FILE__, __LINE__ );
return (uint64_t) -1;
}
if ( NULL != file->file ) {
file->pos= ftello( file->file );
@ -510,6 +679,16 @@ uint64_t OTF_File_size( OTF_File* file ) {
struct stat st;
if ( NULL != file->externalbuffer ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"not yet supported in 'external buffer' mode.\n",
__FUNCTION__, __FILE__, __LINE__ );
return (uint64_t) -1;
}
if ( stat( file->filename, &st ) == -1 ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
@ -623,6 +802,15 @@ int OTF_File_close( OTF_File* file ) {
OTF_FileStatus OTF_File_status( OTF_File* file ) {
if ( NULL != file->externalbuffer ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"not yet supported in 'external buffer' mode.\n",
__FUNCTION__, __FILE__, __LINE__ );
return OTF_FILESTATUS_UNKNOWN;
}
if ( NULL == file->file ) {
if ( 0 == file->pos ) {
@ -642,6 +830,15 @@ OTF_FileStatus OTF_File_status( OTF_File* file ) {
void OTF_File_suspend( OTF_File* file ) {
if ( NULL != file->externalbuffer ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"not yet supported in 'external buffer' mode.\n",
__FUNCTION__, __FILE__, __LINE__ );
return;
}
/* get status and close OS file */
file->pos= ftello( file->file );
@ -653,6 +850,13 @@ void OTF_File_suspend( OTF_File* file ) {
int OTF_File_revive( OTF_File* file, OTF_FileMode mode ) {
if ( NULL != file->externalbuffer ) {
/* no need to revive, everything is fine in 'external buffer' mode */
return 1;
}
switch ( mode ) {
case OTF_FILEMODE_READ :
@ -661,7 +865,7 @@ int OTF_File_revive( OTF_File* file, OTF_FileMode mode ) {
if ( NULL == file->file ) {
/* file currently closed */
/* file currently closed, aka open or reopen */
/*
OTF_fprintf( stderr, "OTF_File_revive() READ: ask FileManager for free handle\n" );
@ -675,39 +879,62 @@ int OTF_File_revive( OTF_File* file, OTF_FileMode mode ) {
return 0;
}
/* open first time, as we open O_RDONLY plus O_NOATIME, which fopen doesn't know, use open/fdopen */
#ifdef _GNU_SOURCE
{
int fd;
int retry_num = 5;
int flags = O_RDONLY | O_NOATIME;
while ( -1 == ( fd = open( file->filename, flags ) ) ) {
/* if the user is not the owner of the file, open with O_NOATIME will fail with errno == EPERM;
try to open without O_NOATIME again to avoid this problem */
if ( EPERM == errno ) {
flags = O_RDONLY;
continue;
/* the file name might be stale, e.g. on Network File System (NFS) */
} else if ( ESTALE == errno && 0 < --retry_num ) {
sleep(1);
continue;
} else {
/* show this error every time */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"cannot open file %s for reading. Maybe the number of "
"opened filehandles exceeds your system's limit\n",
__FUNCTION__, __FILE__, __LINE__, file->filename );
return 0;
}
}
file->file= fdopen( fd, "r" );
}
#else /* _GNU_SOURCE */
file->file= fopen( file->filename, "rb" );
#endif /* _GNU_SOURCE */
if( NULL == file->file ) {
/* show this error every time */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"cannot open file %s for reading. Maybe the number of "
"opened filehandles exceeds your system's limit\n",
__FUNCTION__, __FILE__, __LINE__, file->filename );
return 0;
}
/* Upon repoen, seek to the current position */
if ( 0 != file->pos ) {
/* re-open */
file->file= fopen( file->filename, "rb" );
if( NULL == file->file ) {
/* show this error every time */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"cannot open file %s for reading. Maybe the number of "
"opened filehandles exceeds your system's limit\n",
__FUNCTION__, __FILE__, __LINE__, file->filename );
return 0;
}
fseeko( file->file, file->pos, SEEK_SET );
} else {
/* open first time */
file->file= fopen( file->filename, "rb" );
if( NULL == file->file ) {
/* show this error every time */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"cannot open file %s for reading. Maybe the number of "
"opened filehandles exceeds your system's limit\n",
__FUNCTION__, __FILE__, __LINE__, file->filename );
return 0;
}
}
@ -975,11 +1202,29 @@ OTF_File* OTF_File_open_zlevel( const char* filename, OTF_FileManager* manager,
uint32_t len;
OTF_File* ret;
/* Check input parameters */
if( NULL == filename ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no filename has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return NULL;
}
if( NULL == manager ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"manager has not been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return NULL;
}
/* OTF_fprintf( stderr, "OTF_File_open_zlevel() zlevel: %u, filename: \"%s\"\n", zlevel, filename ); */
OTF_File* ret= (OTF_File*) malloc( sizeof(OTF_File) );
ret= (OTF_File*) malloc( sizeof(OTF_File) );
if( NULL == ret ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
@ -991,18 +1236,6 @@ OTF_File* OTF_File_open_zlevel( const char* filename, OTF_FileManager* manager,
OTF_File_init( ret );
if( NULL == filename ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no filename has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
free( ret );
ret= NULL;
return NULL;
}
len= (uint32_t) strlen( filename );
ret->filename= malloc( len +3 );
if( NULL == ret->filename ) {
@ -1076,7 +1309,12 @@ OTF_File* OTF_File_open_zlevel( const char* filename, OTF_FileManager* manager,
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n",
__FUNCTION__, __FILE__, __LINE__ );
free( ret->zbuffer );
free( ret->ybuffer );
ret->zbuffer= NULL;
ret->ybuffer= NULL;
free( ret->z );
ret->z= NULL;
free( ret->filename );
@ -1091,6 +1329,16 @@ OTF_File* OTF_File_open_zlevel( const char* filename, OTF_FileManager* manager,
#else /* HAVE_ZLIB */
if ( 0 != access( ret->filename, F_OK ) ) {
strncpy( ret->filename +len, ".z", 3 );
if ( 0 == access( ret->filename, F_OK ) ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"cannot open %s. Zlib is not enabled.\n",
__FUNCTION__, __FILE__, __LINE__, ret->filename );
}
/* file still not found, give up */
free( ret->filename );
@ -1157,28 +1405,36 @@ OTF_File* OTF_File_open_zlevel( const char* filename, OTF_FileManager* manager,
}
if( NULL == manager ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"manager has not been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
# ifdef HAVE_ZLIB
free( ret->zbuffer );
ret->zbuffer= NULL;
free( ret->ybuffer );
ret->ybuffer= NULL;
free( ret->z );
ret->z= NULL;
# endif /* HAVE_ZLIB */
free( ret->filename );
ret->filename= NULL;
free( ret );
ret= NULL;
return NULL;
}
ret->manager= manager;
return ret;
}
size_t OTF_File_read_internal( OTF_File* file, void* dest, size_t length ) {
uint64_t actual_length;
/* default behavior first */
if ( NULL == file->externalbuffer )
return fread( dest, 1, length, file->file );
/* now for the special case: read from the external buffer */
actual_length= file->externallen - file->externalpos;
actual_length= ( length <= actual_length ) ? length : actual_length;
/*
OTF_fprintf( stderr, "OTF_File_read_internal from external buffer: "
"addr %x, length %llu, actual_length %llu, pos %llu, bufflen %llu\n",
file->externalbuffer,
(uint64_t)length, (uint64_t)actual_length, (uint64_t) file->externalpos, (uint64_t) file->externallen );
*/
memcpy( dest, file->externalbuffer + file->externalpos, actual_length );
file->externalpos += actual_length;
return actual_length;
}

18
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_File.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -37,7 +37,8 @@ typedef enum enum_OTF_FileMode OTF_FileMode;
/** status of a file */
enum enum_OTF_FileStatus {
OTF_FILESTATUS_ACTIVE= 1,
OTF_FILESTATUS_UNKNOWN= 0,
OTF_FILESTATUS_ACTIVE= 1,
OTF_FILESTATUS_SUSPENDED= 2,
OTF_FILESTATUS_CLOSED= 3
};
@ -53,6 +54,13 @@ void OTF_File_finalize( OTF_File* o );
OTF_File* OTF_File_open( const char* filename, OTF_FileManager* manager,
OTF_FileMode mode );
/** open a pseudo OTF_File that actually reads from the given memory buffer.
The buffer is not copied, you need to manage it yourself!
Don't touch it during access operations. */
OTF_File* OTF_File_open_with_external_buffer( uint32_t len, const char* buffer, uint8_t is_compressed,
OTF_FileMode mode );
/** OTF_File to an OTF_File */
size_t OTF_File_write( OTF_File* file, const void* ptr, size_t size );
@ -89,6 +97,12 @@ void OTF_File_setZBufferSize( OTF_File* file, uint32_t size );
OTF_File* OTF_File_open_zlevel( const char* filename, OTF_FileManager* manager,
OTF_FileMode mode, OTF_FileCompression compression );
/* internal function */
/** read 'length' bytes from underlying file or from special memory buffer */
size_t OTF_File_read_internal( OTF_File* file, void* dest, size_t length );
#ifdef __cplusplus
}
#endif /* __cplusplus */

2
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_FileManager.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/

2
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_FileManager.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/

2
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Filenames.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/

2
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Filenames.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/

526
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Handler.h
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

396
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_HandlerArray.c
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -12,6 +12,7 @@
#include "OTF_HandlerArray.h"
#include "OTF_Definitions.h"
#include "OTF_CopyHandler.h"
#include "OTF_CopyHandler_stream.h"
#include "OTF_Errno.h"
@ -165,12 +166,6 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
OTF_Writer* writer ) {
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefinitionComment,
OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefinitionComment,
OTF_DEFINITIONCOMMENT_RECORD );
@ -195,6 +190,18 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefAttributeList,
OTF_DEFATTRLIST_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFATTRLIST_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefProcessOrGroupAttributes,
OTF_DEFPROCESSORGROUPATTR_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFPROCESSORGROUPATTR_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefFunction,
OTF_DEFFUNCTION_RECORD );
@ -243,7 +250,6 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFCREATOR_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefFile,
OTF_DEFFILE_RECORD );
@ -255,8 +261,32 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
OTF_DEFFILEGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFFILEGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefKeyValue,
OTF_DEFKEYVALUE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFKEYVALUE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefTimeRange,
OTF_DEFTIMERANGE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFTIMERANGE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_DefCounterAssignments,
OTF_DEFCOUNTERASSIGNMENTS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_DEFCOUNTERASSIGNMENTS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_NoOp,
OTF_NOOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_NOOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_Enter,
OTF_ENTER_RECORD );
@ -391,6 +421,19 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
OTF_OPENFILESNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_BeginCollopSnapshot,
OTF_BEGINCOLLOPSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_BEGINCOLLOPSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_BeginFileOpSnapshot,
OTF_BEGINFILEOPSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, writer,
OTF_BEGINFILEOPSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_SummaryComment,
OTF_SUMMARYCOMMENT_RECORD );
@ -448,3 +491,338 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
return 1;
}
int OTF_HandlerArray_getCopyHandler_stream( OTF_HandlerArray* handlers,
OTF_WStream* wstream ) {
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefinitionComment,
OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefTimerResolution,
OTF_DEFTIMERRESOLUTION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFTIMERRESOLUTION_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefProcess,
OTF_DEFPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefProcessGroup,
OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefAttributeList,
OTF_DEFATTRLIST_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFATTRLIST_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefProcessOrGroupAttributes,
OTF_DEFPROCESSORGROUPATTR_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFPROCESSORGROUPATTR_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefFunction,
OTF_DEFFUNCTION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFFUNCTION_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefFunctionGroup,
OTF_DEFFUNCTIONGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFFUNCTIONGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefCollectiveOperation,
OTF_DEFCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefCounter,
OTF_DEFCOUNTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFCOUNTER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefCounterGroup,
OTF_DEFCOUNTERGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFCOUNTERGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefScl,
OTF_DEFSCL_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFSCL_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefSclFile,
OTF_DEFSCLFILE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFSCLFILE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefVersion,
OTF_DEFVERSION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFVERSION_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefCreator,
OTF_DEFCREATOR_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFCREATOR_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefFile,
OTF_DEFFILE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFFILE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefFileGroup,
OTF_DEFFILEGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFFILEGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefKeyValue,
OTF_DEFKEYVALUE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFKEYVALUE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefTimeRange,
OTF_DEFTIMERANGE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFTIMERANGE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefCounterAssignments,
OTF_DEFCOUNTERASSIGNMENTS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFCOUNTERASSIGNMENTS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_NoOp,
OTF_NOOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_NOOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_Enter,
OTF_ENTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_ENTER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_Leave,
OTF_LEAVE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_LEAVE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_SendMsg,
OTF_SEND_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_SEND_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_RecvMsg,
OTF_RECEIVE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_RECEIVE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_Counter,
OTF_COUNTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_COUNTER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_CollectiveOperation,
OTF_COLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_COLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_BeginCollectiveOperation,
OTF_BEGINCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_BEGINCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_EndCollectiveOperation,
OTF_ENDCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_ENDCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_EventComment,
OTF_EVENTCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_EVENTCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_BeginProcess,
OTF_BEGINPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_BEGINPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_EndProcess,
OTF_ENDPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_ENDPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_FileOperation,
OTF_FILEOPERATION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_FILEOPERATION_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_BeginFileOperation,
OTF_BEGINFILEOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_BEGINFILEOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_EndFileOperation,
OTF_ENDFILEOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_ENDFILEOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_RMAPut,
OTF_RMAPUT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_RMAPUT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_RMAPutRemoteEnd,
OTF_RMAPUTRE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_RMAPUTRE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_RMAGet,
OTF_RMAGET_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_RMAGET_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_RMAEnd,
OTF_RMAEND_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_RMAEND_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_SnapshotComment,
OTF_SNAPSHOTCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_SNAPSHOTCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_EnterSnapshot,
OTF_ENTERSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_ENTERSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_SendSnapshot,
OTF_SENDSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_SENDSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_OpenFileSnapshot,
OTF_OPENFILESNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_OPENFILESNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_BeginCollopSnapshot,
OTF_BEGINCOLLOPSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_BEGINCOLLOPSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_BeginFileOpSnapshot,
OTF_BEGINFILEOPSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_BEGINFILEOPSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_SummaryComment,
OTF_SUMMARYCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_SUMMARYCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_FunctionSummary,
OTF_FUNCTIONSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_FUNCTIONSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_FunctionGroupSummary,
OTF_FUNCTIONGROUPSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_FUNCTIONGROUPSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_MessageSummary,
OTF_MESSAGESUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_MESSAGESUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_CollopSummary,
OTF_COLLOPSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_COLLOPSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_FileOperationSummary,
OTF_FILEOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_FILEOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_FileGroupOperationSummary,
OTF_FILEGROUPOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_FILEGROUPOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_DefMarker,
OTF_DEFMARKER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_DEFMARKER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) OTF_CopyHandler_stream_Marker,
OTF_MARKER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, wstream,
OTF_MARKER_RECORD );
return 1;
}

225
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_HandlerArray.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -37,6 +37,7 @@
#include "OTF_Writer.h"
#include "OTF_WStream.h"
#ifdef __cplusplus
@ -81,6 +82,10 @@ int OTF_HandlerArray_setFirstHandlerArg( OTF_HandlerArray* handlers,
int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
OTF_Writer* writer );
/** Provide copy handlers to every record type for OTF streams. \ingroup ha */
int OTF_HandlerArray_getCopyHandler_stream( OTF_HandlerArray* handlers,
OTF_WStream* writer );
/* typdefs for OTF definition records *************************** */
@ -113,19 +118,23 @@ int OTF_HandlerArray_getCopyHandler( OTF_HandlerArray* handlers,
/* # OTF_DEFINITIONCOMMENT_RECORD */
typedef int (OTF_Handler_DefinitionComment) ( void* userData,
uint32_t stream,
const char* comment );
/* # OTF_DEFTIMERRESOLUTION_RECORD */
uint32_t stream,
const char* comment,
OTF_KeyValueList *list );
/* # OTF_DEFTIMERRESOLUTION_RECORD */
typedef int (OTF_Handler_DefTimerResolution) ( void* userData,
uint32_t stream,
uint64_t ticksPerSecond );
uint64_t ticksPerSecond,
OTF_KeyValueList *list );
/* # OTF_DEFPROCESS_RECORD */
typedef int (OTF_Handler_DefProcess) ( void* userData,
uint32_t stream,
uint32_t process,
const char* name,
uint32_t parent );
uint32_t parent,
OTF_KeyValueList *list );
/* # OTF_DEFPROCESSGROUP_RECORD */
typedef int (OTF_Handler_DefProcessGroup) ( void* userData,
@ -133,7 +142,23 @@ typedef int (OTF_Handler_DefProcessGroup) ( void* userData,
uint32_t procGroup,
const char* name,
uint32_t numberOfProcs,
const uint32_t* procs );
const uint32_t* procs,
OTF_KeyValueList *list );
/* # OTF_DEFATTRLIST_RECORD */
typedef int (OTF_Handler_DefAttributeList) ( void* userData,
uint32_t stream,
uint32_t attr_token,
uint32_t num,
OTF_ATTR_TYPE* array,
OTF_KeyValueList *list );
/* # OTF_DEFPROCESSORGROUPATTR_RECORD */
typedef int (OTF_Handler_DefProcessOrGroupAttributes) ( void* userData,
uint32_t stream,
uint32_t proc_token,
uint32_t attr_token,
OTF_KeyValueList *list );
/* # OTF_DEFFUNCTION_RECORD */
typedef int (OTF_Handler_DefFunction) ( void* userData,
@ -141,20 +166,23 @@ typedef int (OTF_Handler_DefFunction) ( void* userData,
uint32_t func,
const char* name,
uint32_t funcGroup,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_DEFFUNCTIONGROUP_RECORD */
typedef int (OTF_Handler_DefFunctionGroup) ( void* userData,
uint32_t stream,
uint32_t funcGroup,
const char* name );
const char* name,
OTF_KeyValueList *list );
/* # OTF_DEFCOLLOP_RECORD */
typedef int (OTF_Handler_DefCollectiveOperation) ( void* userData,
uint32_t stream,
uint32_t collOp,
const char* name,
uint32_t type );
uint32_t type,
OTF_KeyValueList *list );
/* # OTF_DEFCOUNTER_RECORD */
typedef int (OTF_Handler_DefCounter) ( void* userData,
@ -163,31 +191,36 @@ typedef int (OTF_Handler_DefCounter) ( void* userData,
const char* name,
uint32_t properties,
uint32_t counterGroup,
const char* unit );
const char* unit,
OTF_KeyValueList *list );
/* # OTF_DEFCOUNTERGROUP_RECORD */
typedef int (OTF_Handler_DefCounterGroup) ( void* userData,
uint32_t stream,
uint32_t counterGroup,
const char* name );
const char* name,
OTF_KeyValueList *list );
/* # OTF_DEFSCL_RECORD */
typedef int (OTF_Handler_DefScl) ( void* userData,
uint32_t stream,
uint32_t source,
uint32_t sourceFile,
uint32_t line );
uint32_t line,
OTF_KeyValueList *list );
/* # OTF_DEFSCLFILE_RECORD */
typedef int (OTF_Handler_DefSclFile) ( void* userData,
uint32_t stream,
uint32_t sourceFile,
const char* name );
const char* name,
OTF_KeyValueList *list );
/* # OTF_DEFCREATOR_RECORD */
typedef int (OTF_Handler_DefCreator) ( void* userData,
uint32_t stream,
const char* creator );
const char* creator,
OTF_KeyValueList *list );
/* # OTF_DEFVERSION_RECORD */
typedef int (OTF_Handler_DefVersion) ( void* userData,
@ -195,37 +228,71 @@ typedef int (OTF_Handler_DefVersion) ( void* userData,
uint8_t major,
uint8_t minor,
uint8_t sub,
const char* string );
const char* string,
OTF_KeyValueList *list );
/* # OTF_DEFFILE_RECORD */
typedef int (OTF_Handler_DefFile) ( void* userData,
uint32_t stream,
uint32_t token,
const char *name,
uint32_t group );
uint32_t group,
OTF_KeyValueList *list );
/* # OTF_DEFFILEGROUP_RECORD */
typedef int (OTF_Handler_DefFileGroup) ( void* userData,
uint32_t stream,
uint32_t token,
const char *name );
const char *name,
OTF_KeyValueList *list );
/* # OTF_DEFKEYVALUE_RECORD */
typedef int (OTF_Handler_DefKeyValue) ( void* userData,
uint32_t stream,
uint32_t key,
OTF_Type type,
const char *name,
const char *description,
OTF_KeyValueList *list );
/* # OTF_DEFTIMERANGE_RECORD */
typedef int (OTF_Handler_DefTimeRange) ( void* userData,
uint32_t stream,
uint64_t minTime,
uint64_t maxTime,
OTF_KeyValueList* list );
/* # OTF_DEFCOUNTERASSIGNMENTS_RECORD */
typedef int (OTF_Handler_DefCounterAssignments) ( void* userData,
uint32_t stream,
uint32_t counter,
uint32_t number_of_members,
const uint32_t* procs_or_groups,
OTF_KeyValueList* list );
/* typedefs for OTF event records ****************************************** */
/* # OTF_NOOP_RECORD */
typedef int (OTF_Handler_NoOp) ( void* userData,
uint64_t time,
uint32_t process,
OTF_KeyValueList *list );
/* # OTF_ENTER_RECORD */
/* # OTF_ENTER_RECORD */
typedef int (OTF_Handler_Enter) ( void* userData,
uint64_t time,
uint32_t function,
uint32_t process,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_LEAVE_RECORD */
typedef int (OTF_Handler_Leave) ( void* userData,
uint64_t time,
uint32_t function,
uint32_t process,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_SEND_RECORD */
typedef int (OTF_Handler_SendMsg) ( void* userData,
@ -235,7 +302,8 @@ typedef int (OTF_Handler_SendMsg) ( void* userData,
uint32_t group,
uint32_t type,
uint32_t length,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_RECEIVE_RECORD */
typedef int (OTF_Handler_RecvMsg) ( void* userData,
@ -245,14 +313,16 @@ typedef int (OTF_Handler_RecvMsg) ( void* userData,
uint32_t group,
uint32_t type,
uint32_t length,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_COUNTER_RECORD */
typedef int (OTF_Handler_Counter) ( void* userData,
uint64_t time,
uint32_t process,
uint32_t counter,
uint64_t value );
uint64_t value,
OTF_KeyValueList *list );
/* # OTF_COLLOP_RECORD */
typedef int (OTF_Handler_CollectiveOperation) ( void* userData,
@ -264,7 +334,8 @@ typedef int (OTF_Handler_CollectiveOperation) ( void* userData,
uint32_t sent,
uint32_t received,
uint64_t duration,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_BEGINCOLLOP_RECORD */
typedef int (OTF_Handler_BeginCollectiveOperation) ( void* userData,
@ -276,29 +347,34 @@ typedef int (OTF_Handler_BeginCollectiveOperation) ( void* userData,
uint32_t rootProc,
uint64_t sent,
uint64_t received,
uint32_t scltoken );
uint32_t scltoken,
OTF_KeyValueList *list );
/* # OTF_ENDCOLLOP_RECORD */
typedef int (OTF_Handler_EndCollectiveOperation) ( void* userData,
uint64_t time,
uint32_t process,
uint64_t matchingId );
uint64_t matchingId,
OTF_KeyValueList *list );
/* # OTF_EVENTCOMMENT_RECORD */
typedef int (OTF_Handler_EventComment) ( void* userData,
uint64_t time,
uint32_t process,
const char* comment );
const char* comment,
OTF_KeyValueList *list );
/* # OTF_BEGINPROCESS_RECORD */
typedef int (OTF_Handler_BeginProcess) ( void* userData,
uint64_t time,
uint32_t process );
uint32_t process,
OTF_KeyValueList *list );
/* # OTF_ENDPROCESS_RECORD */
typedef int (OTF_Handler_EndProcess) ( void* userData,
uint64_t time,
uint32_t process );
uint32_t process,
OTF_KeyValueList *list );
/* # OTF_FILEOPERATION_RECORD */
@ -310,24 +386,28 @@ typedef int (OTF_Handler_FileOperation) ( void* userData,
uint32_t operation,
uint64_t bytes,
uint64_t duration,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_BEGINFILEOP_RECORD */
typedef int (OTF_Handler_BeginFileOperation) ( void* userData,
uint64_t time,
uint32_t process,
uint64_t handleid,
uint32_t scltoken );
uint64_t matchingId,
uint32_t scltoken,
OTF_KeyValueList *list );
/* # OTF_ENDFILEOP_RECORD */
typedef int (OTF_Handler_EndFileOperation) ( void* userData,
uint64_t time,
uint32_t process,
uint32_t fileid,
uint64_t handleid,
uint64_t matchingId,
uint64_t handleId,
uint32_t operation,
uint64_t bytes,
uint32_t scltoken );
uint32_t scltoken,
OTF_KeyValueList *list );
/* # OTF_RMAPUT_RECORD */
typedef int (OTF_Handler_RMAPut) ( void* userData,
@ -338,7 +418,8 @@ typedef int (OTF_Handler_RMAPut) ( void* userData,
uint32_t communicator,
uint32_t tag,
uint64_t bytes,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_RMAPUTRE_RECORD */
typedef int (OTF_Handler_RMAPutRemoteEnd) ( void* userData,
@ -349,7 +430,8 @@ typedef int (OTF_Handler_RMAPutRemoteEnd) ( void* userData,
uint32_t communicator,
uint32_t tag,
uint64_t bytes,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_RMAGET_RECORD */
typedef int (OTF_Handler_RMAGet) ( void* userData,
@ -360,7 +442,8 @@ typedef int (OTF_Handler_RMAGet) ( void* userData,
uint32_t communicator,
uint32_t tag,
uint64_t bytes,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_RMAEND_RECORD */
typedef int (OTF_Handler_RMAEnd) ( void* userData,
@ -369,7 +452,8 @@ typedef int (OTF_Handler_RMAEnd) ( void* userData,
uint32_t remote,
uint32_t communicator,
uint32_t tag,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* typedefs for OTF snapshot records *************************************** */
@ -379,7 +463,8 @@ typedef int (OTF_Handler_RMAEnd) ( void* userData,
typedef int (OTF_Handler_SnapshotComment) ( void* userData,
uint64_t time,
uint32_t process,
const char* comment );
const char* comment,
OTF_KeyValueList *list );
/* # OTF_ENTERSNAPSHOT_RECORD */
typedef int (OTF_Handler_EnterSnapshot) ( void *userData,
@ -387,7 +472,8 @@ typedef int (OTF_Handler_EnterSnapshot) ( void *userData,
uint64_t originaltime,
uint32_t function,
uint32_t process,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_SENDSNAPSHOT_RECORD */
typedef int (OTF_Handler_SendSnapshot) ( void *userData,
@ -397,7 +483,9 @@ typedef int (OTF_Handler_SendSnapshot) ( void *userData,
uint32_t receiver,
uint32_t procGroup,
uint32_t tag,
uint32_t source );
uint32_t length,
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_OPENFILESNAPSHOT_RECORD */
typedef int (OTF_Handler_OpenFileSnapshot) ( void* userData,
@ -406,7 +494,31 @@ typedef int (OTF_Handler_OpenFileSnapshot) ( void* userData,
uint32_t fileid,
uint32_t process,
uint64_t handleid,
uint32_t source );
uint32_t source,
OTF_KeyValueList *list );
/* # OTF_BEGINCOLLOPSNAPSHOT_RECORD */
typedef int (OTF_Handler_BeginCollopSnapshot) ( void* userData,
uint64_t time,
uint64_t originaltime,
uint32_t process,
uint32_t collOp,
uint64_t matchingId,
uint32_t procGroup,
uint32_t rootProc,
uint64_t sent,
uint64_t received,
uint32_t scltoken,
OTF_KeyValueList *list );
/* # OTF_BEGINFILEOPSNAPSHOT_RECORD */
typedef int (OTF_Handler_BeginFileOpSnapshot) ( void* userData,
uint64_t time,
uint64_t originaltime,
uint32_t process,
uint64_t matchingId,
uint32_t scltoken,
OTF_KeyValueList *list );
/* typedefs for OTF summary records **************************************** */
@ -416,7 +528,8 @@ typedef int (OTF_Handler_OpenFileSnapshot) ( void* userData,
typedef int (OTF_Handler_SummaryComment) ( void* userData,
uint64_t time,
uint32_t process,
const char* comment );
const char* comment,
OTF_KeyValueList *list );
/* # OTF_FUNCTIONSUMMARY_RECORD */
typedef int (OTF_Handler_FunctionSummary) ( void* userData,
@ -425,7 +538,8 @@ typedef int (OTF_Handler_FunctionSummary) ( void* userData,
uint32_t process,
uint64_t invocations,
uint64_t exclTime,
uint64_t inclTime );
uint64_t inclTime,
OTF_KeyValueList *list );
/* # OTF_FUNCTIONGROUPSUMMARY_RECORD */
typedef int (OTF_Handler_FunctionGroupSummary) ( void* userData,
@ -434,7 +548,8 @@ typedef int (OTF_Handler_FunctionGroupSummary) ( void* userData,
uint32_t process,
uint64_t invocations,
uint64_t exclTime,
uint64_t inclTime );
uint64_t inclTime,
OTF_KeyValueList *list );
/* # OTF_MESSAGESUMMARY_RECORD */
typedef int (OTF_Handler_MessageSummary) ( void* userData,
@ -446,7 +561,8 @@ typedef int (OTF_Handler_MessageSummary) ( void* userData,
uint64_t sentNumber,
uint64_t receivedNumber,
uint64_t sentBytes,
uint64_t receivedBytes );
uint64_t receivedBytes,
OTF_KeyValueList *list );
/* # OTF_COLLOPSUMMARY_RECORD */
typedef int (OTF_Handler_CollopSummary) ( void *userData,
@ -457,7 +573,8 @@ typedef int (OTF_Handler_CollopSummary) ( void *userData,
uint64_t sentNumber,
uint64_t receivedNumber,
uint64_t sentBytes,
uint64_t receivedBytes );
uint64_t receivedBytes,
OTF_KeyValueList *list );
/* # OTF_FILEOPERATIONSUMMARY_RECORD */
typedef int (OTF_Handler_FileOperationSummary) ( void* userData,
@ -470,7 +587,8 @@ typedef int (OTF_Handler_FileOperationSummary) ( void* userData,
uint64_t nwrite,
uint64_t nseek,
uint64_t bytesread,
uint64_t byteswrite );
uint64_t byteswrite,
OTF_KeyValueList *list );
/* # OTF_FILEGROUPOPERATIONSUMMARY_RECORD */
typedef int (OTF_Handler_FileGroupOperationSummary) ( void* userData,
@ -483,7 +601,8 @@ typedef int (OTF_Handler_FileGroupOperationSummary) ( void* userData,
uint64_t nwrite,
uint64_t nseek,
uint64_t bytesread,
uint64_t byteswrite );
uint64_t byteswrite,
OTF_KeyValueList *list );
/* # OTF_UNKNOWN_RECORD */
typedef int (OTF_Handler_UnknownRecord) ( void *userData,
@ -500,14 +619,16 @@ typedef int (OTF_Handler_DefMarker) ( void *userData,
uint32_t stream,
uint32_t token,
const char* name,
uint32_t type );
uint32_t type,
OTF_KeyValueList *list );
/* # OTF_MARKER_RECORD */
typedef int (OTF_Handler_Marker) ( void *userData,
uint64_t time,
uint32_t process,
uint32_t token,
const char* text );
const char* text,
OTF_KeyValueList *list );
/** @endcond */

927
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_KeyValue.c Обычный файл
Просмотреть файл

@ -0,0 +1,927 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch, Johannes Spazier
*/
#include "OTF_KeyValue.h"
#include "OTF_Errno.h"
#include <stdlib.h>
#include <string.h>
uint8_t OTF_KeyValueList_getValue(OTF_KeyValueList *list, uint32_t key, OTF_Type otf_type, OTF_Value *otf_value);
OTF_KeyValueList *OTF_KeyValueList_new() {
OTF_KeyValueList *list = (OTF_KeyValueList*) malloc( sizeof(OTF_KeyValueList) );
if (list == NULL) {
/* error: not enough memory left */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n",
__FUNCTION__, __FILE__, __LINE__ );
return NULL;
}
list->kvBegin = (OTF_KeyValuePairList*) malloc( sizeof(OTF_KeyValuePairList) );
if (list->kvBegin == NULL) {
/* error: not enough memory left */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n",
__FUNCTION__, __FILE__, __LINE__ );
free(list);
return NULL;
}
list->kvBegin->kvNext = NULL;
list->kvBegin->kvPrev = NULL;
list->kvEnd = list->kvCurrent = list->kvBegin;
list->key_count = 0;
list->count = 0;
list->size = 1;
if( OTF_KeyValueList_realloc(list, 9) ) {
/* an error ocurred while realloc */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n",
__FUNCTION__, __FILE__, __LINE__ );
OTF_KeyValueList_close(list);
return NULL;
}
return list;
}
uint8_t OTF_KeyValueList_close(OTF_KeyValueList* list) {
OTF_KeyValuePairList *next;
OTF_KeyValuePairList *p;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 1;
}
p = list->kvBegin;
while (p->kvNext != NULL) {
next = p->kvNext;
free(p);
p = next;
}
free(p);
free(list);
return 0;
}
uint8_t OTF_KeyValueList_reset(OTF_KeyValueList* list) {
/*OTF_KeyValuePairList *next;
OTF_KeyValuePairList *p;
int num = 0;*/
if ( list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 1;
}
list->kvCurrent = list->kvBegin;
list->key_count = 0;
list->count = 0;
/* deallocate memory, reduce size. */
/* this is likely slower than keep the allocated memory */
/*
p = list->kvBegin;
while (p != NULL && num < 9) {
p = p->kvNext;
num++;
}
list->size = 10;
list->kvEnd = p;
p = p->kvNext;
while (p != NULL) {
next = p->kvNext;
free(p);
p = next;
}
list->kvEnd->kvNext = NULL;
*/
return 0;
}
uint8_t OTF_KeyValueList_realloc(OTF_KeyValueList* list, uint32_t num) {
uint32_t i;
OTF_KeyValuePairList *p;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 1;
}
p = list->kvEnd;
for( i=0; i<num; i++ ) {
p->kvNext = (OTF_KeyValuePairList*) malloc( sizeof(OTF_KeyValuePairList) );
if( p->kvNext == NULL) {
/* error: not enough memory left */
/* maybe some memory was allocated before, therefore increase list */
list->kvEnd = p;
list->size += i;
return 1;
}
p->kvNext->kvPrev = p;
p = p->kvNext;
p->kvNext = NULL;
}
list->kvEnd = p;
list->size += num;
return 0;
}
uint8_t OTF_KeyValueList_appendPair(OTF_KeyValueList* list, OTF_KeyValuePair pair) {
OTF_KeyValuePairList *p;
uint32_t i;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 255;
}
p = list->kvBegin;
/* check if key already exists */
for ( i=0; i<list->count; i++) {
/* for byte arrays it is ok that one key can be multiple times in list
--> OTF_KeyValueList_appendByteArray() controls the rest */
if ( (p->kvPair.key == pair.key) && ( pair.type != OTF_BYTE_ARRAY ) ) {
return 1;
}
p = p->kvNext;
}
p = list->kvCurrent;
if ( (list->size - list->count) <= 1 ) {
if( OTF_KeyValueList_realloc(list, 10) ) {
/* an error ocurred while realloc */
if ( (list->size - list->count) < 1 ) {
/* if no memory left, return with error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no memory left.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 255;
}
}
}
if( ( list->kvCurrent->kvPrev == NULL ) || ( list->kvCurrent->kvPrev->kvPair.key != pair.key ) ) {
list->key_count++;
}
p->kvPair = pair;
list->kvCurrent = p->kvNext;
list->count++;
return 0;
}
uint8_t OTF_KeyValueList_appendChar(OTF_KeyValueList* list, uint32_t key, char value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_CHAR;
pair.value.otf_char = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendInt8(OTF_KeyValueList* list, uint32_t key, int8_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_INT8;
pair.value.otf_int8 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendUint8(OTF_KeyValueList* list, uint32_t key, uint8_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_UINT8;
pair.value.otf_uint8 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendInt16(OTF_KeyValueList* list, uint32_t key, int16_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_INT16;
pair.value.otf_int16 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendUint16(OTF_KeyValueList* list, uint32_t key, uint16_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_UINT16;
pair.value.otf_uint16 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendInt32(OTF_KeyValueList* list, uint32_t key, int32_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_INT32;
pair.value.otf_int32 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendUint32(OTF_KeyValueList* list, uint32_t key, uint32_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_UINT32;
pair.value.otf_uint32 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendInt64(OTF_KeyValueList* list, uint32_t key, int64_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_INT64;
pair.value.otf_int64 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendUint64(OTF_KeyValueList* list, uint32_t key, uint64_t value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_UINT64;
pair.value.otf_uint64 = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendFloat(OTF_KeyValueList* list, uint32_t key, float value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_FLOAT;
pair.value.otf_float = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendDouble(OTF_KeyValueList* list, uint32_t key, double value) {
OTF_KeyValuePair pair;
pair.key = key;
pair.type = OTF_DOUBLE;
pair.value.otf_double = value;
return OTF_KeyValueList_appendPair(list, pair);
}
uint8_t OTF_KeyValueList_appendByteArray(OTF_KeyValueList* list, uint32_t key, uint8_t *value, uint32_t len) {
OTF_KeyValuePair pair;
uint32_t remaining_len = len;
uint8_t ret = 0;
/* check here if key is not in list */
if( ! OTF_KeyValueList_hasKey( list, key ) ) {
/* key already in list */
return 1;
}
while( ( remaining_len > 0 ) && ( ! ret ) ) {
len = remaining_len;
if (remaining_len > OTF_KEYVALUE_MAX_ARRAY_LEN) {
len = OTF_KEYVALUE_MAX_ARRAY_LEN;
}
pair.key = key;
pair.type = OTF_BYTE_ARRAY;
memcpy(pair.value.otf_byte_array.array, value, len);
value+=len;
pair.value.otf_byte_array.len = remaining_len;
ret = OTF_KeyValueList_appendPair(list, pair);
remaining_len -= len;
}
return ret;
}
uint8_t OTF_KeyValueList_appendKeyValueList(OTF_KeyValueList *dest_list, OTF_KeyValueList *source_list) {
OTF_KeyValuePairList *p;
uint32_t i;
if ( source_list == NULL) {
return 1;
}
p = source_list->kvBegin;
for( i = 0; i < source_list->count; i++ ) {
if ( 255 == OTF_KeyValueList_appendPair(dest_list, p->kvPair) ) {
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"error while appending OTF_KeyValueList.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 1;
}
p = p->kvNext;
}
return 0;
}
double OTF_Int64ToDouble(uint64_t value) {
double *d = (double*) &value;
return *d;
}
uint64_t OTF_DoubleToInt64(double value) {
uint64_t *i = (uint64_t*) &value;
return *i;
}
float OTF_Int32ToFloat(uint32_t value) {
float *d = (float*) &value;
return *d;
}
uint32_t OTF_FloatToInt32(float value) {
uint32_t *i = (uint32_t*) &value;
return *i;
}
uint8_t OTF_KeyValueList_getValue(OTF_KeyValueList *list, uint32_t key, OTF_Type otf_type, OTF_Value *otf_value) {
OTF_KeyValuePairList *p;
uint32_t i;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 255;
}
p = list->kvBegin;
/* search key */
for ( i=0; i<list->count; i++) {
if ( p->kvPair.key == key ) {
if ( p->kvPair.type == otf_type) {
*otf_value = p->kvPair.value;
/* found matching key and type, all right */
return 0;
} else {
/* type of found key differs */
return 2;
}
}
p = p->kvNext;
}
/* no key in list matches the searched key */
return 1;
}
uint8_t OTF_KeyValueList_getChar(OTF_KeyValueList *list, uint32_t key, char *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_CHAR, &otf_value)) ) {
*value = otf_value.otf_char;
}
return ret;
}
uint8_t OTF_KeyValueList_getInt8(OTF_KeyValueList *list, uint32_t key, int8_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_INT8, &otf_value)) ) {
*value = otf_value.otf_int8;
}
return ret;
}
uint8_t OTF_KeyValueList_getUint8(OTF_KeyValueList *list, uint32_t key, uint8_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_UINT8, &otf_value)) ) {
*value = otf_value.otf_uint8;
}
return ret;
}
uint8_t OTF_KeyValueList_getInt16(OTF_KeyValueList *list, uint32_t key, int16_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_INT16, &otf_value)) ) {
*value = otf_value.otf_int16;
}
return ret;
}
uint8_t OTF_KeyValueList_getUint16(OTF_KeyValueList *list, uint32_t key, uint16_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_UINT16, &otf_value)) ) {
*value = otf_value.otf_uint16;
}
return ret;
}
uint8_t OTF_KeyValueList_getInt32(OTF_KeyValueList *list, uint32_t key, int32_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_INT32, &otf_value)) ) {
*value = otf_value.otf_int32;
}
return ret;
}
uint8_t OTF_KeyValueList_getUint32(OTF_KeyValueList *list, uint32_t key, uint32_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_UINT32, &otf_value)) ) {
*value = otf_value.otf_uint32;
}
return ret;
}
uint8_t OTF_KeyValueList_getInt64(OTF_KeyValueList *list, uint32_t key, int64_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_INT64, &otf_value)) ) {
*value = otf_value.otf_int64;
}
return ret;
}
uint8_t OTF_KeyValueList_getUint64(OTF_KeyValueList *list, uint32_t key, uint64_t *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_UINT64, &otf_value)) ) {
*value = otf_value.otf_uint64;
}
return ret;
}
uint8_t OTF_KeyValueList_getFloat(OTF_KeyValueList *list, uint32_t key, float *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_FLOAT, &otf_value)) ) {
*value = otf_value.otf_float;
}
return ret;
}
uint8_t OTF_KeyValueList_getDouble(OTF_KeyValueList *list, uint32_t key, double *value) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_DOUBLE, &otf_value)) ) {
*value = otf_value.otf_double;
}
return ret;
}
uint8_t OTF_KeyValueList_getByteArray(OTF_KeyValueList *list, uint32_t key, uint8_t *value, uint32_t *len) {
OTF_KeyValuePairList *p;
uint32_t i;
uint32_t max_len;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 255;
}
p = list->kvBegin;
max_len = *len;
*len = 0;
/* search key */
for ( i=0; i<list->count; i++) {
if ( p->kvPair.key == key ) {
if ( p->kvPair.type == OTF_BYTE_ARRAY) {
if( p->kvPair.value.otf_byte_array.len <= OTF_KEYVALUE_MAX_ARRAY_LEN ) {
if( ( *len + p->kvPair.value.otf_byte_array.len ) > max_len ) {
/* allocated memory pointed by "value" is not big enough to store the howle byte array */
/* fill memory until the end and exit with an error-code */
memcpy(value, p->kvPair.value.otf_byte_array.array, max_len - *len);
*len = max_len;
return 255;
}
*len += p->kvPair.value.otf_byte_array.len;
memcpy(value, p->kvPair.value.otf_byte_array.array, p->kvPair.value.otf_byte_array.len);
/* end of byte array reached, all right */
return 0;
} else {
if( ( *len + OTF_KEYVALUE_MAX_ARRAY_LEN ) > max_len ) {
/* allocated memory pointed by "value" is not big enough to store the howle byte array */
/* fill memory until the end and exit with an error-code */
memcpy(value, p->kvPair.value.otf_byte_array.array, max_len - *len);
*len = max_len;
return 255;
}
*len += OTF_KEYVALUE_MAX_ARRAY_LEN;
memcpy(value, p->kvPair.value.otf_byte_array.array, OTF_KEYVALUE_MAX_ARRAY_LEN);
value += OTF_KEYVALUE_MAX_ARRAY_LEN;
}
} else {
/* type of found key differs */
return 2;
}
} else {
if( *len > 0 ) {
/* byte-array not completed */
return 255;
}
}
p = p->kvNext;
}
/* no key in list matches the searched key */
return 1;
}
uint8_t OTF_KeyValueList_getArrayLength(OTF_KeyValueList *list, uint32_t key, uint32_t *len) {
OTF_Value otf_value;
int ret;
if( ! (ret = OTF_KeyValueList_getValue(list, key, OTF_BYTE_ARRAY, &otf_value)) ) {
*len = otf_value.otf_byte_array.len;
}
return ret;
}
OTF_Type OTF_KeyValueList_getTypeForKey(OTF_KeyValueList *list, uint32_t key) {
OTF_KeyValuePairList *p;
uint32_t i;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return OTF_UNKNOWN;
}
p = list->kvBegin;
/* search key */
for ( i=0; i<list->count; i++) {
if ( p->kvPair.key == key ) {
/* found matching key, all right, return type */
return p->kvPair.type;
}
p = p->kvNext;
}
return OTF_UNKNOWN;
}
uint8_t OTF_KeyValueList_hasKey(OTF_KeyValueList *list, uint32_t key) {
OTF_KeyValuePairList *p;
uint32_t i;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 2;
}
p = list->kvBegin;
/* search key */
for ( i=0; i<list->count; i++) {
if ( p->kvPair.key == key ) {
/* found matching key, all right, return true */
return 0;
}
p = p->kvNext;
}
/* key not found, return false */
return 1;
}
uint8_t OTF_KeyValueList_removeKey(OTF_KeyValueList *list, uint32_t key) {
OTF_KeyValuePairList *p;
uint32_t i;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 2;
}
p = list->kvBegin;
/* search key */
for ( i=0; i<list->count; i++) {
if ( p->kvPair.key == key ) {
/* found matching key, remove them, return true */
if ( p->kvPrev ) {
p->kvPrev->kvNext = p->kvNext;
} else {
list->kvBegin = p->kvNext;
}
if ( p->kvNext ) {
p->kvNext->kvPrev = p->kvPrev;
}
free(p);
list->count--;
return 0;
}
p = p->kvNext;
}
/* key not found, return false */
return 1;
}
uint8_t OTF_KeyValueList_getKeyByIndex(OTF_KeyValueList *list, uint32_t index, uint32_t *key) {
OTF_KeyValuePairList *p;
uint32_t i;
uint32_t prev_key = 0;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 2;
}
if (index >= list->key_count) {
/* no key for this index */
return 1;
}
p = list->kvBegin;
prev_key = p->kvPair.key;
/* go to key */
for ( i=0; i<index; i++) {
p = p->kvNext;
if( p->kvPair.key == prev_key ) {
i--;
}
prev_key = p->kvPair.key;
}
/* save found key for index */
*key = p->kvPair.key;
return 0;
}
uint8_t OTF_KeyValueList_getPairByIndex(OTF_KeyValueList *list, uint32_t index, OTF_KeyValuePair **pair) {
OTF_KeyValuePairList *p;
uint32_t i;
uint32_t prev_key = 0;
if (list == NULL) {
/* error */
OTF_fprintf( stderr, "ERROR in function %s, file: %s, line: %i:\n "
"no list has been specified.\n",
__FUNCTION__, __FILE__, __LINE__ );
return 2;
}
if (index >= list->key_count) {
/* no key for this index */
return 1;
}
p = list->kvBegin;
prev_key = p->kvPair.key;
/* go to key */
for ( i=0; i<index; i++) {
p = p->kvNext;
if( p->kvPair.key == prev_key ) {
i--;
}
prev_key = p->kvPair.key;
}
/* save found key-value pair for index */
*pair = &(p->kvPair);
return 0;
}
uint32_t OTF_KeyValueList_getCount(OTF_KeyValueList *list) {
return list->key_count;
}

913
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_KeyValue.h Обычный файл
Просмотреть файл

@ -0,0 +1,913 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch, Johannes Spazier
*/
/**
* @file OTF_KeyValue.h
*
* @brief Provides an additional list of key value pairs that can be added to records.
*
* \ingroup keyvalue
*/
/**
* \defgroup keyvalue KeyValueList Interface
*
* Provides an additional list of key-value pairs that can be added to records.
*
* \section keyvalue_write_example A short Example of writing a KeyValueList
*
* You can append key-value pairs to an OTF_KeyValueList instance that can be added to any record.
*
* After one call to OTF_Writer_writeXxxKV() the given KeyValueList instance will be empty.
*
* \code
* #include <assert.h>
* #include "otf.h"
*
* int main( int argc, char** argv ) {
*
* OTF_FileManager* manager;
* OTF_Writer* writer;
* OTF_KeyValueList* KeyValueList;
*
* manager= OTF_FileManager_open( 100 );
* assert( manager );
*
* writer = OTF_Writer_open( "mytrace", 1, manager );
* assert( writer );
* \endcode
*
* Initialize the prior declared OTF_KeyValueList.
*
* \code
* KeyValueList = OTF_KeyValueList_new();
* \endcode
*
* Write a DefKeyValue record that assigns key=1 to name="first_arg" with description="first argument of function" and type=OTF_INT32.
* \code
* OTF_Writer_writeDefKeyValue( writer, 0, 1, OTF_INT32, "first_arg", "first argument of function" );
* \endcode
*
* Append a signed integer for key=1 to the initialized KeyValueList.
* \code
* OTF_KeyValueList_appendInt32( KeyValueList, 1, 25);
* \endcode
*
* Write the entries of the KeyValueList together with the enter record.
* Afterwards the KeyValueList will be empty!
* \code
* OTF_Writer_writeEnterKV( writer, 10000, 100, 1, 0, KeyValueList );
* \endcode
*
* Clean up before exiting the program. Close the OTF_KeyValueList.
* \code
* OTF_KeyValueList_close( KeyValueList );
* OTF_Writer_close( writer );
* OTF_FileManager_close( manager );
*
* return 0;
* }
* \endcode
*
* Compile this using $ gcc -o write write.c `otfconfig --libs`.
*
*
* \section keyvalue_read_example A short Example of reading from a KeyValueList
*
* \code
* #include <assert.h>
* #include <stdio.h>
* #include <string.h>
* #include "otf.h"
*
* int global_key = 0;
*
* \endcode
*
* Define a callback to read all DefKeyValue records.
* \code
* int handleDefKeyValue( void* userData, uint32_t stream, uint32_t key, OTF_Type type, const char* name, const char *description ) {
* \endcode
*
* Find out which key you are looking for.
* \code
* if( strcmp( name, "first_arg") == 0 ) {
* global_key = key;
* }
*
* return OTF_RETURN_OK;
* }
* \endcode
*
* Define a callback to read all enter records.
* \code
* int handleEnter (void *userData, uint64_t time, uint32_t function, uint32_t process, uint32_t source, OTF_KeyValueList *list) {
*
* int value;
*
* \endcode
*
* Ask for a key value pair with key=global_key. Save the value in variable "value".
* \code
* switch( OTF_KeyValueList_getInt32( list, global_key, &value) ) {
* case 0:
* printf("We entered function %u with argument %d\n", function, value);
* break;
* case 1:
* printf("We entered function %u with no argument.\n", function);
* break;
* default:
* printf("An error occurred while asking for key value pair.\n");
* }
*
* return OTF_RETURN_OK;
* }
*
* \endcode
*
* main() includes the common instructions to read an .otf-file.
* \code
* int main( int argc, char** argv ) {
*
* OTF_FileManager* manager;
* OTF_Reader* reader;
* OTF_HandlerArray* handlers;
*
* manager= OTF_FileManager_open( 100 );
* assert( manager );
*
* handlers = OTF_HandlerArray_open();
* assert( handlers );
*
* reader = OTF_Reader_open( "mytrace", manager );
* assert( reader );
*
* OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefKeyValue, OTF_DEFKEYVALUE_RECORD );
* OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleEnter, OTF_ENTER_RECORD );
*
* OTF_Reader_readDefinitions( reader, handlers );
* OTF_Reader_readEvents( reader, handlers );
*
* OTF_Reader_close( reader );
* OTF_HandlerArray_close( handlers );
* OTF_FileManager_close( manager );
*
* return 0;
* }
* \endcode
*
* Compile this using $ gcc -o read read.c `otfconfig --libs`.
*
*/
#ifndef OTF_KEYVALUE_H
#define OTF_KEYVALUE_H
#include "OTF_inttypes.h"
#include "OTF_Definitions.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/** An enum which holds all OTF datatypes that are relevant for OTF_KeyValueList. \ingroup miscellaneous */
typedef enum OTF_Type_enum {
OTF_UNKNOWN = -1,
OTF_CHAR = 0, /**< */
OTF_INT8 = 1, /**< */
OTF_UINT8 = 2, /**< */
OTF_INT16 = 3, /**< */
OTF_UINT16 = 4, /**< */
OTF_INT32 = 5, /**< */
OTF_UINT32 = 6, /**< */
OTF_INT64 = 7, /**< */
OTF_UINT64 = 8, /**< */
OTF_FLOAT = 9, /**< */
OTF_DOUBLE = 10, /**< */
OTF_BYTE_ARRAY = 11 /**< */
} OTF_Type;
/** @cond OTF_KeyValue */
/** the following lines are ignored by doxygen */
typedef struct byte_array_struct {
uint8_t array[OTF_KEYVALUE_MAX_ARRAY_LEN];
uint32_t len;
} byte_array;
typedef union OTF_Value_union {
char otf_char;
int8_t otf_int8;
uint8_t otf_uint8;
int16_t otf_int16;
uint16_t otf_uint16;
int32_t otf_int32;
uint32_t otf_uint32;
int64_t otf_int64;
uint64_t otf_uint64;
float otf_float;
double otf_double;
byte_array otf_byte_array;
} OTF_Value;
struct OTF_KeyValuePair_struct {
uint32_t key;
OTF_Type type;
OTF_Value value;
};
typedef struct OTF_KeyValuePairList_struct {
struct OTF_KeyValuePair_struct kvPair;
struct OTF_KeyValuePairList_struct *kvNext;
struct OTF_KeyValuePairList_struct *kvPrev;
} OTF_KeyValuePairList;
struct OTF_KeyValueList_struct {
uint32_t key_count; /* number of different keys in list --> user-relevant */
uint32_t count; /* total number of entries in list (treat byte arrays particular) --> internal use only */
uint32_t size; /* number of allocated entries --> internal */
OTF_KeyValuePairList *kvBegin;
OTF_KeyValuePairList *kvEnd;
OTF_KeyValuePairList *kvCurrent;
};
/** @endcond */
/** Object type which holds a key-value list.*/
typedef struct OTF_KeyValueList_struct OTF_KeyValueList;
/** Object type which holds a key-value pair.*/
typedef struct OTF_KeyValuePair_struct OTF_KeyValuePair;
/**
* Create a new OTF_KeyValueList instance.
*
* @return Initialized OTF_KeyValueList instance or NULL if an error
* occurred.
*
* \ingroup keyvalue
*/
OTF_KeyValueList *OTF_KeyValueList_new(void);
/**
* Close an OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @return 0 if instance was closed successfully and 1 otherwise.
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_close(OTF_KeyValueList* list);
/**
* Reset an OTF_KeyValueList instance without deallocating memory.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @return 0 on success, 1 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_reset(OTF_KeyValueList* list);
/**
* Expand an OTF_KeyValueList by allocating more memory.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param num Number of elements for which memory should be allocated.
*
* @return 0 on success, 1 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_realloc(OTF_KeyValueList* list, uint32_t num);
/** @cond OTF_KeyValue */
/** the following lines are ignored by doxygen */
/**
* Append an OTF_KeyValuePair to a given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param pair An initialized OTF_KeyValuePair object.
*
* @return 0 on success, 1 if pair already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendPair(OTF_KeyValueList* list, OTF_KeyValuePair pair);
/** @endcond */
/**
* Append a character to a given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A character that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendChar(OTF_KeyValueList* list, uint32_t key, char value);
/**
* Append a signed integer of 8 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A signed integer of 8 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendInt8(OTF_KeyValueList* list, uint32_t key, int8_t value);
/**
* Append an unsigned integer of 8 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value An unsigned integer of 8 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendUint8(OTF_KeyValueList* list, uint32_t key, uint8_t value);
/**
* Append a signed integer of 16 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A signed integer of 16 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendInt16(OTF_KeyValueList* list, uint32_t key, int16_t value);
/**
* Append an unsigned integer of 16 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value An unsigned integer of 16 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendUint16(OTF_KeyValueList* list, uint32_t key, uint16_t value);
/**
* Append a signed integer of 32 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A signed integer of 32 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendInt32(OTF_KeyValueList* list, uint32_t key, int32_t value);
/**
* Append an unsigned integer of 32 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value An unsigned integer of 32 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendUint32(OTF_KeyValueList* list, uint32_t key, uint32_t value);
/**
* Append a signed integer of 64 bit to a OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A signed integer of 64 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendInt64(OTF_KeyValueList* list, uint32_t key, int64_t value);
/**
* Append an unsigned integer of 64 bit to a given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value An unsigned integer of 64 bit that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendUint64(OTF_KeyValueList* list, uint32_t key, uint64_t value);
/**
* Append a float to a given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A float that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendFloat(OTF_KeyValueList* list, uint32_t key, float value);
/**
* Append a double to a given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value A double that should be appended to the KeyValueList.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendDouble(OTF_KeyValueList* list, uint32_t key, double value);
/**
* Append a byte array to a given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the KeyValueList.
*
* @param value Pointer to a byte array that should be appended to the KeyValueList.
*
* @param len Lenght of byte array.
*
* @return 0 on success, 1 if key already in list and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendByteArray(OTF_KeyValueList* list, uint32_t key, uint8_t *value, uint32_t len);
/**
* Append an existing OTF_KeyValueList to a given OTF_KeyValueList instance.
*
* @param dest_list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param source_list Pointer to an initialized OTF_KeyValueList instance that shall be appended to the given KeyValueList.
* See also OTF_KeyValueList_new();
*
* @return 0 on success, 1 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_appendKeyValueList(OTF_KeyValueList* dest_list, OTF_KeyValueList *source_list);
/**
* Read a character from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param value Pointer to a char array, where the result is saved.
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getChar(OTF_KeyValueList *list, uint32_t key, char *value);
/**
* Read a signed integer of 8 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to a signed integer of 8 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getInt8(OTF_KeyValueList *list, uint32_t key, int8_t *value);
/**
* Read an unsigned integer of 8 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to an unsigned integer of 8 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getUint8(OTF_KeyValueList *list, uint32_t key, uint8_t *value);
/**
* Read a signed integer of 16 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to a signed integer of 16 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getInt16(OTF_KeyValueList *list, uint32_t key, int16_t *value);
/**
* Read an unsigned integer of 16 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to an unsigned integer of 16 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getUint16(OTF_KeyValueList *list, uint32_t key, uint16_t *value);
/**
* Read a signed integer of 32 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to a signed integer of 32 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getInt32(OTF_KeyValueList *list, uint32_t key, int32_t *value);
/**
* Read an unsigned integer of 32 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to an unsigned integer of 32 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getUint32(OTF_KeyValueList *list, uint32_t key, uint32_t *value);
/**
* Read a signed integer of 64 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
*
* @param value Pointer to a signed integer of 64 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getInt64(OTF_KeyValueList *list, uint32_t key, int64_t *value);
/**
* Read an unsigned integer of 64 bit from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
*
* @param value Pointer to an unsigned integer of 64 bit, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getUint64(OTF_KeyValueList *list, uint32_t key, uint64_t *value);
/**
* Read a float from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to a float, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getFloat(OTF_KeyValueList *list, uint32_t key, float *value);
/**
* Read a double from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to a double, where the result is saved.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getDouble(OTF_KeyValueList *list, uint32_t key, double *value);
/**
* Read a byte array from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the value in the OTF_KeyValueList.
*
* @param value Pointer to an allocated byte array, where the result is saved.
*
* @param len Input and output parameter: Musst contain the number of bytes
* that can be written to the buffer pointed by the parameter \a value.
* Therefore at least \a len bytes musst be allocated for this buffer before.
* At the end \e len contains the number of bytes written to the buffer.
* This can be less or equal to the input of parameter \a len. To get the
* total number of bytes stored in the byte-array for the specific \a key you
* can use the function OTF_KeyValueList_getArrayLength() before.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getByteArray(OTF_KeyValueList *list, uint32_t key, uint8_t *value, uint32_t *len);
/**
* Provides the lenght of a byte array in an OTF_KeyValueList instance by given key.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the pair in the OTF_KeyValueList.
*
* @param len Return value for the array length.
*
* @return 0 on success, 1 if key not found, 2 if type differs
* and 255 if an error occurs
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getArrayLength(OTF_KeyValueList *list, uint32_t key, uint32_t *len);
/**
* Search for key in given OTF_KeyValueList instance and return its type.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key An unique id that identifies the pair in the OTF_KeyValueList.
*
* @return OTF_Type on success, OTF_UNKNOWN if key not found or an error occurred.
*
* \ingroup keyvalue
*/
OTF_Type OTF_KeyValueList_getTypeForKey(OTF_KeyValueList *list, uint32_t key);
/**
* Search for key in the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key Token that shall be searched in the OTF_KeyValueList.
*
* @return 0 on success, 1 if key not found or an error occurred.
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_hasKey(OTF_KeyValueList *list, uint32_t key);
/**
* Remove key from the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @param key Token that shall be removed from the OTF_KeyValueList.
*
* @return 0 on success, 1 if key not found or an error occurred.
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_removeKey(OTF_KeyValueList *list, uint32_t key);
/**
* Search for a key at the given index position.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
* @param index Index position in the OTF_KeyValueList.
*
* @param key Return value for the found key.
*
* @return 0 on success, 1 if index not in list
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getKeyByIndex(OTF_KeyValueList *list, uint32_t index, uint32_t *key);
/**
* Search for a key-value pair at the given index position.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
* @param index Index position in the OTF_KeyValueList.
*
* @param pair Pointer to the found key-value pair.
*
* @return 0 on success, 1 if index not in list
*
* \ingroup keyvalue
*/
uint8_t OTF_KeyValueList_getPairByIndex(OTF_KeyValueList *list, uint32_t index, OTF_KeyValuePair **pair);
/**
* Returns the number of elements in the given OTF_KeyValueList instance.
*
* @param list Pointer to an initialized OTF_KeyValueList object. See
* also OTF_KeyValueList_new().
*
* @return Number of elements currently in list.
*
* \ingroup keyvalue
*/
uint32_t OTF_KeyValueList_getCount(OTF_KeyValueList *list);
/**
* Convert an integer of 32 bit to a float.
*
* \ingroup keyvalue
*/
float OTF_Int32ToFloat(uint32_t value);
/**
* Convert a float to an integer of 32 bit.
*
* \ingroup keyvalue
*/
uint32_t OTF_FloatToInt32(float value);
/**
* Convert an integer of 64 bit to a double.
*
* \ingroup keyvalue
*/
double OTF_Int64ToDouble(uint64_t value);
/**
* Convert a double to a signed integer of 64 bit.
*
* \ingroup keyvalue
*/
uint64_t OTF_DoubleToInt64(double value);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OTF_KEYVALUE_H */

62
ompi/contrib/vt/vt/extlib/otf/otflib/OTF_Keywords.h
Просмотреть файл

@ -1,5 +1,5 @@
/*
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2010.
This is part of the OTF library. Copyright by ZIH, TU Dresden 2005-2011.
Authors: Andreas Knuepfer, Holger Brunst, Ronny Brendel, Thomas Kriebitzsch
*/
@ -15,6 +15,8 @@
#ifndef OTF_KEYWORDS_H
#define OTF_KEYWORDS_H
#include "OTF_KeyValue.h"
/*
define all record format keywords here in order to have a single
@ -67,6 +69,14 @@ the keywords identifying record types must follow some special rules:
#define OTF_KEYWORD_S_DEFPROCESSGROUP "PG"
#define OTF_KEYWORD_F_DEFPROCESSGROUP 'P'
#define OTF_KEYWORD_L_DEFATTRLIST "ATTRIBUTELIST"
#define OTF_KEYWORD_S_DEFATTRLIST "A"
#define OTF_KEYWORD_F_DEFATTRLIST 'A'
#define OTF_KEYWORD_L_DEFPROCESSORGROUPATTR "PROCESSORGROUPATTR"
#define OTF_KEYWORD_S_DEFPROCESSORGROUPATTR "PGA"
#define OTF_KEYWORD_F_DEFPROCESSORGROUPATTR 'P'
#define OTF_KEYWORD_L_DEFFUNCTION "FUNCTION"
#define OTF_KEYWORD_S_DEFFUNCTION "F"
#define OTF_KEYWORD_F_DEFFUNCTION 'F'
@ -115,9 +125,23 @@ the keywords identifying record types must follow some special rules:
#define OTF_KEYWORD_S_DEFFILEGROUP "FLG"
#define OTF_KEYWORD_F_DEFFILEGROUP 'F'
#define OTF_KEYWORD_L_DEFKEYVALUE "KEYVALUE"
#define OTF_KEYWORD_S_DEFKEYVALUE "K"
#define OTF_KEYWORD_F_DEFKEYVALUE 'K'
#define OTF_KEYWORD_L_DEFTIMERANGE "TIMERANGE"
#define OTF_KEYWORD_S_DEFTIMERANGE "TRG"
#define OTF_KEYWORD_F_DEFTIMERANGE 'T'
#define OTF_KEYWORD_L_DEFCOUNTERASSIGNMENTS "COUNTERASSIGNMENTS"
#define OTF_KEYWORD_S_DEFCOUNTERASSIGNMENTS "CA"
#define OTF_KEYWORD_F_DEFCOUNTERASSIGNMENTS 'C'
/* *** event record keywords *** */
#define OTF_KEYWORD_L_NOOP "NOOP"
#define OTF_KEYWORD_S_NOOP "N"
#define OTF_KEYWORD_F_NOOP 'N'
#define OTF_KEYWORD_L_ENTER "ENTER"
#define OTF_KEYWORD_S_ENTER "E"
@ -183,14 +207,24 @@ the keywords identifying record types must follow some special rules:
#define OTF_KEYWORD_S_ENDCOLLECTIVEOPERATION "COPE"
#define OTF_KEYWORD_F_ENDCOLLECTIVEOPERATION 'C'
#define OTF_KEYWORD_L_BEGINFILEOPERATION "FILEOPBEGIN"
#define OTF_KEYWORD_S_BEGINFILEOPERATION "FB"
#define OTF_KEYWORD_F_BEGINFILEOPERATION 'F'
/* the OLD/NEW thing for begin as well to make begin and end handled the same */
#define OTF_KEYWORD_L_ENDFILEOPERATION "FILEOPEND"
#define OTF_KEYWORD_S_ENDFILEOPERATION "FE"
#define OTF_KEYWORD_F_ENDFILEOPERATION 'F'
#define OTF_KEYWORD_L_BEGINFILEOPERATION_OLD "FILEOPBEGIN"
#define OTF_KEYWORD_S_BEGINFILEOPERATION_OLD "FB"
#define OTF_KEYWORD_F_BEGINFILEOPERATION_OLD 'F'
#define OTF_KEYWORD_L_BEGINFILEOPERATION_NEW "FILEOPBEGINNEW"
#define OTF_KEYWORD_S_BEGINFILEOPERATION_NEW "FA"
#define OTF_KEYWORD_F_BEGINFILEOPERATION_NEW 'F'
/* the OLD/NEW thing fixes upward compatibility after changing the record contents */
#define OTF_KEYWORD_L_ENDFILEOPERATION_OLD "FILEOPEND"
#define OTF_KEYWORD_S_ENDFILEOPERATION_OLD "FE"
#define OTF_KEYWORD_F_ENDFILEOPERATION_OLD 'F'
#define OTF_KEYWORD_L_ENDFILEOPERATION_NEW "FILEOPENDNEW"
#define OTF_KEYWORD_S_ENDFILEOPERATION_NEW "FF"
#define OTF_KEYWORD_F_ENDFILEOPERATION_NEW 'F'
/* *** summary record keywords *** */
@ -257,6 +291,13 @@ the keywords identifying record types must follow some special rules:
#define OTF_KEYWORD_S_SNAPSHOT_OPENFILE "OF"
#define OTF_KEYWORD_F_SNAPSHOT_OPENFILE 'O'
#define OTF_KEYWORD_L_SNAPSHOT_BEGINCOLLOP "BEGINCOLLOP"
#define OTF_KEYWORD_S_SNAPSHOT_BEGINCOLLOP "BC"
#define OTF_KEYWORD_F_SNAPSHOT_BEGINCOLLOP 'B'
#define OTF_KEYWORD_L_SNAPSHOT_BEGINFILEOP "BEGINFILEOP"
#define OTF_KEYWORD_S_SNAPSHOT_BEGINFILEOP "BF"
#define OTF_KEYWORD_F_SNAPSHOT_BEGINFILEOP 'B'
/* *** marker keywords */
@ -274,6 +315,10 @@ the keywords identifying record types must follow some special rules:
#define OTF_KEYWORD_F_MARKER_MARKERSPOT 'S'
/* *** keyvalue keywords *** */
#define OTF_KEYWORD_L_KEYVALUE_PREFIX "KEY"
#define OTF_KEYWORD_S_KEYVALUE_PREFIX "K"
#define OTF_KEYWORD_F_KEYVALUE_PREFIX 'K'
/* *** local keywords *** */
@ -321,6 +366,9 @@ the keywords identifying record types must follow some special rules:
#define OTF_KEYWORD_L_LOCAL_LINE "LINE"
#define OTF_KEYWORD_S_LOCAL_LINE "LN"
#define OTF_KEYWORD_L_LOCAL_MATCHID "MATCHID"
#define OTF_KEYWORD_S_LOCAL_MATCHID "MI"
#define OTF_KEYWORD_L_LOCAL_MEMBERS "MEMBERS"
#define OTF_KEYWORD_S_LOCAL_MEMBERS "M"

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше