---

IgProf Class Reference

Core profiling implementation. More...

#include <IgTools/IgProf/src/IgProf.h>

List of all members.

Static Public Member Functions
static IgProfTrace *	buffer (int moduleid)
	Return a profile buffer for a profiler in the current thread.
static void	debug (const char *format,...)
	Internal printf()-like debugging utility.
static bool	disable (bool globally)
	Disable the profiling system, either globally or just in this thread.
static void	dump (void)
	Dump out the profiler data: trace tree and live maps.
static bool	enable (bool globally)
	Enable the profiling system, either globally or just in this thread.
static bool	enabled (bool globally)
	Check if the profiler is currently enabled.
static void	exitThread (bool final)
	Finalise a thread.
static bool	initialize (int *moduleid, void(*threadinit)(void), bool perthread)
	Initialise the profiler core itself.
static void	initThread (void)
	Setup a thread so it can be used in profiling.
static bool	isMultiThreaded (void)
	Return true if the process was linked against threading package.
static const char *	options (void)
	Get user-provided profiling options.
static int	panic (const char *file, int line, const char *func, const char *expr)
	Internal assertion helper routine.

---

Detailed Description

Core profiling implementation.

Implements utilities needed to implement actual profiler modules as well as final dumps.

Definition at line 11 of file IgProf.h.

---

Member Function Documentation

IgProfTrace * IgProf::buffer

(

int

moduleid

)

[static]

Return a profile buffer for a profiler in the current thread.

It is safe to call this function from any thread and in asynchronous signal handlers at any time. Returns the buffer to use or a null to indicate no data should be gathered in the calling context, for example if the profile core itself has already been destroyed.

Definition at line 315 of file IgProf.cc.

References IgProfTraceAlloc::buf, s_activated, s_bufkey, s_bufs, s_mainthread, and thread.

Referenced by __attribute__(), profileSignalHandler(), and remove().

{
  // Check which pool to return.  We return the one from s_bufs in
  // non-threaded applications and always in the main thread.  In
  // other threads we return the main thread buffer if a single buffer
  // was requested, otherwise a per-thread buffer.
  pthread_t thread = pthread_self();
  IgProfTraceAlloc *bufs = s_bufs;
  if (! s_activated)
    bufs = 0;
  else if (thread != s_mainthread && s_bufs[moduleid].perthread)
    bufs = (IgProfTraceAlloc *) pthread_getspecific(s_bufkey);

  return bufs ? bufs[moduleid].buf : 0;
}

void IgProf::debug	(	const char *	format,
			...
	)			[static]

Internal printf()-like debugging utility.

Produces output if $IGPROF_DEBUGGING environment variable is set to any value.

Definition at line 423 of file IgProf.cc.

References e.

Referenced by IgProfTrace::acquireResource(), IgProfBuffer::allocateRaw(), doexit(), dokill(), dopthread_sigmask(), dosigaction(), dump(), initialize(), initialize(), threadWrapper(), and IgProfExitDump::~IgProfExitDump().

{
  static const char *debugging = getenv("IGPROF_DEBUGGING");
  if (debugging)
  {
    timeval tv;
    gettimeofday(&tv, 0);
    fprintf(stderr, "*** IgProf(%lu, %.3f): ",
            (unsigned long) getpid(),
            tv.tv_sec + 1e-6*tv.tv_usec);

    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
  }
}

bool IgProf::disable

(

bool

globally

)

[static]

Disable the profiling system, either globally or just in this thread.

This is safe to call from anywhere. Returns true if the profiler was enabled before the call.

Definition at line 370 of file IgProf.cc.

References IgProfAtomicDec(), s_enabled, s_flagkey, and s_pthreads.

Referenced by doaccept(), doclose(), dodup(), dodup2(), doexit(), dokill(), doopen(), doopen64(), dopthread_create(), dosocket(), initialize(), initialize(), panic(), and IgProfExitDump::~IgProfExitDump().

{
  if (! globally && s_pthreads)
  {
    IgProfAtomic *flag = (IgProfAtomic *) pthread_getspecific(s_flagkey);
    return flag ? (IgProfAtomicDec(flag) >= 0 && s_enabled > 0) : false;
  }
  else
  {
    IgProfAtomic newval = IgProfAtomicDec(&s_enabled);
    return newval >= 0;
  }
}

void IgProf::dump

(

void

)

[static]

Dump out the profiler data: trace tree and live maps.

Definition at line 502 of file IgProf.cc.

References debug(), dumpProfile(), info, output(), s_clockres, s_masterbuf, s_outname, and IgProfTrace::stackRoot().

Referenced by dokill(), and IgProfExitDump::~IgProfExitDump().

{
  static bool dumping = false;
  if (dumping) return;
  dumping = true;

  FILE *output = (s_outname[0] == '|'
                  ? (unsetenv("LD_PRELOAD"), popen(s_outname+1, "w"))
                  : fopen (s_outname, "w+"));
  if (! output)
  {
    IgProf::debug("can't write to output %s: %d\n", s_outname, errno);
    dumping = false;
    return;
  }

  IgProfDumpInfo info = { 0, 0, 0, 0 };
  IgProf::debug("dumping state to %s\n", s_outname);
  fprintf(output, "P=(ID=%lu N=(%s) T=%f)\n",
          (unsigned long) getpid(), program_invocation_name, s_clockres);
  dumpProfile(output, s_masterbuf->stackRoot(), info);
  fclose(output);
  dumping = false;
}

bool IgProf::enable

(

bool

globally

)

[static]

Enable the profiling system, either globally or just in this thread.

This is safe to call from anywhere. Returns true if the profiler is enabled after the call.

Definition at line 352 of file IgProf.cc.

References IgProfAtomicInc(), s_enabled, s_flagkey, and s_pthreads.

Referenced by doaccept(), doclose(), dodup(), dodup2(), doexit(), dokill(), doopen(), doopen64(), dopthread_create(), dosocket(), initialize(), and initialize().

{
  if (! globally && s_pthreads)
  {
    IgProfAtomic *flag = (IgProfAtomic *) pthread_getspecific(s_flagkey);
    return flag ? (IgProfAtomicInc(flag) > 0 && s_enabled > 0) : false;
  }
  else
  {
    IgProfAtomic newval = IgProfAtomicInc(&s_enabled);
    return newval > 0;
  }
}

bool IgProf::enabled

(

bool

globally

)

[static]

Check if the profiler is currently enabled.

This function should be called by asynchronous signal handlers to check whether they should record profile data -- not for the actual running where the value of the flag has little useful value, but to make sure no data is gathered after the system has started to close down.

Definition at line 337 of file IgProf.cc.

References s_enabled, s_flagkey, and s_pthreads.

Referenced by dokill(), initThread(), and profileSignalHandler().

{
  if (! globally && s_pthreads)
  {
    IgProfAtomic *flag = (IgProfAtomic *) pthread_getspecific(s_flagkey);
    return flag ? (*flag > 0 && s_enabled > 0) : false;
  }
  else
    return s_enabled > 0;
}

void IgProf::exitThread

(

bool

final

)

[static]

Finalise a thread.

Definition at line 280 of file IgProf.cc.

References i, IgProfTrace::mergeFrom(), N_MODULES, p, s_bufkey, s_bufs, s_mainthread, s_masterbuf, s_pthreads, and thread.

Referenced by doexit(), threadWrapper(), and IgProfExitDump::~IgProfExitDump().

{
  if (! s_pthreads && ! final)
    return;

  pthread_t thread = pthread_self ();
  IgProfTraceAlloc *bufs
    = (thread == s_mainthread ? s_bufs
       : (IgProfTraceAlloc *) pthread_getspecific(s_bufkey));

  for (int i = 0; i < N_MODULES && bufs; ++i)
  {
    IgProfTrace *p = bufs[i].buf;
    if (p)
    {
      s_masterbuf->mergeFrom(*p);
      bufs[i].buf = 0;
      delete p;
    }
  }

  if (thread == s_mainthread)
    s_bufs = 0;
  else
    pthread_setspecific(s_bufkey, 0);

  delete [] bufs;
}

bool IgProf::initialize	(	int *	moduleid,
		void(*)(void)	threadinit,
		bool	perthread
	)			[static]

Initialise the profiler core itself.

Prepares the the program for profiling. Captures various exit points so we generate a dump before the program goes "out". Automatically triggered to run on library load. All profiler modules should invoke this method before doing their own initialisation.

Returns true if profiling is activated in this process.

Definition at line 115 of file IgProf.cc.

References debug(), disable(), e, enable(), IgHook::hook(), i, initBuf(), MAX_FNAME, N_MODULES, options(), IgProfTrace::OptResources, bookConverter::opts, s_activated, s_bufkey, s_bufs, s_clockres, s_dumpflag, s_enabled, s_flagkey, s_initialized, s_mainthread, s_masterbuf, s_masterbufdata, s_outname, s_pthreads, s_symcache, s_symcachedata, target, and threadinits().

Referenced by initialize().

{
  if (! s_initialized)
  {
    s_initialized = true;

    const char *options = IgProf::options();
    if (! options || ! *options)
    {
      IgProf::debug("$IGPROF not set, not profiling this process\n");
      return s_activated = false;
    }

    for (const char *opts = options; *opts; )
    {
      while (*opts == ' ' || *opts == ',')
        ++opts;

      if (! strncmp(opts, "igprof:out='", 12))
      {
        int i = 0;
        opts += 12;
        while (i < MAX_FNAME-1 && *opts && *opts != '\'')
          s_outname[i++] = *opts++;
        s_outname[i] = 0;
      }
      else if (! strncmp(opts, "igprof:dump='", 13))
      {
        int i = 0;
        opts += 13;
        while (i < MAX_FNAME-1 && *opts && *opts != '\'')
          s_dumpflag[i++] = *opts++;
        s_dumpflag[i] = 0;
      }
      else
        opts++;

      while (*opts && *opts != ',' && *opts != ' ')
        opts++;
    }

    if (! s_outname[0])
      sprintf(s_outname, "igprof.%ld", (long) getpid());

    s_bufs = new IgProfTraceAlloc[N_MODULES];
    memset(s_bufs, 0, N_MODULES * sizeof(*s_bufs));

    void *program = dlopen(0, RTLD_NOW);
    if (program && dlsym(program, "pthread_create"))
    {
      s_pthreads = true;
      pthread_key_create(&s_bufkey, 0);
      pthread_key_create(&s_flagkey, 0);
      pthread_setspecific(s_flagkey, new IgProfAtomic(1));
    }
    dlclose(program);

    const char *target = getenv("IGPROF_TARGET");
    s_mainthread = pthread_self();
    if (target && ! strstr(program_invocation_name, target))
    {
      IgProf::debug("Current process not selected for profiling:"
                    " process '%s' does not match '%s'\n",
                    program_invocation_name, target);
      return s_activated = false;
    }

    itimerval precision;
    itimerval interval = { { 0, 10000 }, { 100, 0 } };
    itimerval nullified = { { 0, 0 }, { 0, 0 } };
    setitimer(ITIMER_PROF, &interval, 0);
    getitimer(ITIMER_PROF, &precision);
    setitimer(ITIMER_PROF, &nullified, 0);
    s_clockres = (precision.it_interval.tv_sec
                  + 1e-6 * precision.it_interval.tv_usec);

    IgProf::debug("Activated in %s, timing resolution %f, %s,"
                  " main thread id 0x%lx\n",
                  program_invocation_name, s_clockres,
                  s_pthreads ? "multi-threaded" : "no threads",
                  s_mainthread);
    IgProf::debug("Options: %s\n", options);

    IgHook::hook(doexit_hook_main.raw);
    IgHook::hook(doexit_hook_main2.raw);
    IgHook::hook(dokill_hook_main.raw);
#if __linux
    if (doexit_hook_main.raw.chain)  IgHook::hook(doexit_hook_libc.raw);
    if (doexit_hook_main2.raw.chain) IgHook::hook(doexit_hook_libc2.raw);
    if (dokill_hook_main.raw.chain)  IgHook::hook(dokill_hook_libc.raw);
#endif
    if (s_pthreads)
    {
      IgHook::hook(dopthread_create_hook_main.raw);
#if __linux
      IgHook::hook(dopthread_create_hook_pthread20.raw);
      IgHook::hook(dopthread_create_hook_pthread21.raw);
#endif
    }
    s_activated = true;
    s_enabled = 1;
  }

  if (! s_activated)
    return false;

  if (! moduleid)
    return true;

  IgProf::disable(true);

  if (! s_masterbuf)
  {
    s_masterbuf = new (s_masterbufdata) IgProfTrace(IgProfTrace::OptResources);
    s_symcache = new (s_symcachedata) IgProfSymCache;
  }

  int modid;
  for (modid = 0; modid < N_MODULES; ++modid)
    if (! s_bufs[modid].buf)
    {
      initBuf(s_bufs[modid], perthread);
      *moduleid = modid;
      break;
    }

  if (modid == N_MODULES)
  {
    IgProf::debug("Too many profilers enabled (%d), please"
                  " rebuild IgProf with larger N_MODULES\n",
                  N_MODULES);
    abort ();
  }

  if (threadinit)
    threadinits().push_back(threadinit);

  IgProf::enable(true);
  return true;
}

void IgProf::initThread

(

void

)

[static]

Setup a thread so it can be used in profiling.

This should be called for every thread that will participate in profiling.

Definition at line 264 of file IgProf.cc.

References IgProfTraceAlloc::buf, enabled(), i, initBuf(), N_MODULES, s_bufkey, s_bufs, and s_flagkey.

Referenced by threadWrapper().

{
  IgProfTraceAlloc *bufs = new IgProfTraceAlloc[N_MODULES];
  memset(bufs, 0, N_MODULES * sizeof(*bufs));
  pthread_setspecific(s_bufkey, bufs);

  IgProfAtomic *enabled = new IgProfAtomic(1);
  pthread_setspecific(s_flagkey, enabled);

  for (int i = 0; i < N_MODULES && s_bufs[i].buf; ++i)
    if (s_bufs[i].perthread)
      initBuf(bufs[i], true);
}

bool IgProf::isMultiThreaded

(

void

)

[static]

Return true if the process was linked against threading package.

Definition at line 258 of file IgProf.cc.

References s_pthreads.

Referenced by enableSignalHandler().

{ return s_pthreads; }

const char * IgProf::options

(

void

)

[static]

Get user-provided profiling options.

Definition at line 386 of file IgProf.cc.

References s_options.

Referenced by initialize(), and initialize().

{
  if (! s_options)
    s_options = getenv("IGPROF");
  return s_options;
}

int IgProf::panic	(	const char *	file,
		int	line,
		const char *	func,
		const char *	expr
	)			[static]

Internal assertion helper routine.

Definition at line 395 of file IgProf.cc.

References disable(), i, offset, IgHookTrace::stacktrace(), IgHookTrace::symbol(), and GsfMatrixTools::trace().

{
  IgProf::disable(true);

  fprintf (stderr, "%s: %s:%d: %s: assertion failure: %s\n",
           program_invocation_name, file, line, func, expr);

  void *trace [128];
  int levels = IgHookTrace::stacktrace(trace, 128);
  for (int i = 2; i < levels; ++i)
  {
    const char  *sym = 0;
    const char  *lib = 0;
    int         offset = 0;
    int         liboffset = 0;

    IgHookTrace::symbol(trace[i], sym, lib, offset, liboffset);
    fprintf(stderr, "  %p %s + %d [%s + %d]\n",
            trace[i], sym ? sym : "?", offset, lib ? lib : "?", liboffset);
  }

  // abort();
  return 1;
}

---

The documentation for this class was generated from the following files:

• IgTools/IgProf/src/IgProf.h
• IgTools/IgProf/src/IgProf.cc

---