tools/jprof/leaky.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "leaky.h"
#include "intcnt.h"

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#ifndef NTO
#  include <getopt.h>
#endif
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef NTO
#  include <mem.h>
#endif

#ifndef FALSE
#  define FALSE 0
#endif
#ifndef TRUE
#  define TRUE 1
#endif

static const u_int DefaultBuckets = 10007;  // arbitrary, but prime
static const u_int MaxBuckets = 1000003;    // arbitrary, but prime

//----------------------------------------------------------------------

int main(int argc, char** argv) {
  leaky* l = new leaky;

  l->initialize(argc, argv);
  l->outputfd = stdout;

  for (int i = 0; i < l->numLogFiles; i++) {
    if (l->output_dir || l->numLogFiles > 1) {
      char name[2048];  // XXX fix
      if (l->output_dir)
        snprintf(name, sizeof(name), "%s/%s.html", l->output_dir,
                 argv[l->logFileIndex + i]);
      else
        snprintf(name, sizeof(name), "%s.html", argv[l->logFileIndex + i]);

      fprintf(stderr, "opening %s\n", name);
      l->outputfd = fopen(name, "w");
      // if an error we won't process the file
    }
    if (l->outputfd) {  // paranoia
      l->open(argv[l->logFileIndex + i]);

      if (l->outputfd != stderr) {
        fclose(l->outputfd);
        l->outputfd = nullptr;
      }
    }
  }

  return 0;
}

char* htmlify(const char* in) {
  const char* p = in;
  char *out, *q;
  int n = 0;
  size_t newlen;

  // Count the number of '<' and '>' in the input.
  while ((p = strpbrk(p, "<>"))) {
    ++n;
    ++p;
  }

  // Knowing the number of '<' and '>', we can calculate the space
  // needed for the output string.
  newlen = strlen(in) + n * 3 + 1;
  out = new char[newlen];

  // Copy the input to the output, with substitutions.
  p = in;
  q = out;
  do {
    if (*p == '<') {
      strcpy(q, "&lt;");
      q += 4;
    } else if (*p == '>') {
      strcpy(q, "&gt;");
      q += 4;
    } else {
      *q++ = *p;
    }
    p++;
  } while (*p);
  *q = '\0';

  return out;
}

leaky::leaky() {
  applicationName = nullptr;
  progFile = nullptr;

  quiet = true;
  showAddress = false;
  showThreads = false;
  stackDepth = 100000;
  onlyThread = 0;
  cleo = false;

  mappedLogFile = -1;
  firstLogEntry = lastLogEntry = 0;

  sfd = -1;
  externalSymbols = 0;
  usefulSymbols = 0;
  numExternalSymbols = 0;
  lowestSymbolAddr = 0;
  highestSymbolAddr = 0;

  loadMap = nullptr;

  collect_last = false;
  collect_start = -1;
  collect_end = -1;
}

leaky::~leaky() {}

void leaky::usageError() {
  fprintf(stderr,
          "Usage: %s [-v] [-t] [-e exclude] [-i include] [-s stackdepth] "
          "[--last] [--all] [--start n [--end m]] [--cleo] [--output-dir dir] "
          "prog log [log2 ...]\n",
          (char*)applicationName);
  fprintf(
      stderr,
      "\t-v: verbose\n"
      "\t-t | --threads: split threads\n"
      "\t--only-thread n: only profile thread N\n"
      "\t-i include-id: stack must include specified id\n"
      "\t-e exclude-id: stack must NOT include specified id\n"
      "\t-s stackdepth: Limit depth looked at from captured stack frames\n"
      "\t--last: only profile the last capture section\n"
      "\t--start n [--end m]: profile n to m (or end) capture sections\n"
      "\t--cleo: format output for 'cleopatra' display\n"
      "\t--output-dir dir: write output files to dir\n"
      "\tIf there's one log, output goes to stdout unless --output-dir is set\n"
      "\tIf there are more than one log, output files will be named with .html "
      "added\n");
  exit(-1);
}

static struct option longopts[] = {
    {"threads", 0, nullptr, 't'},    {"only-thread", 1, nullptr, 'T'},
    {"last", 0, nullptr, 'l'},       {"start", 1, nullptr, 'x'},
    {"end", 1, nullptr, 'n'},        {"cleo", 0, nullptr, 'c'},
    {"output-dir", 1, nullptr, 'd'}, {nullptr, 0, nullptr, 0},
};

void leaky::initialize(int argc, char** argv) {
  applicationName = argv[0];
  applicationName = strrchr(applicationName, '/');
  if (!applicationName) {
    applicationName = argv[0];
  } else {
    applicationName++;
  }

  int arg;
  int errflg = 0;
  int longindex = 0;

  onlyThread = 0;
  output_dir = nullptr;
  cleo = false;

  // XXX tons of cruft here left over from tracemalloc
  // XXX The -- options shouldn't need short versions, or they should be
  // documented
  while (((arg = getopt_long(argc, argv, "adEe:gh:i:r:Rs:tT:qvx:ln:", longopts,
                             &longindex)) != -1)) {
    switch (arg) {
      case '?':
      default:
        fprintf(stderr, "error: unknown option %c\n", optopt);
        errflg++;
        break;
      case 'a':
        break;
      case 'A':  // not implemented
        showAddress = true;
        break;
      case 'c':
        cleo = true;
        break;
      case 'd':
        output_dir = optarg;  // reference to an argv pointer
        break;
      case 'R':
        break;
      case 'e':
        exclusions.add(optarg);
        break;
      case 'g':
        break;
      case 'r':  // not implemented
        roots.add(optarg);
        if (!includes.IsEmpty()) {
          errflg++;
        }
        break;
      case 'i':
        includes.add(optarg);
        if (!roots.IsEmpty()) {
          errflg++;
        }
        break;
      case 'h':
        break;
      case 's':
        stackDepth = atoi(optarg);
        if (stackDepth < 2) {
          stackDepth = 2;
        }
        break;
      case 'x':
        // --start
        collect_start = atoi(optarg);
        break;
      case 'n':
        // --end
        collect_end = atoi(optarg);
        break;
      case 'l':
        // --last
        collect_last = true;
        break;
      case 'q':
        break;
      case 'v':
        quiet = !quiet;
        break;
      case 't':
        showThreads = true;
        break;
      case 'T':
        showThreads = true;
        onlyThread = atoi(optarg);
        break;
    }
  }
  if (errflg || ((argc - optind) < 2)) {
    usageError();
  }
  progFile = argv[optind++];
  logFileIndex = optind;
  numLogFiles = argc - optind;
  if (!quiet) fprintf(stderr, "numlogfiles = %d\n", numLogFiles);
}

static void* mapFile(int fd, u_int flags, off_t* sz) {
  struct stat sb;
  if (fstat(fd, &sb) < 0) {
    perror("fstat");
    exit(-1);
  }
  void* base = mmap(0, (int)sb.st_size, flags, MAP_PRIVATE, fd, 0);
  if (!base) {
    perror("mmap");
    exit(-1);
  }
  *sz = sb.st_size;
  return base;
}

void leaky::LoadMap() {
  malloc_map_entry mme;
  char name[1000];

  if (!loadMap) {
    // all files use the same map
    int fd = ::open(M_MAPFILE, O_RDONLY);
    if (fd < 0) {
      perror("open: " M_MAPFILE);
      exit(-1);
    }
    for (;;) {
      int nb = read(fd, &mme, sizeof(mme));
      if (nb != sizeof(mme)) break;
      nb = read(fd, name, mme.nameLen);
      if (nb != (int)mme.nameLen) break;
      name[mme.nameLen] = 0;
      if (!quiet) {
        fprintf(stderr, "%s @ %lx\n", name, mme.address);
      }

      LoadMapEntry* lme = new LoadMapEntry;
      lme->address = mme.address;
      lme->name = strdup(name);
      lme->next = loadMap;
      loadMap = lme;
    }
    close(fd);
  }
}

void leaky::open(char* logFile) {
  int threadArray[100];  // should auto-expand
  int last_thread = -1;
  int numThreads = 0;
  int section = -1;
  bool collecting = false;

  LoadMap();

  setupSymbols(progFile);

  // open up the log file
  if (mappedLogFile) ::close(mappedLogFile);

  mappedLogFile = ::open(logFile, O_RDONLY);
  if (mappedLogFile < 0) {
    perror("open");
    exit(-1);
  }
  off_t size;
  firstLogEntry = (malloc_log_entry*)mapFile(mappedLogFile, PROT_READ, &size);
  lastLogEntry = (malloc_log_entry*)((char*)firstLogEntry + size);

  if (!collect_last || collect_start < 0) {
    collecting = true;
  }

  // First, restrict it to the capture sections specified (all, last, start/end)
  // This loop walks through all the call stacks we recorded
  for (malloc_log_entry* lep = firstLogEntry; lep < lastLogEntry;
       lep = reinterpret_cast<malloc_log_entry*>(&lep->pcs[lep->numpcs])) {
    if (lep->flags & JP_FIRST_AFTER_PAUSE) {
      section++;
      if (collect_last) {
        firstLogEntry = lep;
        numThreads = 0;
        collecting = true;
      }
      if (collect_start == section) {
        collecting = true;
        firstLogEntry = lep;
      }
      if (collect_end == section) {
        collecting = false;
        lastLogEntry = lep;
      }
      if (!quiet)
        fprintf(stderr, "New section %d: first=%p, last=%p, collecting=%d\n",
                section, (void*)firstLogEntry, (void*)lastLogEntry, collecting);
    }

    // Capture thread info at the same time

    // Find all the threads captured

    // pthread/linux docs say the signal can be delivered to any thread in
    // the process.  In practice, it appears in Linux that it's always
    // delivered to the thread that called setitimer(), and each thread can
    // have a separate itimer.  There's a support library for gprof that
    // overlays pthread_create() to set timers in any threads you spawn.
    if (showThreads && collecting) {
      if (lep->thread != last_thread) {
        int i;
        for (i = 0; i < numThreads; i++) {
          if (lep->thread == threadArray[i]) break;
        }
        if (i == numThreads &&
            i < (int)(sizeof(threadArray) / sizeof(threadArray[0]))) {
          threadArray[i] = lep->thread;
          numThreads++;
          if (!quiet) fprintf(stderr, "new thread %d\n", lep->thread);
        }
      }
    }
  }
  if (!quiet)
    fprintf(stderr,
            "Done collecting: sections %d: first=%p, last=%p, numThreads=%d\n",
            section, (void*)firstLogEntry, (void*)lastLogEntry, numThreads);

  if (!cleo) {
    fprintf(outputfd,
            "<html><head><title>Jprof Profile Report</title></head><body>\n");
    fprintf(outputfd, "<h1><center>Jprof Profile Report</center></h1>\n");
  }

  if (showThreads) {
    fprintf(stderr, "Num threads %d\n", numThreads);

    if (!cleo) {
      fprintf(outputfd, "<hr>Threads:<p><pre>\n");
      for (int i = 0; i < numThreads; i++) {
        fprintf(outputfd, "   <a href=\"#thread_%d\">%d</a>  ", threadArray[i],
                threadArray[i]);
        if ((i + 1) % 10 == 0) fprintf(outputfd, "<br>\n");
      }
      fprintf(outputfd, "</pre>");
    }

    for (int i = 0; i < numThreads; i++) {
      if (!onlyThread || onlyThread == threadArray[i]) analyze(threadArray[i]);
    }
  } else {
    analyze(0);
  }

  if (!cleo) fprintf(outputfd, "</pre></body></html>\n");
}

//----------------------------------------------------------------------

static int symbolOrder(void const* a, void const* b) {
  Symbol const** ap = (Symbol const**)a;
  Symbol const** bp = (Symbol const**)b;
  return (*ap)->address == (*bp)->address
             ? 0
             : ((*ap)->address > (*bp)->address ? 1 : -1);
}

void leaky::ReadSharedLibrarySymbols() {
  LoadMapEntry* lme = loadMap;
  while (nullptr != lme) {
    ReadSymbols(lme->name, lme->address);
    lme = lme->next;
  }
}

void leaky::setupSymbols(const char* fileName) {
  if (usefulSymbols == 0) {
    // only read once!

    // Read in symbols from the program
    ReadSymbols(fileName, 0);

    // Read in symbols from the .so's
    ReadSharedLibrarySymbols();

    if (!quiet) {
      fprintf(stderr, "A total of %d symbols were loaded\n", usefulSymbols);
    }

    // Now sort them
    qsort(externalSymbols, usefulSymbols, sizeof(Symbol*), symbolOrder);
    lowestSymbolAddr = externalSymbols[0]->address;
    highestSymbolAddr = externalSymbols[usefulSymbols - 1]->address;
  }
}

// Binary search the table, looking for a symbol that covers this
// address.
int leaky::findSymbolIndex(u_long addr) {
  u_int base = 0;
  u_int limit = usefulSymbols - 1;
  Symbol** end = &externalSymbols[limit];
  while (base <= limit) {
    u_int midPoint = (base + limit) >> 1;
    Symbol** sp = &externalSymbols[midPoint];
    if (addr < (*sp)->address) {
      if (midPoint == 0) {
        return -1;
      }
      limit = midPoint - 1;
    } else {
      if (sp + 1 < end) {
        if (addr < (*(sp + 1))->address) {
          return midPoint;
        }
      } else {
        return midPoint;
      }
      base = midPoint + 1;
    }
  }
  return -1;
}

Symbol* leaky::findSymbol(u_long addr) {
  int idx = findSymbolIndex(addr);

  if (idx < 0) {
    return nullptr;
  } else {
    return externalSymbols[idx];
  }
}

//----------------------------------------------------------------------

bool leaky::excluded(malloc_log_entry* lep) {
  if (exclusions.IsEmpty()) {
    return false;
  }

  char** pcp = &lep->pcs[0];
  u_int n = lep->numpcs;
  for (u_int i = 0; i < n; i++, pcp++) {
    Symbol* sp = findSymbol((u_long)*pcp);
    if (sp && exclusions.contains(sp->name)) {
      return true;
    }
  }
  return false;
}

bool leaky::included(malloc_log_entry* lep) {
  if (includes.IsEmpty()) {
    return true;
  }

  char** pcp = &lep->pcs[0];
  u_int n = lep->numpcs;
  for (u_int i = 0; i < n; i++, pcp++) {
    Symbol* sp = findSymbol((u_long)*pcp);
    if (sp && includes.contains(sp->name)) {
      return true;
    }
  }
  return false;
}

//----------------------------------------------------------------------

void leaky::displayStackTrace(FILE* out, malloc_log_entry* lep) {
  char** pcp = &lep->pcs[0];
  u_int n = (lep->numpcs < stackDepth) ? lep->numpcs : stackDepth;
  for (u_int i = 0; i < n; i++, pcp++) {
    u_long addr = (u_long)*pcp;
    Symbol* sp = findSymbol(addr);
    if (sp) {
      fputs(sp->name, out);
      if (showAddress) {
        fprintf(out, "[%p]", (char*)addr);
      }
    } else {
      fprintf(out, "<%p>", (char*)addr);
    }
    fputc(' ', out);
  }
  fputc('\n', out);
}

void leaky::dumpEntryToLog(malloc_log_entry* lep) {
  printf("%ld\t", lep->delTime);
  printf(" --> ");
  displayStackTrace(outputfd, lep);
}

void leaky::generateReportHTML(FILE* fp, int* countArray, int count,
                               int thread) {
  fprintf(fp, "<center>");
  if (showThreads) {
    fprintf(fp, "<hr><A NAME=thread_%d><b>Thread: %d</b></A><p>", thread,
            thread);
  }
  fprintf(
      fp,
      "<A href=#flat_%d>flat</A><b> | </b><A href=#hier_%d>hierarchical</A>",
      thread, thread);
  fprintf(fp, "</center><P><P><P>\n");

  int totalTimerHits = count;
  int* rankingTable = new int[usefulSymbols];

  for (int cnt = usefulSymbols; --cnt >= 0; rankingTable[cnt] = cnt)
    ;

  // Drat.  I would use ::qsort() but I would need a global variable and my
  // intro-pascal professor threatened to flunk anyone who used globals.
  // She damaged me for life :-) (That was 1986.  See how much influence
  // she had.  I don't remember her name but I always feel guilty about globals)

  // Shell Sort. 581130733 is the max 31 bit value of h = 3h+1
  int mx, i, h;
  for (mx = usefulSymbols / 9, h = 581130733; h > 0; h /= 3) {
    if (h < mx) {
      for (i = h - 1; i < usefulSymbols; i++) {
        int j, tmp = rankingTable[i], val = countArray[tmp];
        for (j = i; (j >= h) && (countArray[rankingTable[j - h]] < val);
             j -= h) {
          rankingTable[j] = rankingTable[j - h];
        }
        rankingTable[j] = tmp;
      }
    }
  }

  // Ok, We are sorted now.  Let's go through the table until we get to
  // functions that were never called.  Right now we don't do much inside
  // this loop.  Later we can get callers and callees into it like gprof
  // does
  fprintf(fp,
          "<h2><A NAME=hier_%d></A><center><a "
          "href=\"http://dxr.mozilla.org/mozilla-central/source/tools/jprof/"
          "README.html#hier\">Hierarchical Profile</a></center></h2><hr>\n",
          thread);
  fprintf(fp, "<pre>\n");
  fprintf(fp, "%6s %6s         %4s      %s\n", "index", "Count", "Hits",
          "Function Name");

  for (i = 0; i < usefulSymbols && countArray[rankingTable[i]] > 0; i++) {
    Symbol** sp = &externalSymbols[rankingTable[i]];

    (*sp)->cntP.printReport(fp, this, rankingTable[i], totalTimerHits);

    char* symname = htmlify((*sp)->name);
    fprintf(fp,
            "%6d %6d (%3.1f%%)%s <a name=%d>%8d (%3.1f%%)</a>%s <b>%s</b>\n",
            rankingTable[i], (*sp)->timerHit,
            ((*sp)->timerHit * 1000 / totalTimerHits) / 10.0,
            ((*sp)->timerHit * 1000 / totalTimerHits) / 10.0 >= 10.0 ? "" : " ",
            rankingTable[i], countArray[rankingTable[i]],
            (countArray[rankingTable[i]] * 1000 / totalTimerHits) / 10.0,
            (countArray[rankingTable[i]] * 1000 / totalTimerHits) / 10.0 >= 10.0
                ? ""
                : " ",
            symname);
    delete[] symname;

    (*sp)->cntC.printReport(fp, this, rankingTable[i], totalTimerHits);

    fprintf(fp, "<hr>\n");
  }
  fprintf(fp, "</pre>\n");

  // OK, Now we want to print the flat profile.  To do this we resort on
  // the hit count.

  // Cut-N-Paste Shell sort from above.  The Ranking Table has already been
  // populated, so we do not have to reinitialize it.
  for (mx = usefulSymbols / 9, h = 581130733; h > 0; h /= 3) {
    if (h < mx) {
      for (i = h - 1; i < usefulSymbols; i++) {
        int j, tmp = rankingTable[i], val = externalSymbols[tmp]->timerHit;
        for (j = i;
             (j >= h) && (externalSymbols[rankingTable[j - h]]->timerHit < val);
             j -= h) {
          rankingTable[j] = rankingTable[j - h];
        }
        rankingTable[j] = tmp;
      }
    }
  }

  // Pre-count up total counter hits, to get a percentage.
  // I wanted the total before walking the list, if this
  // double-pass over externalSymbols gets slow we can
  // do single-pass and print this out after the loop finishes.
  totalTimerHits = 0;
  for (i = 0;
       i < usefulSymbols && externalSymbols[rankingTable[i]]->timerHit > 0;
       i++) {
    Symbol** sp = &externalSymbols[rankingTable[i]];
    totalTimerHits += (*sp)->timerHit;
  }
  if (totalTimerHits == 0) totalTimerHits = 1;

  if (totalTimerHits != count)
    fprintf(stderr, "Hit count mismatch: count=%d; totalTimerHits=%d", count,
            totalTimerHits);

  fprintf(fp,
          "<h2><A NAME=flat_%d></A><center><a "
          "href=\"http://dxr.mozilla.org/mozilla-central/source/tools/jprof/"
          "README.html#flat\">Flat Profile</a></center></h2><br>\n",
          thread);
  fprintf(fp, "<pre>\n");

  fprintf(fp, "Total hit count: %d\n", totalTimerHits);
  fprintf(fp, "Count %%Total  Function Name\n");
  // Now loop for as long as we have timer hits
  for (i = 0;
       i < usefulSymbols && externalSymbols[rankingTable[i]]->timerHit > 0;
       i++) {
    Symbol** sp = &externalSymbols[rankingTable[i]];

    char* symname = htmlify((*sp)->name);
    fprintf(fp, "<a href=\"#%d\">%3d   %-2.1f     %s</a>\n", rankingTable[i],
            (*sp)->timerHit,
            ((float)(*sp)->timerHit / (float)totalTimerHits) * 100.0, symname);
    delete[] symname;
  }
}

void leaky::analyze(int thread) {
  int* countArray = new int[usefulSymbols];
  int* flagArray = new int[usefulSymbols];

  // Zero our function call counter
  memset(countArray, 0, sizeof(countArray[0]) * usefulSymbols);

  // reset hit counts
  for (int i = 0; i < usefulSymbols; i++) {
    externalSymbols[i]->timerHit = 0;
    externalSymbols[i]->regClear();
  }

  // The flag array is used to prevent counting symbols multiple times
  // if functions are called recursively.  In order to keep from having
  // to zero it on each pass through the loop, we mark it with the value
  // of stacks on each trip through the loop.  This means we can determine
  // if we have seen this symbol for this stack trace w/o having to reset
  // from the prior stacktrace.
  memset(flagArray, -1, sizeof(flagArray[0]) * usefulSymbols);

  if (cleo) fprintf(outputfd, "m-Start\n");

  // This loop walks through all the call stacks we recorded
  // --last, --start and --end can restrict it, as can excludes/includes
  stacks = 0;
  for (malloc_log_entry* lep = firstLogEntry; lep < lastLogEntry;
       lep = reinterpret_cast<malloc_log_entry*>(&lep->pcs[lep->numpcs])) {
    if ((thread != 0 && lep->thread != thread) || excluded(lep) ||
        !included(lep)) {
      continue;
    }

    ++stacks;  // How many stack frames did we collect

    u_int n = (lep->numpcs < stackDepth) ? lep->numpcs : stackDepth;
    char** pcp = &lep->pcs[n - 1];
    int idx = -1, parrentIdx = -1;  // Init idx incase n==0
    if (cleo) {
      // This loop walks through every symbol in the call stack.  By walking it
      // backwards we know who called the function when we get there.
      char type = 's';
      for (int i = n - 1; i >= 0; --i, --pcp) {
        idx = findSymbolIndex(reinterpret_cast<u_long>(*pcp));

        if (idx >= 0) {
          // Skip over bogus __restore_rt frames that realtime profiling
          // can introduce.
          if (i > 0 && !strcmp(externalSymbols[idx]->name, "__restore_rt")) {
            --pcp;
            --i;
            idx = findSymbolIndex(reinterpret_cast<u_long>(*pcp));
            if (idx < 0) {
              continue;
            }
          }
          Symbol** sp = &externalSymbols[idx];
          char* symname = htmlify((*sp)->name);
          fprintf(outputfd, "%c-%s\n", type, symname);
          delete[] symname;
        }
        // else can't find symbol - ignore
        type = 'c';
      }
    } else {
      // This loop walks through every symbol in the call stack.  By walking it
      // backwards we know who called the function when we get there.
      for (int i = n - 1; i >= 0; --i, --pcp) {
        idx = findSymbolIndex(reinterpret_cast<u_long>(*pcp));

        if (idx >= 0) {
          // Skip over bogus __restore_rt frames that realtime profiling
          // can introduce.
          if (i > 0 && !strcmp(externalSymbols[idx]->name, "__restore_rt")) {
            --pcp;
            --i;
            idx = findSymbolIndex(reinterpret_cast<u_long>(*pcp));
            if (idx < 0) {
              continue;
            }
          }

          // If we have not seen this symbol before count it and mark it as seen
          if (flagArray[idx] != stacks && ((flagArray[idx] = stacks) || true)) {
            ++countArray[idx];
          }

          // We know who we are and we know who our parrent is.  Count this
          if (parrentIdx >= 0) {
            externalSymbols[parrentIdx]->regChild(idx);
            externalSymbols[idx]->regParrent(parrentIdx);
          }
          // inside if() so an unknown in the middle of a stack won't break
          // the link!
          parrentIdx = idx;
        }
      }

      // idx should be the function that we were in when we received the signal.
      if (idx >= 0) {
        ++externalSymbols[idx]->timerHit;
      }
    }
  }
  if (!cleo) generateReportHTML(outputfd, countArray, stacks, thread);
}

void FunctionCount::printReport(FILE* fp, leaky* lk, int parent, int total) {
  const char* fmt =
      "                      <A href=\"#%d\">%8d (%3.1f%%)%s %s</A>%s\n";

  int nmax, tmax = ((~0U) >> 1);

  do {
    nmax = 0;
    for (int j = getSize(); --j >= 0;) {
      int cnt = getCount(j);
      if (cnt == tmax) {
        int idx = getIndex(j);
        char* symname = htmlify(lk->indexToName(idx));
        fprintf(fp, fmt, idx, getCount(j), getCount(j) * 100.0 / total,
                getCount(j) * 100.0 / total >= 10.0 ? "" : " ", symname,
                parent == idx ? " (self)" : "");
        delete[] symname;
      } else if (cnt < tmax && cnt > nmax) {
        nmax = cnt;
      }
    }
  } while ((tmax = nmax) > 0);
}