tau_context_event(3) [debian man page]
TAU_CONTEXT_EVENT(3) TAU Instrumentation API TAU_CONTEXT_EVENT(3) NAME
TAU_CONTEXT_EVENT - Triggers a context event SYNOPSIS
C/C++: TAU_CONTEXT_EVENT(TauUserEvent variable, double value); Fortran: TAU_CONTEXT_EVENT(integer variable(2), real value); DESCRIPTION
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. EXAMPLE
C/C++ : int f2(void) { static int count = 0; count ++; TAU_PROFILE("f2()", "(sleeps 2 sec, calls f3)", TAU_USER); TAU_REGISTER_CONTEXT_EVENT(event, "Iteration count"); /* if (count == 2) TAU_DISABLE_CONTEXT_EVENT(event); */ printf("Inside f2: sleeps 2 sec, calls f3 "); TAU_CONTEXT_EVENT(event, 232+count); sleep(2); f3(); return 0; } Fortran : integer memevent(2) / 0, 0 / save memevent call TAU_REGISTER_CONTEXT_EVENT(memevent, "STORAGEARY mem allocated') call TAU_CONTEXT_EVENT(memevent, SIZEOF(STORAGEARY)*sizeof(INTEGER)) SEE ALSO
TAU_REGISTER_CONTEXT_EVENT(3) 08/31/2005 TAU_CONTEXT_EVENT(3)
Check Out this Related Man Page
TAU_TRACK_MEMORY_HEA(3) TAU Instrumentation API TAU_TRACK_MEMORY_HEA(3) NAME
TAU_TRACK_MEMORY_HEADROOM - Track the headroom (amount of memory for a process to grow) by periodically interrupting the program SYNOPSIS
C/C++: TAU_TRACK_MEMORY_HEADROOM(void); Fortran: TAU_TRACK_MEMORY_HEADROOM(void); DESCRIPTION
Tracks the amount of memory available for the process before it runs out of free memory on the heap. This call sets up a signal handler that is invoked every 10 seconds by an interrupt (this interval may be altered by using the TAU_SET_INTERRUPT_INTERVAL call). Inside the interrupt handler, TAU evaluates how much memory it can allocate and associates it with the callstack using the TAU context events (See TAU_REGISTER_CONTEXT_EVENT(3)). The user can vary the size of the callstack by setting the environment variable TAU_CALLPATH_DEPTH (default is 2). This call is useful on machines like IBM BG/L where no virtual memory (or paging using the swap space) is present. The amount of heap memory available to the program is limited by the amount of available physical memory. TAU executes a series of malloc calls with a granularity of 1MB and determines the amount of memory available for the program to grow. EXAMPLE
C/C++ : TAU_TRACK_MEMORY_HEADROOM(); Fortran : call TAU_TRACK_MEMORY_HEADROOM() SEE ALSO
TAU_TRACK_MEMORY(3), TAU_SET_INTERRUPT_INTERVAL(3), TAU_ENABLE_TRACKING_MEMORY_HEADROOM(3), TAU_DISABLE_TRACKING_MEMORY_HEADROOM(3), TAU_TRACK_MEMORY_HEADROOM_HERE(3) 08/31/2005 TAU_TRACK_MEMORY_HEA(3)