TAU Reference Guide

TAU has been tested on the following platforms:

Selective Instrumentation File Specification

The selective instrumentation file has the following sections, each preceded and followed by:

Both Memory and IO events are represented along with their call-stack; the length of which can be set with environment variable TAU_CALLPATH_DEPTH .

Selective instrumention can be set at compile time by setting -tau_options=-optTauSelectFile=<file> in the TAU_OPTIONS environment variable when compiling with the TAU compiler wrapper scripts. Alternatively an application can be selectively instrumented at runtime by setting the TAU_SELECT_FILE environment variable to the selective instrumentation file’s location in the application’s execution environment.

TAU also allows you to dynamically instrument your application using the DynInst package. There are a few limitation to DyInst: 1) only function level events will be captured and 2) your application must be compiled with debugging symbols ( -g ).

To install the DynInstAPI package, configure TAU with -dyinst= option which will point TAU to where dyninst is installed. Use the tau_run tool to instrument your application at runtime.

The command-line options accepted by tau_run are:

By default, libTAU . so is loaded by tau_run. However, the user can override this and specify another file using the -Xrun<Taulibrary>. In this case lib<Taulibrary>.so will be loaded using LD_LIBRARY_PATH .

To use tau_run , TAU is configured with DyninstAPI as shown below:

By default TAU profiles the total time (inclusive/exclusive) spent on a given function. Profiling each function call for an application that calls some function hundred of thousands of times, is impractical since the profile data would grow enormously. But configuring TAU with the -PROFILEPARAM option will have TAU profile select functions each time they are called. But TAU will also group some of these function calls together according to the value of the parameter they are given. For example if a function mpisend(int i) is called 2000 times 1000 times with 512 and 1000 times with 1024 then we will receive two profile for mpisend() one we it is called with 512 and one when it is called with 1024. This reduces the overhead since we are profiling mpisend() two times not 2000 times.

LIST OF COUNTERS:

Set the TAU_METRICS environment variable with a comma separated list of metrics or to use the old method set the following values for the COUNTER<1-25> environment variables.

and PAPI/PCL options that can be found in [papi_table] and [pcl_table] . Example:

NOTE: When -MULTIPLECOUNTERS is used with -TRACE option, the tracing library uses the wall-clock time from the function specified in the COUNTER1 variable. This should typically point to wall-clock time routines (such as GET_TIME_OF_DAY or SGI_TIMERS or LINUX_TIMERS ).

Example:

will produce profile files in directories called MULT_P_WALL_CLOCK_TIME, MULTI__PAPI_L1_DCM, and MULTI_PAPI_FP_INS.

For example to measure the floating point operations in routines using PCL ,

While running the application, set the environment variable PCL_EVENT or TAU_METRICS , to specify which hardware performance counter TAU should use while profiling the application.

To select floating point instructions for profiling using PAPI , you would:

In addition to the following events, you can use native events (see papi_native ) on a given CPU by setting TAU_ to PAPI_NATIVE_<event> . For example:

By default PAPI will profile events in all domains (users space, kernel, hypervisor, etc). You can restrict the set of domains for papi event profiling by using the TAU_PAPI_DOMAIN environment variable with these values (in a colon separated list, if desired): PAPI_DOM_USER, PAPI_DOM_KERNEL, PAPI_DOM_SUPERVISOR, and PAPI_DOM_OTHER like thus:

This profiling option is currently under development at LANL.

To configure TAU with PerfLib use the following arguments:

After TAU is built a new Makefile will be generated with -perflib- in its name, use this Makefile when profiling applications with perflib.

After configuration and installation, toggle these three environment variables before running the application:

We also provide a perf2tau conversion utilities to convert the remaining perflib profiles to regular TAU profiles. To use perf2tau set the environment variable perf_data_directory to the type of the profiling to be converted (the directory where the data is store will be called something like perf_data.[type]/). Or you may execute perf2tau with the type as an argument:

See also the man page for perf2tau, perf2tau .

TAU can automatically instrument all Python routines when the tau python package is imported. Add <TAUROOT>/<ARCH>/lib/bindings-<options> to the PYTHONPATH environment variable in order to use the TAU module.

To execute the program, tau.run routine is invoked with the name of the top level Python code. For e.g.,

instruments routines OurMain(), f1() and f2() although there are no instrumentation calls in the routines. To use this feature, TAU must be configured with the -pythoninc=<dir> option (and -pythonlib=<dir> if running under IBM). Before running the application, the environment variable PYTHONPATH and LD_LIBRARY_PATH should be set to include the TAU library directory (where tau.py is stored). Manual instrumentation of Python sources is also possible using the Python API and the pytau package. For e.g.,

shows how two timers x and y are created and used. Note, multiple timers can be nested, but not overlapping. Overlapping timers are detected by TAU at runtime and flagged with a warning (as exclusive time is not defined when timers overlap).

pprof sorts and displays profile data generated by TAU. To view the profile, merely execute pprof in the directory where profile files are located (or set the PROFILEDIR environment variable).

Its usage is explained below:

Java applications are profiled/traced using tau_java as shown below:

More information about tau_java can be found in the Tools section of the Reference Guide.

Running the application generates profile files with names having the form profile.<node>.<context>.<thread>. These files can be analyzed using pprof or paraprof.

If a tau.conf file is created, then code that uses that TAU lib will effected by the settings in tau.conf. For example, if a directory tau-2.21/tau_system_defaults is created and a tau.conf file is placed in it, TAU will read that file before doing the measurements. A user of that TAU libs can choose to override the contents of that file by placing a tau.conf in their own directory. But by default, if the sysadmin chooses to create this dir, all the users of the TAU libs will be globally affected by this tau.conf.

For example, tau.conf could be:

Then anyone using TAU from that directory will get TAU_IBM_BG_HWP_COUNTERS=1, TAU_TRACK_MESSAGE=1, etc.

TAU can be configured to use the Score-P measurement infrastructure (www.score-p.org). To use Score-P, configure TAU with -scorep= option to point TAU to the Score-P installation. (Please use Score-P version 1.0 beta or above.) You may then instrument and run your application with TAU in a manor of your choosing.

Set the environment variable SCOREP_PROFILING_FORMAT to TAU_SNAPSHOT to produce TAU Snapshot files, which will be found in scorep*/tau/. Also, the Score-P library must be found in LD_LIBRARY_PATH.

Please see examples/upc for more details.

To instrument Berkeley UPC with GASP, configure TAU with -upcnetwork=<option> /where option is "mpi" or "udp". Then use a selective instrumentation file like the one shown below.

Then tau_upc.sh can be used to build the application. If "udp" is used with -upcnetwork, then upcrun can be used to run the application. For "mpi", mpirun or a similar mechanism can be used.

To instrument UPC with Cray CCE compilers, the following will produce a configuration that supports Cray UPC and may be used with tau_upc.sh

TAU can also build the DMAPP wrapper using Cray CCE compilers. When the -optDMAPP option is used when building the application with TAU using TAU_OPTIONS, DMAPP events are automatically instrumented with tau_upc.sh.

TAU must be configured with the -TRACE option to generate event traces. This can be used in conjunction with -PROFILE to generate both profiles and traces. The traces are stored in a directory specified by the environment variable TRACEDIR , or the current directory, by default. The environment variables TAU_TRACEFILE may be used to specify the name of Vampir trace file. When this variable is set, trace files are automatically merged and the tau2vtf is invoked to convert the merged trace file to VTF3 trace format. This conversion takes place on node 0, thread 0. The intermediate trace files are deleted. To retain the trace files, the user can set the environment variable TAU_KEEP_TRACEFILES to true. When TAU_TRACEFILE is not specified, the user needs to merge and convert the traces as below. Example:

This generates files named

When generating a Vampir Trace Format (otf or vtf) these environment variables maybe helpful:

Using the utility tau_treemerge.pl, these traces are then merged as shown below:

This generates tau.trc as the merged trace file and tau.edf as the merged event description file.

tau_treemerge.pl can take an optional argument (with -n <value>) to specify the maximum number of trace files to merge in each invocation of tau_merge. If we need to merge 2000 trace files and if the maximum number of open files specified by unix is 250, tau_treemerge.pl will incrementally merge the trace files so as not to exceed the number of open file descriptors. This is important for the IBM BlueGene/L machine where such restrictions are present on the front-end node.

To convert merged or per-thread traces to another trace format, the utilities, tau2otf, tau_convert, tau2vtf, or tau2slog2 are used as shown below:

Here is an example:

Converting to Vampir’s VTF format:

To generate slog2 trace files that may be visualized using Jumpshot, we recommend using the slog2 SDK and Jumpshot bundled with TAU.

To generate traces that may be visualized using Vampir, we recommend using tau2vtf over the older tau_convert tool. tau2vtf can produce binary traces with user-defined events (hardware performance counters from PAPI etc.) while tau_convert cannot do this. Binary traces load faster in Vampir.

To view the dump of the trace in text form, use

tau_convert can also be used to convert traces to the Vampir trace format. For single-threaded applications (such as the MPI application above), the -pv option is used to generate Vampir traces as follows:

To convert TAU traces to SDDF or ALOG trace formats, -SDDF and -alog options may be used. When multiple threads are used on a node (as with -jdk, -pthread or -tulipthread options during configure), the -vampir option is used to convert the traces to the vampir trace format, as shown below:

To convert to the Paraver trace format, use the -paraver option for single threaded programs and -paraver -t option for multi-threaded programs.

NOTE: To ensure that inter-process communication events are recorded in the traces, in addition to the routine transitions, it is necessary to insert TAU_TRACE_SENDMSG and TAU_TRACE_RECVMSG macro calls in the source code during instrumentation. This is not needed when the TAU MPI wrapper library is used.

Vampir format traces may be converted to TAU profiles using the vtf2profile tool.

TAU can evaluate the following memory events:

The tau_exec command allow you to track these memory events with either an instrumented or uninstrumented binary. If you want to instead track memory usage in select locations in the source code consider the TAU API calls below.

TAU’s memory leak detection feature can be initiated by giving tau_compiler.sh the option -optDetectMemoryLeaks . For a demonstration consider this C++ program:

Notice that bar fails to free allocated memory on input between 5 and 15 and that foo will call g that calls bar when the input to foo is greater than 5.

Now configuring TAU with -PROFILECALLPATH run the file by:

Notice that the first row show the two Memory leaks along with the callpath tracing where the unallocated memory was requested.

To profile memory usage in Fortran 90 use TAU’s ability to selectively instrument a program. The option -optTauSelectFile=<file> for tau_compilier.sh let you specify a selective instrumentation file which defines regions of the source code to instrument.

To begin memory profiling, state which file/routines to profile by typing:

Wildcard can be used to instrument multiple routines. For file names * character can be used to specify any number of character, thus foo* matches foobar, foo2, etc. also for file names ? can match a single charater, ie. foo? matches foo2, fooZ, but not foobar. You can use # as a wildcard for routines, ie. b# matches bar, b2z etc.

Memory Profile in Fortran gives you these three metrics:

Here is the profile for the example/memoryleakdetect/f90/foo.f90 file.

Copy the plugins directory in the tau2/tools/src/taujava directory to the location of your eclipse installation. You may have to restart eclipse if it is running when this is done.

In eclipse go to the Window menu, select Preferences and go to the TauJava Preferences section. Enter the location of the lib directory in the tau installation for your architecture in the TAU Library Directory field. Other options may also be selected at this time.

Java programs can be instrumented at the level of full Java projects, packages or individual Java files. From within the Java view simply right click on the element in the package explorer that you wish to instrument select the TAU pop up menu and click on Instrument Project, Package or Java respectively.

Note that the instrumenter will add the TAU.jar file to the project’s class-path the first time any element is instrumented.

Do not perform multiple instrumentations of the same Java file. Do not edit the comments added by the instrumenter or adjust the white space around them. Doing so may prevent the uninstrumenter from working properly.

Uninstrumenting a Java project, package or file works just like instrumenting. Just select the uninstrument option instead. Note that the uninstrumenter only removes TAU instrumentation as formatted and commented by the instrumenter. Running the uninstrumenter on code with no TAU instrumentation present has no effect.

To automatically analyze your instrumented project on a Unix-based system TAU must first be configured with the -JDK option, and any other options you want applied to your trace output. On windows the type of analysis to be conducted, Profile, Call path or Trace, should be selected from the Window, Preferences TauJava Preferences menu.

Once that has been accomplished, right click on the Java file containing the main method you want to run, go to the TAU menu and click on Run TAU-Instrumented Java. The program will run and, by default, the profile and/or trace files will be placed in a timestamped directory, inside a directory indicating the name of the file that was run, in the TAU_Output directory in the home directory of the Java project.

The following options are accessible from the Window, Preferences TAUJava Preferences menu.

Use Alternative TAU Output Directory: Causes the TAU_Output directory to be placed in the location specified in the associated field. The internal directory structure of the TAU_Output directory remains unchanged.

Automatically run ParaProf on profile output?: Causes the TAU profile viewer, paraprof, to run on the output of profile and call-path analysis output as soon as the trace files have been produced.

Enable selective instrumentation: Causes Java elements specified in the given selection file to be included or excluded from instrumentation. By default all packages files and methods are included. The file should conform to the TAU file selection format described here.

Be certain that the PTP / CDT / Photran plug-ins are installed and running properly in your eclipse installation. Use TAU’s perfdmf_configure utility to set up a performance database for Eclipse to store profile output.

Run the install_plug-ins.sh script located in [tau installation]/tools/src/eclipse with the location of your eclipse installation. e.g: ~/tau2/tools/src/eclipse/install_plug-ins.sh /opt/eclipse

Restart eclipse with the -clean flag after installing the plugins.

In eclipse go to the Window menu, select Preferences and go to the Performance Tools preferences section and the Tool Configuration subsection. If the PTP is available the Performance Tools section will be under the PTP menu. Enter the location of the desired TAU bin directory in your in the tau Bin Directory field.

To create a TAU launch configuration, click the profile button added near the run and debug buttons. This will provide an interface for launching either a standard or parallel C, C++ or Fortran application, similar to the interface provided by the standard run configuration dialog. You may select a pre-existing run configuration or create a new one in the usual way.

The run configuration options are equivalent to those of a standard run configuration, with the addition of a performance analysis tab a parametric study tab and a TAU tab. To run an application with TAU first make sure that the TAU option is selected in the drop down box on the performance analysis tab. You may also specify that a TAU instrumented executable should not be run after it is built. This option will leave a new TAU specific build configuration available for your use. It will have the name of the original build configuration, with the TAU configuration options used appended. The executables available in such build configurations can be run through the standard run and debug launch configurations. This option can be useful if you need to launch TAU instrumented binaries outside of eclipse. There is also an option to select existing performance data. This will upload data specified on the filesystem to a selected database, rather than generating the data from a project in Eclipse.

On the TAU tab you must select a TAU makefile from the available makefiles in the TAU architecture directory you specified. You may select specific configuration options to narrow the list of makefiles in the dropdown box. Only makefiles configured with the -pdt option will be listed. Additional TAU compiler options are provided on the TAU Compiler sub-tab.

If you select a makefile with the PAPI counter library and -MULTIPLECOUNTERS enabled you may specify the PAPI environment variables using the Select PAPI Counters button. The counters you select will be placed in the environment variables list for your run configuration.

You may specify the use of TAU selective instrumentation either by selecting a pre-defined selective instrumentation file, by selecting the internal option to have TAU to use a file generated by the selective instrumentation commands available in the Eclipse workspace or by selecting the automatic option to have eclipse generate a selective instrumentation file using TAU’s tau_reduce utility. Note that the automatic option will cause your project to be rebuilt and run twice.

By default TAU profile data will only be stored in a perfdmf database, if available. The database may be selected on the Data Collection sub-tab. You may specify that performance data should be kept on the file-system with the Keep Profiles option.

If you wish to collect the resulting profile data on TAU’s online Portal , check the "Upload profile data to TAU Portal" box. After the profiling has finished you will be prompted to provide your user name, password and specify the destination workspace. To view the profile data log on to the portal and select the specified workspace.

C, C and Fortran programs have several selective instrumentation options in Eclipse. The selective instrumentation sub-menu of the right click menu provided by C/C and Fortran projects, source files and routines in the C/C++ and program outline views allows inclusion, exclusion and loop level instrumentation to be specified for each of these objects. You may also clear instrumentation specified for each of these levels from the selective instrumentation menu.

The source editor’s context menu allows the insertion of interval and atomic user defined events. To specify an atomic user defined event, place the cursor on the line where you want the event to trigger, right click, go to the Selective Instrumentation sub-menu and select Insert TAU Atomic User Defined Event. Put the name you wish to associate with the event in the first context window that appears. Put either a numeric constant or the name of a valid numeric variable in the second window.

To specify an interval based user defined event, select the source code you wish to be included in the interval, right click, go to the Selective Instrumentation sub-menu and select Insert TAU Interval (start/stop) User Defined Event. You may select use of a Static Timer, Dynamic Timer, Static Phase or Dynamic Phase event. Note that to get phase data you must select a TAU makefile configured with the -PROFILEPHASE option. Once you have selected the event type you will be prompted to enter a name for the event.

All selective instrumentation options are placed in the tau.selective file in your project’s main directory. This file is automatically employed when the TAU launch configuration has "internal" selective instrumentation selected. You may safely edit this file manually so long as it remains a valid TAU selective instrumentation file.

To launch your project with TAU either select the Profile button from the profile launch configuration window, select your launch configuration from the dropdown menu of the profile button or, if your desired configuration is already selected, simply click on the profile button.

If a perfdmf database is configured and available, TAU profile data will be saved there. Trace data and other performance data output will be stored in your project’s top level directory. If a perfdmf database is not available or you have selected to save profile data on the file system profile output will appear in a Profiles directory in your project’s top level directory. Profiles are organized in sub-directories by the TAU configuration options used to generate them and the time-stamp of their creation.

Instrumenting source files.

The TAU Compiler provides a simple way to automatically instrument an entire project. The TAU Compiler can be used on C, C++, fixed form Fortran, and free form Fortran.

-optVerbose Turn on verbose debugging messages. -optMemDbg Enable TAU’s runtime memory debugger. -optDetectMemoryLeaks Instructs TAU to detect any memory leaks in C/C programs.TAU then tracks the source location of the memory leak as wellas the place in the callstack where the memory allocation wasmade. `-optPdtDir=<dir>` The PDT architecture directory. Typically `$(PDTDIR)/$(PDTARCHDIR)` . `-optPdtF95Opts=<opts>` Options for Fortran parser in PDT (f95parse). `-optPdtF95Reset=<opts>` Reset options to the Fortran parser to the given list. `-optPdtCOpts=<opts>` Options for C parser in PDT (cparse). Typically `$(TAU_MPI_INCLUDE) $(TAU_INCLUDE) $(TAU_DEFS)` . `-optPdtCReset=<opts>` Reset options to the C parser to the given list `-optPdtCxxOpts=<opts>` Options for C parser in PDT (cxxparse). Typically $(TAU_MPI_INCLUDE) $(TAU_INCLUDE) $(TAU_DEFS) . -optPdtCxxReset=<opts> Reset options to the C parser to the given list `-optPdtF90Parser=<parser>` Specify a different Fortran parser. For e.g., `f90parse` instead of `f95parse` . `-optPdtCxxParser=<parser>` Specify a different C parser. For e.g., cxxparse401 instead of cxxparse . -optGnuFortranParser=<parser> Specify the GNU gfortran Fortran parser gfparse instead of f95parse -optGnuCleanscapeParser Uses the Cleanscape Fortran parser f95parse instead of GNU’s gfparse -optPdtUser=<opts> Optional arguments for parsing source code. -optTauInstr=<path> Specify location of tau_instrumentor. Typically $(TAUROOT)/$(CONFIG_ARCH)/bin/tau_instrumentor . -optContinueBeforeOMP Insert a CONTINUE statement before !$OMP directives. -optIncludeMemory Forinteral use only -optTrackUPCR Adds tracking of the UPC runtime library. -optTrackDMAPP Specify wrapping of Pthread library calls at link time. -optTrackPthread Adds tracking of the UPC runtime library. -optNoTrackGOMP Disable wrapping of GOMP library calls at link time -optTrackMPCThread Specify wrapping of MPC Thread library calls at link time. -optPreProcess Preprocess the source code before parsing. Uses /usr/bin/cpp-P by default. -optCPP=<path> Specify an alternative preprocessor and pre-process the sources. -optCPPOpts=<options> Specify additional options to the C pre-processor. -optCPPReset=<options> ResetC preprocessor options to the specified list. -optFPP=<path> Specify an alternative preprocessor and pre-process for Fortran sources. -optFPPOpts=<options> Specify additional options to the Fortran pre-processor. -optTauSelectFile=<file> Specify selective instrumentation file for tau_instrumentor -optPDBFile=<file> Specify PDB file for tau_instrumentor. Skips parsing stage. -optTau=<opts> Specify options for tau_instrumentor. -optCompile=<opts> Options passed to the compiler. Typically $(TAU_MPI_INCLUDE) $(TAU_INCLUDE) $(TAU_DEFS) . -optTauDefs=<opts> Options passed to the compiler by TAU. Typically $(TAU_DEFS) . -optTauIncludes=<opts> Options passed to the compiler by TAU. Typically $(TAU_MPI_INCLUDE) $(TAU_INCLUDE) . -optReset=<opts> Reset options to the compiler to the given list -optLinking=<opts> Options passed to the linker. Typically $(TAU_MPI_FLIBS) $(TAU_LIBS) $(TAU_CXXLIBS) . -optLinkReset=<opts> Reset options to the linker to the given list. -optLinkPreserveLib=<opts> Libraries which TAU should preserve the order of on the link line see "Moving these libraries to the end of the link line:". Default: none. -optTauCC=<cc> Specifies the C compiler used by TAU. -optUseReturnFix Specifies the use of a bug fix with ROSE parser using EDG v3.x -optLinkOnly Disable instrumentation during compilation, do link in the TAU libs -optOpariTool=<path/opari> Specifies the location of the Opari tool. -optOpariDir=<path> Specifies the location of the Opari directory. -optOpariOpts=<opts> Specifies optional arguments to the Opari tool. -optOpariNoInit Do not initlize the POMP2 regions. -optOpariReset=<opts> Resets options passed to the Opari tool. -optOpariLibs=<> Specifies the libraries that have POMP2 regions. (Overrides optOpariNoInit). -optOpari2Tool=<path to opari2> Specifies the location of the Opari tool. -optOpari2ConfigTool=<path/opari2-config> Specifies the location of the Opari tool configuration file -optOpari2Opts=<opts> Specifies optional arguments to the Opari tool. -optOpari2Reset=<opts> Resets options passed to the Opari tool. -optOpari2Dirs=<opts> Specifies the location of the Opari directory -optNoMpi Removes -l*mpi* libraries during linking (default). -optMpi Does not remove -l*mpi* libraries during linking. -optNoRevert Exit on error. THIS IS CRAZY Does not revert to the original compilation rule on error. -optRevert Revert to the original compilation rule on error (default). -optKeepFiles Does not remove intermediate .pdb and .inst.* files. -optReuseFiles Reuses a pre-instrumented file and preserves them. -optAppCC Sets the failsafe C compiler. -optAppCXX Sets the failsafe C compiler. `-optAppF90` Sets the failsafe F90 compiler `-optShared` Use shared library version of TAU `-optCompInst` Use compiler-based instrumentation `-optNoCompInst` Do not revert to compiler instrumentation if source instrumentation fails. `-optPDTInst` Use PDT-based instrumentation `-optHeaderInst` Enable instrumentation of headers `-optDisableHeaderInst` Disable instrumentation of headers `-optTrackIO` Specify wrapping of POSIX I/O calls at link time. `-optMICOffload` Links code for Intel MIC offloading, requires both host and MIC TAU libraries `-optWrappersDir=""` Specify the location of the link wrappers directory. `-optTauUseCXXForC` Specifies the use of a C compiler for compiling C code -optTauWrapFile=<filename> Specify path to the link_options.tau file generated by tau_wrap -optFixHashIf

Generate a TAU profile set from a vampir trace file

vtf2profile is created when TAU is configured with the -vtf=<vtf_dir> option. This tool converts a VTF trace file (*.vpt) to a tau profile set (profile.A.B.C where A, B and C are the node, context and thread numbers respectively). The vtf file to be read is specified in the command line by the -f flag followed by the file’s location. The VTF tracefile specified may be in gzipped form, eg app.vpt.gz. -p is similarly used to specify the relative path to the directory where the profile files should be stored. If no output directory is specified the current directory will be used. A contiguous interval within the vtf file may be selected for conversion by using the -i flag followed by two integers, representing the timestamp of the start and end of the desired interval respectively. The entire vtf file is converted if no interval is given.

-f tracefile -Specify the Vampir tracefile to be converted. -p profile -Specify the location where the profile file(s) should be written. -i interval_start interval_end -Limit the profile produced to the specified interval within the vampir trace file. -c -Opens a command line interface for the program. -h -Displays a help message.

To convert a vampir tracefile, trace.vpt, to an equivalent TAU profile, use the following: ---- vtf2profile -f trace.vpt To produce a TAU profile in the ./profiles directory representing only the events from the start of the tracefile to timestamp 6000, use: ---- To produce a TAU profile in the ./profiles directory representing only the events from the start of the tracefile to timestamp 6000, use: ---- vtf2profile -f trace.vpt -p ./profiles -i 0 6000 ----

tau2vtf , trace2profile

convert TAU tracefiles to vampir tracefiles

This program is generated when TAU is configured with the -vtf=<vtf_dir> option. The tau2vtf trace converter takes a single tau_tracefile (.trc) and tau_eventfile (.edf) and produces a corresponding vtf_tracefile (*.vtf). The input files and output file must be specified in that order. Multi-file TAU traces must be merged before conversion. The default output file format is VTF3 binary. If the output filename is given as the .vpt.gz type, rather than .vpt, the output file will be gzipped. There are two additional output format options. The command line argument '-a' produces the vtf file output in ASCII VTF3 format. The command line argument '-fa' produces the vtf file output in the FAST ASCII VTF3 format. Note that these arguments are mutually exclusive.

-nomessage Suppresses printing of message information in the trace. -v Verbose mode sends trace event descriptions to the standard output as they are converted. -a Print the vtf file output in the human-readable VTF3 ASCII format -fa Print the vtf file in the simplified human-readable FAST ASCII VTF3 format

The program must be run with the TAU trace, TAU event and vtf output files specified in the command line in that order. Any additional arguments follow. The following will produce a VTF, app.vpt, from the TAU trace and event files merged.trc and tau.edf trace file: ---- tau2vtf merged.trc tau.edf app.vpt The following will convert merged.trc and tau.edf to a gzipped FAST ASCII vampir tracefile app.vpt.gz, with message events omitted: ---- The following will convert merged.trc and tau.edf to a gzipped FAST ASCII vampir tracefile app.vpt.gz, with message events omitted: ---- tau2vtf merged.trc tau.edf app.vpt.gz -nomessage -fa ----

vtf2profile , trace2profile , tau_merge , tau_convert

convert TAU tracefiles to TAU profile files

This program is generated when TAU is configured with the -TRACE option. The trace2profile converter takes a single tau_tracefile (.trc) and tau_eventfile (.edf) and produces a corresponding series of profile files. The input files must be specified in that order, with optinal parameters coming afterward. Multi-file TAU traces must be merged before conversion.

-d Output profile files to the specified 'directory' rather than the current directory. -s Output a profile snapshot showing the state of the profile data accumulated from the trace every 'snapshot_interval' time units. The snapshot profiles are placed sequentially in directories labled 'snapshot_n' where 'n' is an integer ranging from 0 to to the total number of snapshots -1.

The program must be run with the TAU trace and tau event files specified in the command line in that order. Any additional arguments follow. The following will produce a profile file array, from the TAU trace and event files merged.trc and tau.edf trace file: ---- trace2profile merged.trc tau.edf The following will convert merged.trc and tau.edf to a series of profiles one directory higher. It will also produce a profile snapshot every 250,000 time units: ---- The following will convert merged.trc and tau.edf to a series of profiles one directory higher. It will also produce a profile snapshot every 250,000 time units: ---- trace2profile merged.trc tau.edf -d ./.. -s 250000 ----

vtf2profile , tau2vtf , tau2otf , tau_merge , tau_convert

convert TAU tracefiles to Epilog tracefiles

This program is generated when TAU is configured with the -epilog=<epilog_dir> option. The tau2elg trace converter takes a tau trace file (.trc) and event definition file (.edf) and produces a corresponding epilog binary trace file (*.elg). Multi-file TAU traces must be merged before conversion.

-nomessage Suppresses printing of message information in the trace. -v Verbose mode sends trace event descriptions to the standard output as they are converted.

The program must be run with the TAU trace, TAU event and elg output files specified in the command line in that order. Any additional arguments follow. The following would convert merged.trc and tau.edf to the Epilog tracefile app.elg, with message events omitted: ---- ./tau2vtf merged.trc tau.edf app.elg -nomessage ----

tau_merge

convert TAU tracefiles to SLOG2 tracefiles

This program is generated when TAU is configured with the -slog2 or -slog2=<slog2_dir> option. The tau2slog2 trace converter takes a single tau trace file (.trc) and event definition file (.edf) and produces a corresponding slog2 binary trace file (*.slog2). The tau2slog2 converter is called from the command line with the locations of the tau trace and event files. These arguments must be followed by the -o flag and the name of the slog2 file to be written. tau2slog 2 accepts no other arguments.

[-h|--h|-help|--help] Display HELP message. [-tc] Check increasing endtime order, exit when 1st violation occurs. [-tcc] Check increasing endtime order,continue when violations occur. [-nc number] Number of childern per node (default is 2) [-ls number] Max byte size of leaf nodes (default is 65536) [-o output.slog2] Output filename with slog2 suffix

A typical invocation of the converter, to create app.slog2, is as follows: ---- tau2slog2 app.trc tau.edf -o app.slog2 ----

tau_merge , tau_convert

convert TAU tracefiles to OTF tracefiles for Vampir/VNG

This program is generated when TAU is configured with the -otf=<otf_dir> option. The tau2otf trace converter takes a TAU formatted tracefile (.trc) and a TAU event description file (.edf) and produces an output trace file in the Open Trace Format (OTF). The user may specify the number of output streams for OTF. The input files and output file must be specified in that order. TAU traces should be merged using tau_merge prior to conversion.

-n streams Specifies the number of output streams (default is 1). -nomessage Suppresses printing of message information in the trace. -v Verbose mode sends trace event descriptions to the standard output as they are converted.

The program must be run with the tau trace, tau event and otf output files specified in the command line in that order. Any additional arguments follow. The following will produce an OTF file, a pp.otf and other related event and definition files, from the TAU trace and event files merged.trc and tau.edf: ---- tau2otf merged.trc tau.edf app.otf ----

tau2vtf(1), trace2profile(1), vtf2profile(1), tau_merge(1), tau_convert(1)

convert TAU tracefiles to OTF2 tracefiles for Vampir/VNG

This program is generated when TAU is configured with the -otf=<otf_dir> option. The tau2otf2 trace converter takes a TAU formatted tracefile (.trc) and a TAU event description file (.edf) and produces an output trace file in the Open Trace Format (OTF2). The user may specify the number of output streams for OTF2. The input files and output file must be specified in that order. TAU traces should be merged using tau_merge prior to conversion.

-n streams Specifies the number of output streams (default is 1). -nomessage Suppresses printing of message information in the trace. -v Verbose mode sends trace event descriptions to the standard output as they are converted.

The program must be run with the tau trace, tau event and otf2 output files specified in the command line in that order. Any additional arguments follow. The following will produce an OTF2 file, a pp.otf2 and other related event and definition files, from the TAU trace and event files tau.trc and tau.edf: ---- tau2otf2 merged.trc tau.edf app.otf2 ----

tau2vtf(1), trace2profile(1), vtf2profile(1), tau_merge(1), tau_convert(1)

convert TAU tracefiles to json tracefiles for Chrome tracing or other viewers

The tau_trace2json trace converter takes a TAU formatted tracefile (.trc) and a TAU event description file (.edf) and produces an output trace file in json. The user may specify the creation of a json file readable by Chrome’s trace viewer. If no output file name is specified with the -o option output will be created in an events.json file in the current directory.

-chrome Output Chrome readable trace output. -ignoreatomic Do not include atomic events in json output. TAU traces include metadata as atomic events so using this option is advised in general. -o Specify an output file other than the default events.json -nomessage Suppresses printing of message information in the trace. -v Verbose mode sends trace event descriptions to the standard output as they are converted.

The program must be run with the tau trace, tau event input first followed by any arguments. The following will produce a json file, trace.json, from the TAU trace and event files tau.trc and tau.edf: ---- tau_trace2json ./tau.trc ./tau.edf -chrome -ignoreatomic -o trace.json ----

tau2vtf(1), trace2profile(1), vtf2profile(1), tau_merge(1), tau_convert(1)

converts PerfLib profiles to TAU profile files

Converts perflib data to TAU format. If an argument is not specified, it checks the perf_data_directory environment variable. Then opens perf_data.timing directory to read perflib data If no args are specified, it tries to read perf_data.<current_date> file.

-h Display the help information. -flat Suppresses callpath profiles, each callpath profile will be flattened to show only the function profile.

---- %> perf2tau timing ----

vtf2profile , tau2vtf , tau2otf , tau_merge , tau_convert

combine multiple node and or thread TAU tracefiles into a merged tracefile

tau_merge is generated when TAU is configured with the -TRACE option. This tool assembles a set of tau trace and event files from multiple multiple nodes or threads across a program’s execution into a single unified trace file. Many TAU trace file tools operate on merged trace files. Minimally, tau_merge must be invoked with a list of unmerged trace files followed by the desired name of the merged trace file or the - flag to send the output to the standard out. Typically the list can be designated by giving the shared name of the trace files to be merged followed by desired range of thread or node designators in brackets or the wild card character '' to encompass variable thread and node designations in the filename (trace.A.B.C.trc where A, B and C are the node, context and thread numbers respectively). For example tautrace..trc would represent all tracefiles in a given directory while tautrace.[0-5].0.0.trc would represent the tracefiles of nodes 0 through 5 with context 0 and thread 0. tau_merge will generate the specified merged trace file and an event definition file, tau.edf by default. The event definition file can be given an alternative name by using the '-m' flag followed by the desired filename. A list of event definition files to be merged can be designated explicitly by using the '-e' flag followed by a list of unmerged .edf files, specified in the same manner as the trace file list. If computational resources are insufficient to merge all trace and event files simultaneously the process may be undertaken hierarchically. Corresponding subsets of the tracefiles and eventfiles may be merged in sequence to produce a smaller set of files that can then be to merged into a singular fully merged tracefile and eventfile. E.g. for a 100 node trace, trace sets 1-10, 11-20, …​, 91-100 could be merged into traces 1a, 2a, …​, 10a. Then 1a-10a could be merged to create a fully merged tracefile.

-e eventfile_list explicitly define the eventfiles to be merged -m output_eventfile explicitly name the merged eventfile to be created - send the merged tracefile to the standard out -a adjust earliest timestamp time to zero -r do not reassemble long events -n do not block waiting for new events. By default tau_merge will block and wait for new events to be appended if a tracefile is incomplete. This command allows offline merging of (potentially) incomplete tracefiles.

To merge all TAU tracefiles into app.trc and produce a merged tau.edf eventfile: ---- tau_merge .trc app.trc To merge all eventfiles 0-255 into ev0_255merged.edf and TAU tracefiles for nodes 0-255 into the standard out: ---- To merge all eventfiles 0-255 into ev0_255merged.edf and TAU tracefiles for nodes 0-255 into the standard out: ---- tau_merge -e events.[0-255].edf -m ev0_255merged.edf \ tautrace.[0-255]..trc - To merge eventfiles 0, 5 and seven info ev057.edf and tau tracefiles for nodes 0, 5 and 7 with context and thread 0 into app.trc: ---- To merge eventfiles 0, 5 and seven info ev057.edf and tau tracefiles for nodes 0, 5 and 7 with context and thread 0 into app.trc: ---- tau_merge -e events.0.edf events.5.edf events.7.edf -m ev057.edf \ tautrace.0.0.0.trc tautrace.5.0.0.trc tautrace.7.0.0.trc app.trc ----

tau_convert trace2profile tau2vtf tau2elg tau2slog2

combine multiple node and or thread TAU tracefiles into a merged tracefile

tau_treemerge.pl is generated when TAU is configured with the -TRACE option. This tool assembles a set of tau trace and event files from multiple multiple nodes or threads across a program’s execution into a single unified trace file. Many TAU trace file tools operate on merged trace files. tau_treemerge.pl will generate the specified merged trace file and an event definition file, tau.edf by default.

-n break_amount set the maximum number of trace files to merge in each invocation of tau_merge. If we need to merge 2000 trace files and if the maximum number of open files specified by unix is 250, tau_treemerge.pl will incrementally merge the trace files so as not to exceed the number of open file descriptors.

tau_merge tau_convert trace2profile tau2vtf tau2elg tau2slog2

convert TAU tracefiles into various alternative trace formats

tau_convert is generated when TAU is configured with the -TRACE option. This program requires specification of a TAU tracefile and eventfile. It will convert the given TAU traces to the ASCII-based trace format specified in the first argument. The conversion type specification may be followed by additional options specific to the conversion type. It defaults to the single threaded vampir format if no other format is specified. tau_convert also accepts specification of an output file as the last argument. If none is given it prints the converted data to the standard out.

-alog convert TAU tracefile into the alog format (This format is deprecated. The SLOG2 format is recommended.) -SDDF convert TAU tracefile into the SDDF format -dump convert TAU tracefile into multi-column human readable text -paraver convert TAU tracefile into paraver format -t indicate conversion of multi threaded TAU trace into paraver format -pv convert single threaded TAU tracefile into vampir format (all -vampir options apply) (default) -vampir convert multi threaded TAU tracefile into vampir format -longsymbolbugfix make the first characters of long, similar identifier strings unique to avoid a bug in vampir -compact abbreviate individual event entries -all compact all entries (default) -user compact user entries only -class compact class entries only -nocomm disregard communication events [outputtrc] specify the name of the output tracefile to be produced

To print the contents of a TAU tracefile to the screen: ---- tau_convert -dump app.trc tau.edf To convert a merged, threaded TAU tracefile to paraver format: ---- To convert a merged, threaded TAU tracefile to paraver format: ---- tau_convert -paraver -t app.trc tau.edf app.pv ----

tau_merge , tau2vtf , trace2profile , tau2slog2

generates selective instrumentation rules based on profile data

tau_reduce is an application that will apply a set of user-defined rules to a pprof dump file ( pprof -d ) in order to create a select file that will include an exclude list for selective implementation for TAU. The user must specify the name of the pprof dump file that this application will use. This is done with the -f filename flag. If no rule file is specified, then a single default rule will be applied to the file. This rule is: numcalls > 1000000 & usecs/call < 2, which will exclude all routines that are called at least 1,000,000 times and average less then two microseconds per call. If a rule file is specified, then this rule is not applied. If no output file is specified, then the results will be printed out to the screen.

Users can specify a set of rules for tau_reduce to apply. The rules should be specified in a separate file, one rule per line, and the file name should be specifed with the appropriate option on the command line. The grammar for a rule is: [GROUPNAME:]FIELD OPERATOR NUMBER. The GROUPNAME followed by the colon (:) is optional. If included, the rule will only be applied to routines that are a member of the group specified. Only one group name can be applied to each rule, and a rule must follow a groupname. If only a groupname is given, then an unrecognized field error will be returned. If the desired effect is to exclude all routines that belong to a certain group, then a trivial rule, such as GROUP:numcalls > -1 may be applied. If a groupnameis given, but the data does not contain any groupname data, then then an error message will be given, but the rule will still be applied to the date ignoring the groupname specification. A FIELD is any of the routine attributes listed in the following table:

Some FIELDS are only available for certain files. If hardware counters are used, then usec, cumusec, usecs/per call are not applicable and a error is reported. The opposite is true if timing data is used rather than hardware counters. Also, stddev is only available for certain files that contain that data. An OPERATOR is any of the following: < (less than), > (greater than), or = (equals). A NUMBER is any number. A compound rule may be formed by using the & (and) symbol in between two simple rules. There is no "OR" because there is an implied or between two separate simple rules, each on a separate line. (ie the compound rule usec < 1000 OR numcalls = 1 is the same as the two simple rules "usec < 1000" and "numcalls = 1").

-f filename specify filename of pprof dump file -p print out all functions with their attributes -o filename specify filename for select file output (default: print to screen -r filename specify filename for rule file -v verbose mode (for each rule, print out rule and all functions that it excludes)

To print to the screen the selective instrumentation list for the paraprof dump file app.prf with default selection rules use: ---- tau_reduce -f app.prf To create a selection file, app.sel, from the paraprof dump file app.prf using rules specified in foo.rlf use: ---- To create a selection file, app.sel, from the paraprof dump file app.prf using rules specified in foo.rlf use: ---- tau_reduce -f app.prf -r foo.rlf -o app.sel ----

Completes uncompleted do/for/parallel omp directives

Finds uncompleted do/for omp directives and inserts closing directives for each one uncompleted. do/for directives are expected immediately before a do/for loop. Closing directives are then placed immediately following the same do/for loop.

pdbfile A pdbfile generated from the source file you wish to check. This pdbfile must contain comments from which the omp directives are gathered. See pdbcomment for information on how to obtain comment from a pdbfile. sourcefile A fortran, C or C++ source file to analyzed. -o write the output to the specified outfile. -v verbose output, will say which directive where added. -d debuging information, we suggest you pipe this unrestrained output to a file.

To check file: source.f90 do: (you will need pdtoolkit/<arch>/bin and tau/utils/ in your path). ---- %>f95parse source.f90 %>pdbcomment source.pdb > source.comment.pdb %>tau_omp source.comment.pdb source.f90 -o source.chk.f90 ----

f95parse pdbcomment

Instruments a MPI application while it is being executed with poe.

This tool dynamically instruments a mpi application by loading a specific mpi library file.

tauOptions To instrument a mpi application a specific TAU library file is loaded when the application is executed. To select which library is loaded use this option. The library files are build according to the options set when TAU is configured. The library file that have been build and thus available for use are in the [TAU_HOME]/[arch]/lib directory. The file are listed as libTAUsh-*.so where * is the instrumentation options. For example to use the libTAUsh-pdt-openmp-opari.so file let the comman line option be -XrunTAUsh-pdt-openmp-opari.

Instrument a.out wit the currently configured options and then run it on four nodes: ---- %>tau_poe ./a.out -procs 4 ---- Select the libTAUsh-mpi.so library to instrument a.out with: ---- %>tau_poe -XrunTAUsh-mpi ./a.out -procs 4 ----

Validates a TAU installation by performing various tests on each TAU stub Makefile

tau_validate will attempt to validate a TAU installation by performing various tests on each TAU stub Makefile. Some degree of logic exists to know where a given test applies to a given makefile, but it’s not perfect.

v Verbose output html Output results in HTML build Only build run Only run tag Only check configurations containing the tag. ie. --tag papi checks only libraries with the -papi in their name. arch directory Specify an arch directory (e.g. rs6000), or the lib directory (rs6000/lib), or a specific makefile. Relative or absolute paths are ok.

There is a few examples: ---- bash : ./tau_validate --html x86_64 &> results.html tcsh : ./tau_validate --html x86_64 >& results.html ----

Allows you to choose a TAU configuration at runtime

Use this script to dynamically load a TAU profiling/tracing library or to select which papi events/domain to use during execuation of the application. At runtime tauex will set the LD_LIBRARY_PATH and pass any other parameters (or papi events) to the program and execute it with the specified TAU measurement options.

Defaults if unspecified: -U -T MPI,PROFILE -e P_WALL_CLOCK_TIME MPI is assumed unless SERIAL is specified PROFILE is assumed unless one of TRACE, VAMPIRTRACE or EPILOG is specified P_WALL_CLOCK_TIME means count real time using fastest available timer

mpirun -np 2 tauex -e PAPI_TOT_CYC -e PAPI_FP_OPS -T MPI,PROFILE — ./ring

TAU execution wrapping script

Use this script to perform runtime performance tracking on either an instrumented or uninstrumented executable. Options include memory and IO tracking, event based sampling, hardware accelerator tracking and data collection from library-provided instrumention API’s such as mpi communication events and RAJA and Kokkos instrumention hooks.

Defaults if unspecified: -T MPI. MPI is assumed unless SERIAL is specified CUDA kernel tracking is included, if A CUDA SYNC call is made after each kernel launch and cudaThreadExit() is called before the exit of each thread that uses CUDA. OPENCL kernel tracking is included, if A OPENCL SYNC call is made after each kernel launch and clReleaseContext() is called before the exit of each thread that uses CUDA. tau_python is similar to tau_exec and can replace the 'python' command when launching a python application. The -tau_python_interpreter=<interpreter> argument allows specification of a python interpreter other than the one used to configure TAU.

mpirun -np 2 tau_exec -io ./ring mpirun -np 8 tau_exec -ebs -ebs_period=1000000 -ebs_source=PAPI_FP_INS ./ring tau_exec -T serial,cupti -cupti ./matmult (Preferred for CUDA 4.1 or later) tau_exec -T serial -cuda ./matmult (Preferred for CUDA 4.0 or earlier) tau_exec -T serial -opencl (OPENCL)

Corrects and reorders the records of TAU trace files.

This program takes in TAU trace files, reorders and corrects the times of these records and then outputs the records to new trace files. The time correction algorithm uses a logical clock algorithm with amortization. This is done by adjusting the times of events such that the product of an effect happens after the cause of that effect.

trace input file EDF input file trace output file EDF output file

This tool generates a selective instrumentation file (called throttle.tau) from a program output that has "Disabling" messages.

This tools will auto-generates a selective instrumenation file basied on output from a program that has the profiling of some its functions throttled.

This tool is design to interact with the TAU web portal (http://tau.nic.uoregon.edu). There are commands for uploading or downloading packed profile files form the TAU portal.

Each command will initate a transfer to profile data btween the TAU portal and either the filesytem (to be stored as ppk file) or to a PerfDMF database. See tau_portal --help for more information.

Configuration program for a PerfDMF database.

This configuration script will create a new TAUdb database.

-h, --help show help --create-default creates a H2 database with all the default values -g, --configFile configFile specify the path to the file that defines the TAUdb configuration. -c, --config configuration_name specify the name of the TAUdb configuration -c foo is equalivent to -g <home>/.ParaProf/perfdmf.cfg.foo . -t, --tauroot path Path to the root directory of tau.

This script will create a new application in the perfdmf database.

-g, --configFile configFile specify the path to the file that defines the perfdmf configuration. -c, --config configuration_name specify the name of the perfdmf configuration -c foo is equalivent to -g <home>/.ParaProf/perfdmf.cfg.foo . -a, --applicationid applicationID specify the id number of the newly added application (default uses auto-increment). -n, --name name the name of the application.

This script will create a new experiment in the perfdmf database.

-g, --configFile configFile specify the path to the file that defines the perfdmf configuration. -c, --config configuration_name specify the name of the perfdmf configuration -c foo is equalivent to -g <home>/.ParaProf/perfdmf.cfg.foo. -a, --applicationid applicationID specify the id number of the application to associate with the new experiment. -n, --name name the name of the application.

Command line tool to load a trial into the TAUdb database.

This script will create a new trial in the TAUdb database.

-n, --name name the name of the application. -a, --applicationname name specify associated application name for this trial -x, --experimentname experimentName specify the name of the experiment to associate with newly uploaded trial. -e, --experimentid experimentID specify the id number of the experiment to associate with the new trial. -g, --configFile configFile specify the path to the file that defines the TAUdb configuration. (overrides -c) -c, --config configuration_name specify the name of the TAUdb configuration -c foo is equalivent to -g <. -t, --trialid experimentID specify the id number of the newly uploaded trial. -m, --metadata filename specify the filename of the XML metadata for this trial. -f, --filetype filetype Specify type of performance data, options are: profiles (default), pprof, dynaprof, mpip, gprof, psrun, hpm, packed, cube, hpc, ompp, snap, perixml, gptl, paraver, ipm, google -i, --fixnames Use the fixnames option for gprof

For the TAU profiles type, you can specify either a specific set of profile files on the commandline, or you can specify a directory (by default the current directory). The specified directory will be searched for profile...* files, or, in the case of multiple counters, directories named MULTI_* containing profile data.

taudb_loadtrial -e 12 -n "Batch 001" This will load profile.* (or multiple counters directories MULTI_*) into experiment 12 and give the trial the name "Batch 001" taudb_loadtrial -e 12 -n "HPM data 01" -f hpm perfhpm* This will load perfhpm* files of type HPMToolkit into experiment 12 and give the trial the name "HPM data 01" taudb_loadtrial -a "NPB2.3" -x "parametric" -n "64" par64.ppk This will load packed profile par64.ppk into the experiment named "parametric" under the application named "NPB2.3" and give the trial the name "64". The application and experiment will be created if not found.

Launches TAU’s Performance Data Mining Analyzer.

Complete documentation can be found at http://www.cs.uoregon.edu/research/tau/tau-usersguide.pdf

Configures a TAUdb database for use with perfexplorer, and installs necessary JAR files.

Configures a TAUdb database for use with perfexplorer, and installs necessary JAR files.

C compiler wrapper for TAU

If the -tau:makefile option is not used, the TAU_MAKEFILE environment variable will be checked, if it is not specified, then the -tau:<options> will be used to identify a binding.

taucc foo.c -o foo taucc -tau:MPI,OPENMP,TRACE foo.c -o foo taucc -tau:verbose -tau:PTHREAD foo.c -o foo

Complete documentation can be found at http://www.cs.uoregon.edu/research/tau/tau-usersguide.pdf

UPC wrapper for TAU

If the -tau:makefile option is not used, the TAU_MAKEFILE environment variable will be checked, if it is not specified, then the -tau:<options> will be used to identify a binding.

Complete documentation can be found at http://www.cs.uoregon.edu/research/tau/tau-usersguide.pdf

C++ compiler wrapper for TAU

If the -tau:makefile option is not used, the TAU_MAKEFILE environment variable will be checked, if it is not specified, then the -tau:<options> will be used to identify a binding.

taucxx foo.cpp -o foo taucxx -tau:MPI,OPENMP,TRACE foo.cpp -o foo taucxx -tau:verbose -tau:PTHREAD foo.cpp -o foo

Complete documentation can be found at http://www.cs.uoregon.edu/research/tau/tau-usersguide.pdf

Fortran compiler wrapper for TAU

If the -tau:makefile option is not used, the TAU_MAKEFILE environment variable will be checked, if it is not specified, then the -tau:<options> will be used to identify a binding.

tauf90 foo.f90 -o foo tauf90 -tau:MPI,OPENMP,TRACE foo.f90 -o foo tauf90 -tau:verbose -tau:PTHREAD foo.f90 -o foo

Complete documentation can be found at http://www.cs.uoregon.edu/research/tau/tau-usersguide.pdf

Launches TAU’s Java-based performance data viewer.

For the TAU profiles type, you can specify either a specific set of profile files on the commandline, or you can specify a directory (by default the current directory). The specified directory will be searched for profile...* files, or, in the case of multiple counters, directories named MULTI_* containing profile data.

Complete documentation can be found at http://www.cs.uoregon.edu/research/tau/tau-usersguide.pdf

Quickly diplays profile data.

-a Show all location information available -c Sort according to number of Calls -b Sort according to number of suBroutines called by a function -m Sort according to Milliseconds (exclusive time total) -t Sort according to Total milliseconds (inclusive time total) (default) -e Sort according to Exclusive time per call (msec/call) -i Sort according to Inclusive time per call (total msec/call) -v Sort according to Standard Deviation (excl usec) -r Reverse sorting order -s print only Summary profile information -n num print only first num number of functions -f filename specify full path and Filename without node ids -p suPpress conversion to hhmmssmmm format -l List all functions and exit -d Dump output format (for tau_reduce) [node numbers] prints only info about all contexts/threads of given node numbers

automaticly instruments a source basied on information provided by pdt.

-a Show all location information available -c Sort according to number of Calls -b Sort according to number of suBroutines called by a function -m Sort according to Milliseconds (exclusive time total) -t Sort according to Total milliseconds (inclusive time total) (default) -e Sort according to Exclusive time per call (msec/call) -i Sort according to Inclusive time per call (total msec/call) -v Sort according to Standard Deviation (excl usec) -r Reverse sorting order -s print only Summary profile information -n num print only first num number of functions -f filename specify full path and Filename without node ids -p suPpress conversion to hhmmssmmm format -l List all functions and exit -d Dump output format (for tau_reduce) [node numbers] prints only info about all contexts/threads of given node numbers

%> tau_instrumentor foo.pdb foo.cpp -o foo.inst.cpp -f select.tau

Converts VTF profile to TAU profiles and launches an interactive VTF prompt.

-c Opens command line interface. -f Converts trace [file] to TAU profiles. -p Places the resulting profiles in the directory [path]. -i States that the interval [from],[to] should be profiled.

Launches GUI interface to configure TAU.

-v Verbose output. --html Output results in HTML. --build Only build. --run Only run.

Instruments an external library with TAU without needing to recompile

---- %> tau_wrap hdf5.h.pdb hdf5.h -o hdf5.inst.c -f select.tau -g hdf5 ---- This specifies the instrumented wrapper library source (hdf5.inst.c), the instrumentation specification file (select.tau) and the group (hdf5). It creates the wrapper/ directory.

Generates a wrapper library that can intercept at link time or at runtime routines specified in a header file

---- %> tau_gen_wrapper hdf5.h /usr/lib/libhdf5.a ---- This generates a wrapper library that may be linked in using TAU_OPTIONS -optTauWrapFile=<wrapperdir>/link_options.tau

tau_gen_wrapper reads the TAU_MAKEFILE environment variable to get PDT settings

Instruments application at run time using Intel’s PIN library

To profile routines in mytest.exe with prefix "myf": ---- tau_pin -r myf.* — mytest.exe ---- To profile all routines in mpitest.exe ( no need to specify any rule for all ): ---- tau_pin mpitest.exe ---- to profile only MPI routines in mpitest.exe by launching two instances: ---- tau_pin -n 2 -r MPI.* — mpitest.exe ---- .Wildcards * for anything, for example *MPI means any string having MPI in between any other characters. * ? It’s a placeholder wild card ?MPI* means any character followed by MPI and followed by any string, example: ??Try could be __Try or MyTry or MeTry etc.

Instruments java applications at runtime using JVMTI

Detects the available CUPTI counters on the a each GPU device.

Instruments and executes binaries to generate performance data. (DyninstAPI based instrumentor)

Rewrites binaries using Maqao if TAU is configured using PDT 3.17+ at the routine level. If it doesn’t find the Maqao package from PDT 3.17, it reverts to tau_run (DyninstAPI based instrumentor).

Defaults if unspecified: -T MPI MPI is assumed unless SERIAL is specified

---- tau_rewrite -T papi,pdt a.out -o a.inst ---- ---- mpirun -np 4 ./a.inst ----

Launches PySpark applications with TAU instrumentation

TAU can profile PySpark applications using Spark 2.2 or later and Python 2.7 or later with the numpy package installed. TAU must be configured with the -pythoninc and -pythonlib options specifying an appropriate Python installation. The SPARK_HOME environment variable must be set to the location of your Spark installation. Replace spark-submit in your normal Spark application invocation with tau_spark-submit. Options for tau_spark-submit can be set using the TAU_SPARK_PYTHON_ARGS environment variable. A PySpark application profiled using tau_spark-submit will generate one profile file per task executed.

---- export TAU_SPARK_PYTHON_ARGS="-T serial,python" ---- ---- tau_spark-submit --master local[4] ./als.py ----

Additional documentation and examples can be found in the pyspark subdirectory of the examples directory in your TAU installation.

TAUdb (TAU Database), formerly known as PerfDMF (Performance Data Management Framework) is a an API/Toolkit that sits atop a DBMS to manage and analyze performance data. The API is available in its native Java form as well as C.

The easiest way to interact with TAUdb is to use ParaProf which provides a GUI interface to all of the database information. In addition, the following commandline utilities are provided.

The database schema in TAUdb is designed to flexibly and efficiently store multidimensional parallel performance data. There are 5 dimensions to the actual timer measurements, and 4 dimensions to the counter measurements

Timer dimensions

Counter dimensions

Starts a timer.

Starts the timer given by name

C/C++ :

Fortran :

TAU_PROFILE , TAU_STOP

Stops a timer.

Stops the timer given by timer . It is important to note that timers can be nested, but not overlapping. TAU detects programming errors that lead to such overlaps at runtime, and prints a warning message.

C/C++ :

Fortran :

TAU_PROFILE , TAU_START

Profile a C++ function

TAU_PROFILE profiles a function. This macro defines the function and takes care of the timer start and stop as well. The timer will stop when the macro goes out of scope (as in C++ destruction).

TAU_PROFILE_TIMER

dynamic_profile a c++ function

TAU_DYNAMIC_PROFILE profiles a function dynamically creating a separate profile for each time the function is called. this macro defines the function and takes care of the timer start and stop as well. the timer will stop when the macro goes out of scope (as in c++ destruction).

Creates a dynamic timer

TAU_PROFILE_CREATE_DYNAMIC creates a dynamic timer the name of the timer should be different for each execution.

TAU_DYNAMIC_TIMER_START TAU_DYNAMIC_TIMER_STOP

Creates a dynamic timer for C/C++

TAU_CREATE_DYNAMIC_AUTO creates a dynamic timer automatically incrementing the name each time the timer is executed.

TAU_PROFILE_CREATE_DYNAMIC TAU_DYNAMIC_TIMER_START TAU_DYNAMIC_TIMER_STOP

Creates a dynamic timer in Fortran.

TAU_PROFILE_DYNAMIC_ITER creates a dynamic timer the name of the timer is appended by the iterator.

TAU_DYNAMIC_TIMER_START TAU_DYNAMIC_TIMER_STOP

Creates a dynamic phase in Fortran.

TAU_PHASE_DYNAMIC_ITER creates a dynamic phase the name of which is appended by the iterator.

TAU_DYNAMIC_TIMER_START TAU_DYNAMIC_TIMER_STOP

Defines a static timer.

C/C++ : With TAU_PROFILE_TIMER , a group of one or more statements is profiled. This macro has a timer variable as its first argument, and then strings for name and type, as described earlier. It associates the timer to the profile group specified in the last parameter. Fortran : To profile a block of Fortran code, such as a function, subroutine, loop etc., the user must first declare a profiler, which is an integer array of two elements (pointer) with the save attribute, and pass it as the first parameter to the TAU_PROFILE_TIMER subroutine. The second parameter must contain the name of the routine, which is enclosed in a single quote. TAU_PROFILE_TIMER declares the profiler that must be used to profile a block of code. The profiler is used to profile the statements using TAU_PROFILE_START and TAU_PROFILE_STOP as explained later.

C/C++ :

Fortran :

TAU_PROFILE_TIMER_DYNAMIC , TAU_PROFILE_START , TAU_PROFILE_STOP

Starts a timer.

Starts the timer given by timer

C/C++ :

Fortran :

TAU_PROFILE_TIMER , TAU_PROFILE_STOP

Stops a timer.

Stops the timer given by timer . It is important to note that timers can be nested, but not overlapping. TAU detects programming errors that lead to such overlaps at runtime, and prints a warning message.

C/C++ :

Fortran :

TAU_PROFILE_TIMER , TAU_PROFILE_START

Starts a timer.

Starts a static timer defined by TAU_PROFILE .

C/C++ :

Fortran :

TAU_PROFILE , TAU_STATIC_PHASE_START , TAU_STATIC_PHASE_STOP

Starts a timer.

Starts a static timer defined by TAU_PROFILE .

C/C++ :

Fortran :

TAU_PROFILE , TAU_STATIC_PHASE_START , TAU_STATIC_PHASE_STOP

Starts a dynamic timer.

Starts a new dynamic timer concating the iterator to the end of the name.

C/C++ :

Fortran :

TAU_PROFILE_TIMER , TAU_PROFILE_STOP

Starts a dynamic timer.

Stops a new dynamic timer concating the iterator to the end of the name. timer

C/C++ :

Fortran :

TAU_PROFILE_TIMER , TAU_PROFILE_STOP

Defines a dynamic timer.

TAU_PROFILE_TIMER_DYNAMIC operates similar to TAU_PROFILE_TIMER except that the timer is created each time the statement is invoked. This way, the name of the timer can be different for each execution.

C/C++ :

Fortran :

TAU_PROFILE_TIMER , TAU_PROFILE_START , TAU_PROFILE_STOP

Declares a timer for C

Because C89 does not allow mixed code and declarations, TAU_PROFILE_TIMER can only be used once in a function. To declare two timers in a C function, use TAU_PROFILE_DECLARE_TIMER and TAU_PROFILE_CREATE_TIMER .

C :

TAU_PROFILE_CREATE_TIMER

Creates a timer for C

Because C89 does not allow mixed code and declarations, TAU_PROFILE_TIMER can only be used once in a function. To declare two timers in a C function, use TAU_PROFILE_DECLARE_TIMER and TAU_PROFILE_CREATE_TIMER .

C :

TAU_PROFILE_DECLARE_TIMER , TAU_PROFILE_START , TAU_PROFILE_STOP

Declares a global timer

As TAU_PROFILE_TIMER is used within the scope of a block (typically a routine), TAU_GLOBAL_TIMER can be used across different routines.

C/C++ :

TAU_GLOBAL_TIMER_EXTERNAL , TAU_GLOBAL_TIMER_START , TAU_GLOBAL_TIMER_STOP

Declares a global timer from an external compilation unit

TAU_GLOBAL_TIMER_EXTERNAL allows you to access a timer defined in another compilation unit.

C/C++ :

TAU_GLOBAL_TIMER , TAU_GLOBAL_TIMER_START , TAU_GLOBAL_TIMER_STOP

Starts a global timer

TAU_GLOBAL_TIMER_START starts a global timer.

C/C++ :

TAU_GLOBAL_TIMER , TAU_GLOBAL_TIMER_EXTERNAL , TAU_GLOBAL_TIMER_STOP

Stops a global timer

TAU_GLOBAL_TIMER_STOP stops a global timer.

C/C++ :

TAU_GLOBAL_TIMER , TAU_GLOBAL_TIMER_EXTERNAL , TAU_GLOBAL_TIMER_START

Profile a C++ function as a phase

TAU_PHASE profiles a function as a phase. This macro defines the function and takes care of the timer start and stop as well. The timer will stop when the macro goes out of scope (as in C++ destruction).

TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_CREATE_STATIC

Defines a dynamic phase.

TAU_DYNAMIC_PHASE creates a dynamic phase. The name of the timer can be different for each execution.

C/C++ :

Fortran :

TAU_PHASE_CREATE_DYNAMIC , TAU_DYNAMIC_PHASE_START , TAU_DYNAMIC_PHASE_STOP

Defines a dynamic phase.

TAU_PHASE_CREATE_DYNAMIC creates a dynamic phase. The name of the timer can be different for each execution.

C/C++ :

Fortran :

TAU_PHASE_CREATE_STATIC , TAU_PHASE_START , TAU_PHASE_STOP

Defines a static phase.

TAU_PHASE_CREATE_STATIC creates a static phase. Static phases (and timers) are more efficient than dynamic ones because the function registration only takes place once.

C/C++ :

Fortran :

TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_START , TAU_PHASE_STOP

Enters a phase.

TAU_PHASE_START enters a phase. Phases can be nested, but not overlapped.

C/C++ :

Fortran :

TAU_PHASE_CREATE_STATIC , TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_STOP

Exits a phase.

TAU_PHASE_STOP exits a phase. Phases can be nested, but not overlapped.

C/C++ :

Fortran :

TAU_PHASE_CREATE_STATIC , TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_START

Enters a DYNAMIC_PHASE.

TAU_DYNAMIC_PHASE_START enters a DYNAMIC phase. Phases can be nested, but not overlapped.

C/C++ :

Fortran :

TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_CREATE_STATIC , TAU_PHASE_STOP

Enters a DYNAMIC_PHASE.

TAU_DYNAMIC_PHASE_STOP leaves a DYNAMIC phase. Phases can be nested, but not overlapped.

C/C++ :

Fortran :

TAU_PHASE_CREATE_STATIC , TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_STOP

Enters a STATIC_PHASE.

TAU_STATIC_PHASE_START enters a static phase. Phases can be nested, but not overlapped.

C/C++ :

Fortran :

TAU_PHASE_CREATE_STATIC , TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_STOP

Enters a STATIC_PHASE.

TAU_STATIC_PHASE_STOP leaves a static phase. Phases can be nested, but not overlapped.

C/C++ :

Fortran :

TAU_PHASE_CREATE_STATIC , TAU_PHASE_CREATE_DYNAMIC , TAU_PHASE_STOP

Declares a global phase

Declares a global phase to be used in multiple compilation units.

C/C++ :

TAU_GLOBAL_PHASE_EXTERNAL , TAU_GLOBAL_PHASE_START , TAU_GLOBAL_PHASE_STOP

Declares a global phase from an external compilation unit

TAU_GLOBAL_PHASE_EXTERNAL allows you to access a phase defined in another compilation unit.

C/C++ :

TAU_GLOBAL_PHASE , TAU_GLOBAL_PHASE_START , TAU_GLOBAL_PHASE_STOP

Starts a global phase

TAU_GLOBAL_PHASE_START starts a global phase.

C/C++ :

TAU_GLOBAL_PHASE , TAU_GLOBAL_PHASE_EXTERNAL , TAU_GLOBAL_PHASE_STOP

Stops a global phase

TAU_GLOBAL_PHASE_STOP stops a global phase.

C/C++ :

TAU_GLOBAL_PHASE , TAU_GLOBAL_PHASE_EXTERNAL , TAU_GLOBAL_PHASE_START

Alerts the profiling system to an exit call

TAU_PROFILE_EXIT should be called prior to an error exit from the program so that any profiles or event traces can be dumped to disk before quitting.

C/C++ :

Fortran :

TAU_DB_DUMP

Register a thread with the profiling system

To register a thread with the profiling system, invoke the TAU_REGISTER_THREAD macro in the run method of the thread prior to executing any other TAU macro. This sets up thread identifiers that are later used by the instrumentation system.

C/C++ :

Fortran :

PDT based tau_instrumentor does not insert TAU_REGISTER_THREAD calls, they must be inserted manually

Returns the measurement system’s node id

TAU_PROFILE_GET_NODE gives the node id for the processes in which it is called. When using MPI node id is the same as MPI rank.

C/C++ :

Fortran :

Python:

TAU_PROFILE_GET_CONTEXT

Gives the measurement system’s context id

TAU_PROFILE_GET_CONTEXT gives the context id for the processes in which it is called.

C/C++ :

Fortran :

TAU_PROFILE_SET_CONTEXT

Informs the measurement system of the THREAD id

The TAU_PROFILE_SET_THREAD macro sets the thread identifier of the executing task for profiling and tracing. Tasks are identified using node, context and thread ids. The profile data files generated will accordingly be named profile.<THREAD>.<context>.<thread>. Note that it is not necessary to call TAU_PROFILE_SET_THREAD when you configued with a threading package (including OpenMP).

C/C++ :

Fortran :

Python:

TAU_PROFILE_SET_NODE TAU_PROFILE_SET_CONTEXT

Gives the measurement system’s thread id

TAU_PROFILE_GET_THREAD gives the thread id for the processes in which it is called.

C/C++ :

Fortran :

Python:

TAU_PROFILE_GET_NODE TAU_PROFILE_GET_CONTEXT

Informs the measurement system of the node id

The TAU_PROFILE_SET_NODE macro sets the node identifier of the executing task for profiling and tracing. Tasks are identified using node, context and thread ids. The profile data files generated will accordingly be named profile.<node>.<context>.<thread>. Note that it is not necessary to call TAU_PROFILE_SET_NODE when using the TAU MPI wrapper library.

C/C++ :

Fortran :

Python:

TAU_PROFILE_SET_CONTEXT

Informs the measurement system of the context id

The TAU_PROFILE_SET_CONTEXT macro sets the context identifier of the executing task for profiling and tracing. Tasks are identified using context, context and thread ids. The profile data files generated will accordingly be named profile.<context>.<context>.<thread>. Note that it is not necessary to call TAU_PROFILE_SET_CONTEXT when using the TAU MPI wrapper library.

C/C++ :

Fortran :

TAU_PROFILE_SET_NODE

Informs the measurement system that a fork has taken place

To register a child process obtained from the fork() syscall, invoke the TAU_REGISTER_FORK macro. It takes two parameters, the first is the node id of the child process (typically the process id returned by the fork call or any 0..N-1 range integer). The second parameter specifies whether the performance data for the child process should be derived from the parent at the time of fork ( TAU_INCLUDE_PARENT_DATA ) or should be independent of its parent at the time of fork ( TAU_EXCLUDE_PARENT_DATA ). If the process id is used as the node id, before any analysis is done, all profile files should be converted to contiguous node numbers (from 0..N-1). It is highly recommended to use flat contiguous node numbers in this call for profiling and tracing.

C/C++ :

Registers a user event

TAU can profile user-defined events using TAU_REGISTER_EVENT . The meaning of the event is determined by the user. The first argument to TAU_REGISTER_EVENT is the pointer to an integer array. This array is declared with a save attribute as shown below.

C/C++ :

Fortran :

TAU_EVENT , TAU_REGISTER_CONTEXT_EVENT , TAU_REPORT_STATISTICS , TAU_REPORT_THREAD_STATISTICS , TAU_GET_EVENT_NAMES , TAU_GET_EVENT_VALS

Registers a user event

TAU can profile user-defined events using TAU_PROFILER_REGISTER_EVENT . The meaning of the event is determined by the user. The first argument to TAU_PROFILER_REGISTER_EVENT is the pointer to an integer array. This array is declared with a save attribute as shown below.

C/C++ :

Fortran :

TAU_EVENT , TAU_REGISTER_CONTEXT_EVENT , TAU_REPORT_STATISTICS , TAU_REPORT_THREAD_STATISTICS , TAU_GET_EVENT_NAMES , TAU_GET_EVENT_VALS

Triggers a user event

Triggers an named event with the given value

C/C++ :

Fortran :

Triggers a user event

Triggers an named event with the given value on a given thead or task.

C/C++ :

Fortran :

Triggers a user event

Triggers an event that was registered with TAU_REGISTER_EVENT .

C/C++ :

Fortran :

TAU_REGISTER_EVENT

Triggers a user event on a given thread

Triggers an event that was registered with TAU_REGISTER_EVENT on a given thread.

C/C++ :

Fortran :

TAU_REGISTER_EVENT

Registers a context event

Creates a context event with name. A context event appends the names of routines executing on the callstack to the name specified by the user. Whenver a context event is triggered, the callstack is examined to determine the context of execution. Starting from the parent function where the event is triggered, TAU walks up the callstack to a depth specified by the user in the environment variable TAU_CALLPATH_DEPTH . If this environment variable is not specified, TAU uses 2 as the default depth. For e.g., if the user registers a context event with the name "memory used" and specifies 3 as the callpath depth, and if the event is triggered in two locations (in routine a, when it was called by b, when it was called by c, and in routine h, when it was called by g, when it was called by i), then, we’d see the user defined event information for "memory used: c() ⇒ b() ⇒ a()" and "memory used: i() ⇒ g() ⇒ h()".

C/C++ :

Fortran :

TAU_CONTEXT_EVENT , TAU_ENABLE_CONTEXT_EVENT , TAU_DISABLE_CONTEXT_EVENT , TAU_REGISTER_EVENT , TAU_REPORT_STATISTICS , TAU_REPORT_THREAD_STATISTICS , TAU_GET_EVENT_NAMES , TAU_GET_EVENT_VALS

Triggers a context event

Triggers a context event. A context event associates the name with the list of routines along the callstack. A context event tracks information like a user defined event and TAU records the maxima, minima, mean, std. deviation and the number of samples for each context event. A context event helps distinguish the data supplied by the user based on the location where an event occurs and the sequence of actions (routine/timer invocations) that preceeded the event. The depth of the the callstack embedded in the context event’s name is specified by the user in the environment variable TAU_CALLPATH_DEPTH . If this variable is not specified, TAU uses a default depth of 2.

C/C++ :

Fortran :

TAU_REGISTER_CONTEXT_EVENT

Triggers a context event

Triggers an event with a name and the list of routines along the callstack. A context event tracks information like a user defined event and TAU records the maxima, minima, mean, std. deviation and the number of samples for each context event. A context event helps distinguish the data supplied by the user based on the location where an event occurs and the sequence of actions (routine/timer invocations) that preceeded the event. The depth of the the callstack embedded in the context event’s name is specified by the user in the environment variable TAU_CALLPATH_DEPTH . If this variable is not specified, TAU uses a default depth of 2.

C/C++ :

Fortran :

TAU_REGISTER_CONTEXT_EVENT

Triggers a context user event

Triggers an event with a name and the list of routines along the callstack. A context event tracks information like a user defined event and TAU records the maxima, minima, mean, std. deviation and the number of samples for each context event. A context event helps distinguish the data supplied by the user based on the location where an event occurs and the sequence of actions (routine/timer invocations) that preceeded the event. The depth of the the callstack embedded in the context event’s name is specified by the user in the environment variable TAU_CALLPATH_DEPTH . If this variable is not specified, TAU uses a default depth of 2.

C/C++ :

Fortran :

Enable a context event

Enables a context event.

C/C++ :

TAU_REGISTER_CONTEXT_EVENT , TAU_DISABLE_CONTEXT_EVENT

Disable a context event

Disables a context event.

C/C++ :

TAU_REGISTER_CONTEXT_EVENT , TAU_ENABLE_CONTEXT_EVENT

Sets the name of an event

Changes the name of an event.

C/C++ :

TAU_REGISTER_EVENT

Disables tracking of maximum statistic for a given event

Disables tracking of maximum statistic for a given event

C/C++ :

TAU_REGISTER_EVENT

Disables tracking of mean statistic for a given event

Disables tracking of mean statistic for a given event

C/C++ :

TAU_REGISTER_EVENT

Disables tracking of minimum statistic for a given event

Disables tracking of minimum statistic for a given event

C/C++ :

TAU_REGISTER_EVENT

Disables tracking of standard deviation statistic for a given event

Disables tracking of standard deviation statistic for a given event

C/C++ :

TAU_REGISTER_EVENT

Outputs statistics

TAU_REPORT_STATISTICS prints the aggregate statistics of user events across all threads in each node. Typically, this should be called just before the main thread exits.

C/C++ :

Fortran :

TAU_REGISTER_EVENT , TAU_REGISTER_CONTEXT_EVENT , TAU_REPORT_THREAD_STATISTICS

Outputs statistics, plus thread statistics

TAU_REPORT_THREAD_STATISTICS prints the aggregate, as well as per thread user event statistics. Typically, this should be called just before the main thread exits.

C/C++ :

Fortran :

TAU_REGISTER_EVENT , TAU_REGISTER_CONTEXT_EVENT , TAU_REPORT_STATISTICS

Enables instrumentation

TAU_ENABLE_INSTRUMENTATION macro re-enables all TAU instrumentation. All instances of functions and statements that occur between the disable/enable section are ignored by TAU. This allows a user to limit the trace size, if the macros are used to disable recording of a set of iterations that have the same characteristics as, for example, the first recorded instance.

C/C++ :

Fortran :

Python:

TAU_DISABLE_INSTRUMENTATION , TAU_ENABLE_GROUP , TAU_DISABLE_GROUP , TAU_INIT , TAU_PROFILE_INIT

Disables instrumentation

TAU_DISABLE_INSTRUMENTATION macro disables all entry/exit instrumentation within all threads of a context. This allows the user to selectively enable and disable instrumentation in parts of his/her code. It is important to re-enable the instrumentation within the same basic block and scope.

C/C++ :

Fortran :

Python:

TAU_ENABLE_INSTRUMENTATION , TAU_ENABLE_GROUP , TAU_DISABLE_GROUP , TAU_INIT , TAU_PROFILE_INIT

Enables tracking of a given group

Enables the instrumentation for a given group. By default, it is already on.

C/C++ :

Fortran :

Python:

TAU_ENABLE_INSTRUMENTATION , TAU_DISABLE_INSTRUMENTATION , TAU_DISABLE_GROUP , TAU_INIT , TAU_PROFILE_INIT

Disables tracking of a given group

Disables the instrumentation for a given group. By default, it is on.

C/C++ :

Fortran :

Python:

TAU_ENABLE_INSTRUMENTATION , TAU_DISABLE_INSTRUMENTATION , TAU_ENABLE_GROUP , TAU_INIT , TAU_PROFILE_INIT

Change the group of a timer

TAU_PROFILE_TIMER_SET_GROUP changes the group associated with a timer.

C/C++ :

TAU_PROFILE_TIMER , TAU_PROFILE_TIMER_SET_GROUP_NAME

Changes the group name for a timer

TAU_PROFILE_TIMER_SET_GROUP_NAME changes the group name associated with a given timer.

C/C++ :

TAU_PROFILE_TIMER , TAU_PROFILE_TIMER_SET_GROUP

Changes the name of a timer

TAU_PROFILE_TIMER_SET_NAME macro changes the name associated with a timer to the newname argument.

C/C++ :

TAU_PROFILE_TIMER

Changes the type of a timer

TAU_PROFILE_TIMER_SET_TYPE macro changes the type associated with a timer to the newname argument.

C/C++ :

TAU_PROFILE_TIMER

Changes the group name of a profiled section

TAU_PROFILE_SET_GROUP_NAME macro allows the user to change the group name associated with the instrumented routine. This macro must be called within the instrumented routine.

C/C++ :

TAU_PROFILE

Processes command-line arguments for selective instrumentation

TAU_INIT parses and removes the command-line arguments for the names of profile groups that are to be selectively enabled for instrumentation. By default, if this macro is not used, functions belonging to all profile groups are enabled. TAU_INIT differs from TAU_PROFILE_INIT only in the argument types.

C/C++ :

TAU_PROFILE_INIT

Processes command-line arguments for selective instrumentation

TAU_PROFILE_INIT parses the command-line arguments for the names of profile groups that are to be selectively enabled for instrumentation. By default, if this macro is not used, functions belonging to all profile groups are enabled. TAU_INIT differs from TAU_PROFILE_INIT only in the argument types.

C/C++ :

Fortran :

TAU_INIT

Creates groups based on names

TAU_GET_PROFILE_GROUP allows the user to dynamically create groups based on strings, rather than use predefined, statically assigned groups such as TAU_USER1, TAU_USER2 etc. This allows names to be associated in creating unique groups that are more meaningful, using names of files or directories for instance.

C/C++ :

Python:

TAU_ENABLE_GROUP_NAME , TAU_DISABLE_GROUP_NAME , TAU_ENABLE_ALL_GROUPS , TAU_DISABLE_ALL_GROUPS

Enables a group based on name

TAU_ENABLE_GROUP_NAME macro can turn on the instrumentation associated with routines based on a dynamic group assigned to them. It is important to note that this and the TAU_DISABLE_GROUP_NAME macros apply to groups created dynamically using TAU_GET_PROFILE_GROUP.

C/C++ :

Fortran :

Python:

TAU_GET_PROFILE_GROUP , TAU_DISABLE_GROUP_NAME , TAU_ENABLE_ALL_GROUPS , TAU_DISABLE_ALL_GROUPS

Disables a group based on name

Similar to TAU_ENABLE_GROUP_NAME , this macro turns off the instrumentation in all routines associated with the dynamic group created using the tau_instrumentor -g <group_name> argument.

C/C++ :

Fortran :

Python:

TAU_GET_PROFILE_GROUP , TAU_ENABLE_GROUP_NAME , TAU_ENABLE_ALL_GROUPS , TAU_DISABLE_ALL_GROUPS

Enables instrumentation in all groups

This macro turns on instrumentation in all groups

C/C++ :

Fortran :

Python:

TAU_GET_PROFILE_GROUP , TAU_ENABLE_GROUP_NAME , TAU_DISABLE_GROUP_NAME , TAU_DISABLE_ALL_GROUPS

Disables instrumentation in all groups

This macro turns off instrumentation in all groups.

C/C++ :

Fortran :

Python:

TAU_GET_PROFILE_GROUP , TAU_ENABLE_GROUP_NAME , TAU_DISABLE_GROUP_NAME , TAU_ENABLE_ALL_GROUPS

Gets the registered user events.

Retrieves user event names for all user-defined events

C/C++ :

TAU_REGISTER_EVENT , TAU_REGISTER_CONTEXT_EVENT , TAU_GET_EVENT_VALS

Gets user event data for given user events.

Retrieves user defined event data for the specified user defined events. The list of events are specified by the first parameter (eventList) and the user specifies the number of events in the second parameter (numUserEvents). TAU returns the number of times the event was invoked in the numUserEvents. The max, min, mean values are returned in the following parameters. TAU computes the sum of squares of the given event and returns this value in the next argument (sumSqe).

C/C++ :

TAU_REGISTER_EVENT , TAU_REGISTER_CONTEXT_EVENT , TAU_GET_EVENT_NAMES

Gets the counter names

TAU_GET_COUNTER_NAMES returns the list of counter names and the number of counters used for measurement. When wallclock time is used, the counter name of "default" is returned.

C/C++ :

Python:

TAU_GET_FUNC_NAMES , TAU_GET_FUNC_VALS

Gets the function names

This macro fills the funcList argument with the list of timer and routine names. It also records the number of routines active in the numFuncs argument.

C/C++ :

Python:

TAU_GET_COUNTER_NAMES , TAU_GET_FUNC_VALS , TAU_DUMP_FUNC_NAMES , TAU_DUMP_FUNC_VALS

Gets detailed performance data for given functions

It gets detailed performance data for the list of routines. The user specifies inFuncs and the number of routines; TAU then returns the other arguments with the performance data. counterExclusiveValues and counterInclusiveValues are two dimensional arrays: the first dimension is the routine id and the second is counter id. The value is indexed by these two dimensions. numCalls and numSubrs (or child routines) are one dimensional arrays.

C/C++ :

Python:

TAU_GET_COUNTER_NAMES , TAU_GET_FUNC_NAMES , TAU_DUMP_FUNC_NAMES , TAU_DUMP_FUNC_VALS

Enables memory tracking

Enables tracking of the heap memory utilization in the program. TAU takes a sample of the heap memory utilized (as reported by the mallinfo system call) and associates it with a single global user defined event. An interrupt is generated every 10 seconds and the value of the heap memory used is recorded in the user defined event. The inter-interrupt interval (default of 10 seconds) may be set by the user using the call TAU_SET_INTERRUPT_INTERVAL .

C/C++ :

Fortran :

Python:

TAU_DISABLE_TRACKING_MEMORY , TAU_SET_INTERRUPT_INTERVAL , TAU_TRACK_MEMORY , TAU_TRACK_MEMORY_HERE

Disables memory tracking

Disables tracking of heap memory utilization. This call may be used in sections of code where TAU should not interrupt the execution to periodically track the heap memory utilization.

C/C++ :

Fortran :

Python:

TAU_ENABLE_TRACKING_MEMORY , TAU_SET_INTERRUPT_INTERVAL , TAU_TRACK_MEMORY , TAU_TRACK_MEMORY_HERE

Initializes POWER tracking system

For power profiling, there are two modes of operation: 1) the user explicitly inserts TAU_TRACK_POWER_HERE() calls in the source code and the power event is triggered at those locations, and 2) the user enables tracking POWER by calling TAU_TRACK_POWER() and an interrupt is generated every 10 seconds and the POWER event is triggered with the current value. Also, this interrupt interval can be changed by calling TAU_SET_INTERRUPT_INTERVAL(value). The tracking of power events in both cases can be explictly enabled or disabled by calling the macros TAU_ENABLE_TRACKING_POWER() or TAU_DISABLE_TRACKING_() respectively.

C/C++ :

Fortran :

Python:

TAU_ENABLE_TRACKING_POWER , TAU_DISABLE_TRACKING_POWER , TAU_SET_INTERRUPT_INTERVAL , TAU_TRACK_POWER_HERE , TAU_TRACK_POWER

Triggers power tracking at a given execution point

Triggers power tracking at a given execution point

C/C++ :

Fortran :

Python:

TAU_TRACK_POWER

Enables power headroom tracking

TAU_ENABLE_TRACKING_POWER() enables power tracking after a TAU_DISABLE_TRACKING_POWER() .

C/C++ :

Fortran :

Fortran :

TAU_TRACK_POWER , TAU_DISABLE_TRACKING_POWER , TAU_TRACK_POWER_HERE , TAU_SET_INTERRUPT_INTERVAL

Disables power headroom tracking

TAU_DISABLE_TRACKING_POWER() disables power tracking.

C/C++ :

Fortran :

Python:

TAU_TRACK_POWER , TAU_ENABLE_TRACKING_POWER , TAU_TRACK_POWER_HERE , TAU_SET_INTERRUPT_INTERVAL

Initializes memory tracking system

For memory profiling, there are two modes of operation: 1) the user explicitly inserts TAU_TRACK_MEMORY_HERE() calls in the source code and the memory event is triggered at those locations, and 2) the user enables tracking memory by calling TAU_TRACK_MEMORY() and an interrupt is generated every 10 seconds and the memory event is triggered with the current value. Also, this interrupt interval can be changed by calling TAU_SET_INTERRUPT_INTERVAL(value). The tracking of memory events in both cases can be explictly enabled or disabled by calling the macros TAU_ENABLE_TRACKING_MEMORY() or TAU_DISABLE_TRACKING_MEMORY() respectively.

C/C++ :

Fortran :

Python:

TAU_ENABLE_TRACKING_MEMORY , TAU_DISABLE_TRACKING_MEMORY , TAU_SET_INTERRUPT_INTERVAL , TAU_TRACK_MEMORY_HERE , TAU_TRACK_MEMORY_HEADROOM

Triggers memory tracking at a given execution point

Triggers memory tracking at a given execution point

C/C++ :

Fortran :

Python:

TAU_TRACK_MEMORY

Initializes memory footprint tracking system

Similar to TAU_TRACK_MEMORY but uses the Virtual Memory Resident Set Size (VmRSS) and High Water Mark (VmHWM) to produce an interval event and an atomic event respectively.

C/C++ :

Fortran :

TAU_ENABLE_TRACKING_MEMORY , TAU_DISABLE_TRACKING_MEMORY , TAU_SET_INTERRUPT_INTERVAL , TAU_TRACK_MEMORY_HERE , TAU_TRACK_MEMORY , TAU_TRACK_MEMORY_FOOTPRINT_HERE , TAU_TRACK_MEMORY_HEADROOM

Triggers memory footprint tracking at a given execution point

Similar to TAU_TRACK_MEMORY_HERE but uses the Virtual Memory Resident Set Size (VmRSS) and High Water Mark (VmHWM) to produce an interval event and an atomic event respectively.

C/C++ :

Fortran :

TAU_TRACK_MEMORY_FOOTPRINT

Enables memory headroom tracking

TAU_ENABLE_TRACKING_MEMORY_HEADROOM() enables memory headroom tracking after a TAU_DISABLE_TRACKING_MEMORY_HEADROOM() .

C/C++ :

Fortran :

Fortran :

TAU_TRACK_MEMORY_HEADROOM , TAU_DISABLE_TRACKING_MEMORY_HEADROOM , TAU_TRACK_MEMORY_HEADROOM_HERE , TAU_SET_INTERRUPT_INTERVAL

Disables memory headroom tracking

TAU_DISABLE_TRACKING_MEMORY_HEADROOM() disables memory headroom tracking.

C/C++ :

Fortran :

Python:

TAU_TRACK_MEMORY_HEADROOM , TAU_ENABLE_TRACKING_MEMORY_HEADROOM , TAU_TRACK_MEMORY_HEADROOM_HERE , TAU_SET_INTERRUPT_INTERVAL