---

IgProfTrace Class Reference

A resizeable profiler trace buffer. More...

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

Inheritance diagram for IgProfTrace:

List of all members.

Public Types
typedef uintptr_t	Address
	A value that might be an address, usually memory resource.
enum	CounterType { TICK, TICK_PEAK, MAX }
	Counter type. More...
typedef unsigned int	RecordType
	Bitmask of properties the record covers.
typedef uintmax_t	Value
	A large-sized accumulated value for counters.
Public Member Functions
	IgProfTrace (int opts)
	Initialise a trace buffer.
void	mergeFrom (IgProfTrace &other)
void	push (void **stack, int depth, Record *recs, int nrecs)
	Push a call frame and its records into the buffer.
Stack *	stackRoot (void) const
	~IgProfTrace (void)
Static Public Attributes
static const RecordType	ACQUIRE = 2
static const RecordType	COUNT = 1
static const int	MAX_DEPTH = 800
	Deepest supported stack depth.
static const int	OptResources = 1
static const int	OptShared = 2
static const RecordType	RELEASE = 4
Private Member Functions
void	acquireResource (Record &rec, Counter *ctr)
Stack *	childStackNode (Stack *parent, void *address)
void	debugDump (void)
bool	findResource (Record &rec, Resource **&rlink, Resource *&res, CounterDef *def)
	IgProfTrace (IgProfTrace &)
Counter *	initCounter (Counter *&link, CounterDef *def, Stack *frame)
void	mergeFrom (int depth, Stack *frame, void **callstack, Record *recs)
IgProfTrace &	operator= (IgProfTrace &)
void	releaseResource (Record &rec)
void	releaseResource (Resource **rlink, Resource *res)
Static Private Member Functions
static void	debugDumpStack (Stack *s, int depth)
Private Attributes
StackCache *	callcache_
pthread_mutex_t	mutex_
int	options_
void **	poolcur_
void **	poolfirst_
Resource *	resfree_
Resource **	restable_
Stack *	stack_
Classes
struct	Counter
	Counter value. More...
struct	CounterDef
	Counter definition. More...
struct	Record
	Structure used by callers to record values. More...
struct	Resource
	Data for a resource. More...
struct	Stack
	Stack trace node. More...
struct	StackCache
	Structure for call stack cache at the end. More...

---

Detailed Description

A resizeable profiler trace buffer.

Each trace buffer tracks stack traces and their linked profiling counter values. Optionally the buffer may also account resources linked with the counters: tracking which call stack acquired which yet-unreleased resource and the size of the resource.

The buffer owner is responsible for arranging correct handling of the buffer in presence of multiple threads. Buffers that do not track resources can be made thread-local and access need not be guarded. Resource-accounting buffers must be shared among all the threads able to acquire or release the resource -- the resource records are entered into the buffer in the order of the profile events, but there is no other concept of time and therefore it would not be possible to merge buffers from multiple threads into a canonical time order later on. In the rare situation the resources are thread-local the buffer can be thread-local too, otherwise the caller must ensure atomic access to the buffer.

Technically a trace buffer consists of a header and a collection of fixed-size memory pools for the data, and possibly some pools for hash tables. The stack trace and resource counter information is stored starting in one of the arrays. If the buffer tracks resource information, a resource hash points to resource records. The trace buffer grows by allocating more memory pool as needed.

The stack trace is represented as a tree of nodes keyed by call address. Each stack frame has a singly linked list of children, the addresses called from that stack frame. A frame also has a singly linked list of profiling counters associated with the call tree. Each counter may point to a list of resources known to be live within that buffer; the resources linked with the counter form a singly linked list. The root of the stack trace is a null frame: one with zero call address.

The resource hash table provides quick access to the most recent record on each profiled resource. Each hash bin points to a resource; the resources in the same bin form a singly linked list, a list separate from the singly linked list for resources by counter. A live resource points back to the counter owning that resource, permitting that counter to be decremented when the resource is released.

The memory is allocated and the pool otherwise managed by using raw operating system pritimives: anonymous memory mappings. The buffer avoids calling any non-trivial library calls. The buffer implementation is safe for use in asynchronous signals provided the caller avoids re-enter the same buffer from nested signals.

Definition at line 60 of file IgProfTrace.h.

---

Member Typedef Documentation

typedef uintptr_t IgProfTrace::Address

A value that might be an address, usually memory resource.

Definition at line 74 of file IgProfTrace.h.

typedef unsigned int IgProfTrace::RecordType

Bitmask of properties the record covers.

Definition at line 158 of file IgProfTrace.h.

typedef uintmax_t IgProfTrace::Value

A large-sized accumulated value for counters.

Definition at line 77 of file IgProfTrace.h.

---

Member Enumeration Documentation

enum IgProfTrace::CounterType

Counter type.

Enumerator:

TICK
TICK_PEAK
MAX

Definition at line 99 of file IgProfTrace.h.

  {
    TICK,                       //< Ticked cumulative counter.
    TICK_PEAK,                  //< Ticked and keep also the peak value.
    MAX                         //< Maximum-value counter.
  };

---

Constructor & Destructor Documentation

IgProfTrace::IgProfTrace

(

int

opts

)

Initialise a trace buffer.

Definition at line 12 of file IgProfTrace.cc.

References IgProfBuffer::allocateRaw(), IgProfBuffer::allocateSpace(), callcache_, IGPROF_ASSERT, MAX_DEPTH, mutex_, OptResources, OptShared, resfree_, RESOURCE_HASH, restable_, and stack_.

  : options_(opts),
    restable_(0),
    callcache_(0),
    resfree_(0),
    stack_(0)
{
  if (opts & OptShared)
    pthread_mutex_init(&mutex_, 0);

  // If we are tracking resources, allocate a separate slab of memory
  // the resource hash table.  This has to be big for large memory
  // applications, so it's ok to allocate it separately.  Note the
  // memory obtained here starts out as zeroed out.
  if (opts & OptResources)
    restable_ = (Resource **) allocateRaw(RESOURCE_HASH*sizeof(Resource *));
  
  // Allocate the call cache next.
  callcache_ = (StackCache *) allocateSpace(MAX_DEPTH*sizeof(StackCache));

  // Allocate the stack root node.
  stack_ = allocate<Stack>();

  // The resource free list starts out empty.
  IGPROF_ASSERT(! resfree_);
}

IgProfTrace::~IgProfTrace

(

void

)

Definition at line 39 of file IgProfTrace.cc.

References RESOURCE_HASH, restable_, and IgProfBuffer::unallocateRaw().

{
  if (restable_)
    unallocateRaw(restable_, RESOURCE_HASH*sizeof(Resource *));
}

IgProfTrace::IgProfTrace

(

IgProfTrace &

)

[private]

---

Member Function Documentation

void IgProfTrace::acquireResource	(	Record &	rec,
		Counter *	ctr
	)			[private]

Definition at line 174 of file IgProfTrace.cc.

References IgProfTrace::Record::amount, IgProfTrace::Resource::counter, IgProf::debug(), IgProfTrace::Record::def, IgProfTrace::Resource::def, IgProfTrace::Counter::def, findResource(), IgProfTrace::Counter::frame, IGPROF_ASSERT, IgProfTrace::CounterDef::name, IgProfTrace::Resource::nexthash, IgProfTrace::Resource::nextlive, offset, IgProfTrace::Resource::prevlive, releaseResource(), res, resfree_, IgProfTrace::Record::resource, IgProfTrace::Resource::resource, IgProfTrace::Counter::resources, s, IgProfTrace::Resource::size, and IgHookTrace::symbol().

Referenced by push().

{
  IGPROF_ASSERT(ctr);

  // Locate the resource in the hash table.
  Resource  **rlink;
  Resource  *res = 0;
  if (findResource(rec, rlink, res, ctr->def))
  {
    IgProf::debug("New %s resource 0x%lx of %ju bytes was never freed in %p\n",
                  ctr->def->name, rec.resource, res->size, this);
#if IGPROF_DEBUG
    int depth = 0;
    for (Stack *s = ctr->frame; s; s = s->parent)
    {
      const char  *sym = 0;
      const char  *lib = 0;
      int         offset = 0;
      int         liboffset = 0;

      IgHookTrace::symbol(s->address, sym, lib, offset, liboffset);
      IgProf::debug ("  [%u] %10p %s + %d [%s + %d]\n", ++depth, s->address,
                     sym ? sym : "?", offset, lib ? lib : "?", liboffset);
    }
#endif

    // Release the resource, then proceed as if we hadn't found it.
    releaseResource(rlink, res);
  }

  // It wasn't found, insert into the lists as per class documentation.
  if ((res = resfree_))
    resfree_ = res->nextlive;
  else
    res = allocate<Resource>();
  res->resource = rec.resource;
  res->size = rec.amount;
  res->nexthash = *rlink;
  res->prevlive = 0;
  res->nextlive = ctr->resources;
  res->counter = ctr;
  res->def = rec.def;
  ctr->resources = *rlink = res;
  if (res->nextlive)
    res->nextlive->prevlive = res;
}

IgProfTrace::Stack * IgProfTrace::childStackNode	(	Stack *	parent,
		void *	address
	)			[private]

Definition at line 46 of file IgProfTrace.cc.

References IgProfTrace::Stack::address, IgProfTrace::Stack::children, IgProfTrace::Stack::counters, k, and IgProfTrace::Stack::sibling.

Referenced by push().

{
  // Search for the child's call address in the child stack frames.
  Stack **kid = &parent->children;
  while (*kid)
  {
    Stack *k = *kid;
    if (k->address == address)
      return k;

    if ((char *) k->address > (char *) address)
      break;

    kid = &k->sibling;
  }

  // Didn't find it, add a new child in address-sorted order.
  Stack *next = *kid;
  Stack *k = *kid = allocate<Stack>();
  k->address = address;
#if IGPROF_DEBUG
  k->parent = parent;
#endif
  k->sibling = next;
  k->children = 0;
  k->counters = 0;

  return k;
}

void IgProfTrace::debugDump

(

void

)

[private]

Definition at line 417 of file IgProfTrace.cc.

References callcache_, debugDumpStack(), options_, restable_, and stack_.

{
  fprintf (stderr, "TRACE BUFFER %p:\n", this);
  fprintf (stderr, " OPTIONS:   %d\n", options_);
  fprintf (stderr, " RESTABLE:  %p\n", restable_);
  fprintf (stderr, " CALLCACHE: %p\n", callcache_);

  debugDumpStack(stack_, 0);
  // debugDumpResources();
}

void IgProfTrace::debugDumpStack	(	Stack *	s,
		int	depth
	)			[static, private]

Definition at line 392 of file IgProfTrace.cc.

References IgProfTrace::Stack::address, c, IgProfTrace::Stack::children, IgProfTrace::Stack::counters, INDENT, r, and IgProfTrace::Stack::sibling.

Referenced by debugDump().

{
  INDENT(2*depth);
  fprintf(stderr, "STACK %d frame=%p addr=%p next=%p kids=%p\n",
          depth, s, s->address, s->sibling, s->children);

  for (Counter *c = s->counters; c; c = c->next)
  {
    INDENT(2*depth+1);
    fprintf(stderr, "COUNTER ctr=%p %s %ju %ju %ju\n",
            c, c->def->name, c->ticks, c->value, c->peak);

    for (Resource *r = c->resources; r; r = r->nextlive)
    {
      INDENT(2*depth+2);
      fprintf(stderr, "RESOURCE res=%p (prev=%p next=%p) %ju %ju\n",
              r, r->prevlive, r->nextlive, r->resource, r->size);
    }
  }

  for (Stack *kid = s->children; kid; kid = kid->sibling)
    debugDumpStack(kid, depth+1);
}

bool IgProfTrace::findResource	(	Record &	rec,
		Resource **&	rlink,
		Resource *&	res,
		CounterDef *	def
	)			[inline, private]

Definition at line 92 of file IgProfTrace.cc.

References IgProfBuffer::hash(), r, IgProfTrace::Record::resource, RESOURCE_HASH, and restable_.

Referenced by acquireResource(), and releaseResource().

{
  // Locate the resource in the hash table.
  rlink = &restable_[hash(rec.resource) & (RESOURCE_HASH-1)];

  while (Resource *r = *rlink)
  {
    if (r->resource == rec.resource && r->def == def)
    {
      res = r;
      return true;
    }
    if (r->resource > rec.resource)
      return false;
    rlink = &r->nexthash;
  }

  return false;
}

IgProfTrace::Counter * IgProfTrace::initCounter	(	Counter *&	link,
		CounterDef *	def,
		Stack *	frame
	)			[inline, private]

Definition at line 77 of file IgProfTrace.cc.

References IgProfTrace::Counter::def, IgProfTrace::Counter::frame, IgProfTrace::Counter::next, IgProfTrace::Counter::peak, IgProfTrace::Counter::resources, IgProfTrace::Counter::ticks, and IgProfTrace::Counter::value.

Referenced by push().

{
  Counter *ctr = allocate<Counter>();
  ctr->ticks = 0;
  ctr->value = 0;
  ctr->peak = 0;
  ctr->def = def;
  ctr->frame = frame;
  ctr->next = 0;
  ctr->resources = 0;
  link = ctr;
  return ctr;
}

void IgProfTrace::mergeFrom	(	int	depth,
		Stack *	frame,
		void **	callstack,
		Record *	recs
	)			[private]

Definition at line 320 of file IgProfTrace.cc.

References ACQUIRE, IgProfTrace::Stack::address, IgProfTrace::Record::amount, c, IgProfTrace::Stack::children, COUNT, IgProfTrace::Stack::counters, IgProfTrace::Record::def, IGPROF_ASSERT, MAX_DEPTH, MERGE_RECS, mergeFrom(), push(), r, RELEASE, IgProfTrace::Record::resource, IgProfTrace::Stack::sibling, TICK_PEAK, IgProfTrace::Record::ticks, and IgProfTrace::Record::type.

{
  // Process counters at this call stack level.
  int rec = 0;
  for (Counter *c = frame->counters; c; c = c->next)
  {
    if (c->ticks && ! c->resources)
    {
      if (rec == MERGE_RECS)
      {
        push(callstack, depth, recs, rec);
        rec = 0;
      }

      recs[rec].type = COUNT;
      recs[rec].def = c->def;
      recs[rec].amount = c->value;
      recs[rec].ticks = c->ticks;
      ++rec;
    }
    else if (c->ticks)
    {
      for (Resource *r = c->resources; r; r = r->nextlive)
      {
        if (rec == MERGE_RECS)
        {
          push(callstack, depth, recs, rec);
          rec = 0;
        }

        recs[rec].type = COUNT | ACQUIRE;
        recs[rec].def = c->def;
        recs[rec].amount = r->size;
        recs[rec].ticks = 1;
        recs[rec].resource = r->resource;
        ++rec;
      }
    }

    // Adjust the peak counter if necessary.
    if (c->def->type == TICK_PEAK && c->peak > c->value)
    {
      if (rec == MERGE_RECS)
      {
        push(callstack, depth, recs, rec);
        rec = 0;
      }

      recs[rec].type = COUNT | ACQUIRE | RELEASE;
      recs[rec].def = c->def;
      recs[rec].amount = c->peak - c->value;
      recs[rec].ticks = 1;
      recs[rec].resource = ~((Address) 0);
      ++rec;
    }
  }

  if (rec)
    push(callstack, depth, recs, rec);

  // Merge the children.
  for (frame = frame->children; frame; frame = frame->sibling)
  {
    IGPROF_ASSERT(depth < MAX_DEPTH);
    callstack[-1] = frame->address;
    mergeFrom(depth+1, frame, &callstack[-1], recs);
  }
}

void IgProfTrace::mergeFrom

(

IgProfTrace &

other

)

Definition at line 299 of file IgProfTrace.cc.

References IgProfTrace::Stack::address, MAX_DEPTH, MERGE_RECS, mutex_, options_, OptShared, and stack_.

Referenced by IgProf::exitThread(), and mergeFrom().

{
  if (options_ & OptShared)
    pthread_mutex_lock(&mutex_);
  if (other.options_ & OptShared)
    pthread_mutex_lock(&other.mutex_);

  // Scan stack tree and insert each call stack, including resources.
  Record recs[MERGE_RECS];
  void   *callstack[MAX_DEPTH+1];

  callstack[MAX_DEPTH] = stack_->address; // null really
  mergeFrom(0, other.stack_, &callstack[MAX_DEPTH], recs);

  if (other.options_ & OptShared)
    pthread_mutex_unlock(&other.mutex_);
  if (options_ & OptShared)
    pthread_mutex_unlock(&mutex_);
}

IgProfTrace& IgProfTrace::operator=

(

IgProfTrace &

)

[private]

void IgProfTrace::push	(	void **	stack,
		int	depth,
		Record *	recs,
		int	nrecs
	)

Push a call frame and its records into the buffer.

Definition at line 223 of file IgProfTrace.cc.

References ACQUIRE, acquireResource(), IgProfTrace::StackCache::address, IgProfTrace::Record::amount, c, callcache_, childStackNode(), COUNT, IgProfTrace::Stack::counters, IgProfTrace::Record::def, IgProfTrace::Counter::def, IgProfTrace::StackCache::frame, i, initCounter(), MAX, MAX_DEPTH, mutex_, IgProfTrace::Counter::next, options_, OptShared, IgProfTrace::Counter::peak, RELEASE, releaseResource(), stack_, TICK, TICK_PEAK, IgProfTrace::Record::ticks, IgProfTrace::Counter::ticks, IgProfTrace::CounterDef::type, IgProfTrace::Record::type, TrackValidation_HighPurity_cff::valid, and IgProfTrace::Counter::value.

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

{
  if (options_ & OptShared)
    pthread_mutex_lock(&mutex_);

  // Make sure we operate on non-negative depth.  This allows callers
  // to do strip off call tree layers without checking for sufficient
  // depth themselves.
  if (depth < 0)
    depth = 0;

  // Look up call stack in the cache.
  StackCache    *cache = callcache_;
  Stack         *frame = stack_;

  for (int i = 0, valid = 1; i < depth && i < MAX_DEPTH; ++i)
  {
    void *address = stack[depth-i-1];
    if (valid && cache[i].address == address)
      frame = cache[i].frame;
    else
    {
      // Look up this call stack child, then cache result.
      frame = childStackNode(frame, address);
      cache [i].address = address;
      cache [i].frame = frame;
      valid = 0;
    }
  }

  // OK, we now have our final call stack node.  Update its counters
  // and the resource allocations as defined by "recs".
  for (int i = 0; i < nrecs; ++i)
  {
    Counter **ctr = 0;
    Counter *c = 0;

    // If it's a release acquisition or normal tick, update counter.
    if (recs[i].type & (COUNT | ACQUIRE))
    {
      // Locate the counter.
      ctr = &frame->counters;
      while (*ctr && (*ctr)->def != recs[i].def)
        ctr = &(*ctr)->next;

      // If not found, add it.
      c = *ctr;
      if (! c || c->def != recs[i].def)
        c = initCounter(*ctr, recs[i].def, frame);

      // Tick the counter.
      if (recs[i].def->type == TICK || recs[i].def->type == TICK_PEAK)
        c->value += recs[i].amount;
      else if (recs[i].def->type == MAX && c->value < recs[i].amount)
        c->value = recs[i].amount;

      if (recs[i].def->type == TICK_PEAK && c->value > c->peak)
        c->peak = c->value;

      c->ticks += recs[i].ticks;
    }

    // Handle resource record for acquisition.
    if (recs[i].type & ACQUIRE)
      acquireResource(recs[i], c);

    // Handle resource record for release.  Call stack is empty here.
    if (recs[i].type & RELEASE)
      releaseResource(recs[i]);
  }

  if (options_ & OptShared)
    pthread_mutex_unlock(&mutex_);
}

void IgProfTrace::releaseResource

(

Record &

rec

)

[private]

Definition at line 160 of file IgProfTrace.cc.

References IgProfTrace::Record::def, findResource(), releaseResource(), and res.

{
  // Locate the resource in the hash table.
  Resource  **rlink;
  Resource  *res = 0;
  if (! findResource(rec, rlink, res, rec.def))
    // Not found, we missed the allocation, ignore this release.
    return;
  else
    // Found, actually release it.
    releaseResource(rlink, res);
}

void IgProfTrace::releaseResource	(	Resource **	rlink,
		Resource *	res
	)			[inline, private]

Definition at line 116 of file IgProfTrace.cc.

References IgProfTrace::Resource::counter, IGPROF_ASSERT, IgProfTrace::Resource::nexthash, IgProfTrace::Resource::nextlive, IgProfTrace::Resource::prevlive, resfree_, IgProfTrace::Counter::resources, IgProfTrace::Resource::size, IgProfTrace::Counter::ticks, and IgProfTrace::Counter::value.

Referenced by acquireResource(), push(), and releaseResource().

{
  IGPROF_ASSERT(res);
  IGPROF_ASSERT(rlink);
  IGPROF_ASSERT(res->counter);
  IGPROF_ASSERT(res->counter != &FREED);
  IGPROF_ASSERT(res->counter->resources);
  IGPROF_ASSERT(*rlink == res);

  // Deduct the resource from the counter.
  Counter *ctr = res->counter;
  IGPROF_ASSERT(ctr->value >= res->size);
  IGPROF_ASSERT(ctr->ticks > 0);
  ctr->value -= res->size;
  ctr->ticks--;

  // Unchain from hash and counter lists.
  *rlink = res->nexthash;

  if (Resource *prev = res->prevlive)
  {
    IGPROF_ASSERT(prev->nextlive == res);
    prev->nextlive = res->nextlive;
  }
  else
  {
    IGPROF_ASSERT(ctr->resources == res);
    ctr->resources = res->nextlive;
  }

  if (Resource *next = res->nextlive)
  {
    IGPROF_ASSERT(next->prevlive == res);
    next->prevlive = res->prevlive;
  }

  // Put it on free list.
  memset (res, 0, sizeof (*res));
  res->nextlive = resfree_;
  res->counter = &FREED;
  resfree_ = res;
}

IgProfTrace::Stack * IgProfTrace::stackRoot

(

void

)

const [inline]

Definition at line 217 of file IgProfTrace.h.

References stack_.

Referenced by IgProf::dump().

{ return stack_; }

---

Member Data Documentation

const RecordType IgProfTrace::ACQUIRE = 2 [static]

Definition at line 160 of file IgProfTrace.h.

Referenced by __attribute__(), mergeFrom(), and push().

StackCache* IgProfTrace::callcache_ [private]

Definition at line 204 of file IgProfTrace.h.

Referenced by debugDump(), IgProfTrace(), and push().

const RecordType IgProfTrace::COUNT = 1 [static]

Definition at line 159 of file IgProfTrace.h.

Referenced by __attribute__(), mergeFrom(), profileSignalHandler(), and push().

const int IgProfTrace::MAX_DEPTH = 800 [static]

Deepest supported stack depth.

Definition at line 71 of file IgProfTrace.h.

Referenced by __attribute__(), IgProfTrace(), mergeFrom(), profileSignalHandler(), and push().

pthread_mutex_t IgProfTrace::mutex_ [private]

Definition at line 199 of file IgProfTrace.h.

Referenced by IgProfTrace(), mergeFrom(), and push().

int IgProfTrace::options_ [private]

Definition at line 200 of file IgProfTrace.h.

Referenced by debugDump(), mergeFrom(), and push().

const int IgProfTrace::OptResources = 1 [static]

Definition at line 174 of file IgProfTrace.h.

Referenced by IgProfTrace(), initBuf(), and IgProf::initialize().

const int IgProfTrace::OptShared = 2 [static]

Definition at line 175 of file IgProfTrace.h.

Referenced by IgProfTrace(), initBuf(), mergeFrom(), and push().

void** IgProfTrace::poolcur_ [private]

Reimplemented from IgProfBuffer.

Definition at line 202 of file IgProfTrace.h.

void** IgProfTrace::poolfirst_ [private]

Reimplemented from IgProfBuffer.

Definition at line 201 of file IgProfTrace.h.

const RecordType IgProfTrace::RELEASE = 4 [static]

Definition at line 161 of file IgProfTrace.h.

Referenced by mergeFrom(), push(), and remove().

Resource* IgProfTrace::resfree_ [private]

Definition at line 205 of file IgProfTrace.h.

Referenced by acquireResource(), IgProfTrace(), and releaseResource().

Resource** IgProfTrace::restable_ [private]

Definition at line 203 of file IgProfTrace.h.

Referenced by debugDump(), findResource(), IgProfTrace(), and ~IgProfTrace().

Stack* IgProfTrace::stack_ [private]

Definition at line 206 of file IgProfTrace.h.

Referenced by debugDump(), IgProfTrace(), mergeFrom(), push(), and stackRoot().

---

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

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

---