tools/trace-malloc/tmreader.h

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is tmreader.h/tmreader.c code, released
  17  * July 7, 2000.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 2000
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Brendan Eich, 7-July-2000
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40 #ifndef tmreader_h___
  41 #define tmreader_h___
  42
  43 #include "prtypes.h"
  44 #include "plhash.h"
  45 #include "nsTraceMalloc.h"
  46 #include "plarena.h"
  47
  48 PR_BEGIN_EXTERN_C
  49
  50 typedef struct tmreader     tmreader;
  51 typedef struct tmevent      tmevent;
  52 typedef struct tmcounts     tmcounts;
  53 typedef struct tmallcounts  tmallcounts;
  54 typedef struct tmgraphlink  tmgraphlink;
  55 typedef struct tmgraphedge  tmgraphedge;
  56 typedef struct tmgraphnode  tmgraphnode;
  57 typedef struct tmcallsite   tmcallsite;
  58 typedef struct tmmethodnode tmmethodnode;
  59
  60 struct tmevent {
  61     char            type;
  62     uint32          serial;
  63     union {
  64         char        *libname;
  65         char        *srcname;
  66         struct {
  67             uint32  library;
  68             uint32  filename;
  69             uint32  linenumber;
  70             char    *name;
  71         } method;
  72         struct {
  73             uint32  parent;
  74             uint32  method;
  75             uint32  offset;
  76         } site;
  77         struct {
  78             uint32  interval; /* in ticks */
  79             uint32  ptr;
  80             uint32  size;
  81             uint32  oldserial;
  82             uint32  oldptr;
  83             uint32  oldsize;
  84             uint32  cost;     /* in ticks */
  85         } alloc;
  86         struct {
  87             nsTMStats tmstats;
  88             uint32  calltree_maxkids_parent;
  89             uint32  calltree_maxstack_top;
  90         } stats;
  91     } u;
  92 };
  93
  94 struct tmcounts {
  95     uint32          direct;     /* things allocated by this node's code */
  96     uint32          total;      /* direct + things from all descendents */
  97 };
  98
  99 struct tmallcounts {
 100     tmcounts        bytes;
 101     tmcounts        calls;
 102 };
 103
 104 struct tmgraphnode {
 105     PLHashEntry     entry;      /* key is serial or name, value must be name */
 106     tmgraphlink     *in;
 107     tmgraphlink     *out;
 108     tmgraphnode     *up;        /* parent in supergraph, e.g., JS for JS_*() */
 109     tmgraphnode     *down;      /* subgraph kids, declining bytes.total order */
 110     tmgraphnode     *next;      /* next kid in supergraph node's down list */
 111     int             low;        /* 0 or lowest current tree walk level */
 112     tmallcounts     allocs;
 113     tmallcounts     frees;
 114     double          sqsum;      /* sum of squared bytes.direct */
 115     int             sort;       /* sorted index in node table, -1 if no table */
 116 };
 117
 118 struct tmmethodnode {
 119     tmgraphnode   graphnode;
 120     char          *sourcefile;
 121     uint32        linenumber;
 122 };
 123
 124 #define tmgraphnode_name(node)  ((char*) (node)->entry.value)
 125 #define tmmethodnode_name(node)  ((char*) (node)->graphnode.entry.value)
 126
 127 #define tmlibrary_serial(lib)   ((uint32) (lib)->entry.key)
 128 #define tmcomponent_name(comp)  ((const char*) (comp)->entry.key)
 129 #define filename_name(hashentry) ((char*)hashentry->value)
 130
 131 /* Half a graphedge, not including per-edge allocation stats. */
 132 struct tmgraphlink {
 133     tmgraphlink     *next;      /* next fanning out from or into a node */
 134     tmgraphnode     *node;      /* the other node (to if OUT, from if IN) */
 135 };
 136
 137 /*
 138  * It's safe to downcast a "from" tmgraphlink (one linked from a node's out
 139  * pointer) to tmgraphedge.  To go from an "out" (linked via tmgraphedge.from)
 140  * or "in" (linked via tmgraphedge.to) list link to its containing edge, use
 141  * TM_LINK_TO_EDGE(link, which).
 142  */
 143 struct tmgraphedge {
 144     tmgraphlink     links[2];
 145     tmallcounts     allocs;
 146     tmallcounts     frees;
 147 };
 148
 149 /* Indices into tmgraphedge.links -- out must come first. */
 150 #define TM_EDGE_OUT_LINK        0
 151 #define TM_EDGE_IN_LINK         1
 152
 153 #define TM_LINK_TO_EDGE(link,which) ((tmgraphedge*) &(link)[-(which)])
 154
 155 struct tmcallsite {
 156     PLHashEntry     entry;      /* key is site serial number */
 157     tmcallsite      *parent;    /* calling site */
 158     tmcallsite      *siblings;  /* other sites reached from parent */
 159     tmcallsite      *kids;      /* sites reached from here */
 160     tmmethodnode    *method;    /* method node in tmr->methods graph */
 161     uint32          offset;     /* pc offset from start of method */
 162     tmallcounts     allocs;
 163     tmallcounts     frees;
 164     void            *data;      /* tmreader clients can stick arbitrary
 165                                  *  data onto a callsite.
 166                                  */
 167 };
 168
 169 struct tmreader {
 170     const char      *program;
 171     void            *data;
 172     PLHashTable     *libraries;
 173     PLHashTable     *filenames;
 174     PLHashTable     *components;
 175     PLHashTable     *methods;
 176     PLHashTable     *callsites;
 177     PLArenaPool     arena;
 178     tmcallsite      calltree_root;
 179     uint32          ticksPerSec;
 180 };
 181
 182 typedef void (*tmeventhandler)(tmreader *tmr, tmevent *event);
 183
 184 /* The tmreader constructor and destructor. */
 185 extern tmreader     *tmreader_new(const char *program, void *data);
 186 extern void         tmreader_destroy(tmreader *tmr);
 187
 188 /*
 189  * Return -1 on permanent fatal error, 0 if filename can't be opened or is not
 190  * a trace-malloc logfile, and 1 on success.
 191  */
 192 extern int          tmreader_eventloop(tmreader *tmr, const char *filename,
 193                                        tmeventhandler eventhandler);
 194
 195 /* Map serial number or name to graphnode or callsite. */
 196 extern tmgraphnode  *tmreader_library(tmreader *tmr, uint32 serial);
 197 extern tmgraphnode  *tmreader_filename(tmreader *tmr, uint32 serial);
 198 extern tmgraphnode  *tmreader_component(tmreader *tmr, const char *name);
 199 extern tmmethodnode  *tmreader_method(tmreader *tmr, uint32 serial);
 200 extern tmcallsite   *tmreader_callsite(tmreader *tmr, uint32 serial);
 201
 202 /*
 203  * Connect node 'from' to node 'to' with an edge, if there isn't one already
 204  * connecting the nodes.  Add site's allocation stats to the edge only if we
 205  * create the edge, or if we find that it exists, but that to->low is zero or
 206  * less than from->low.
 207  *
 208  * If the callsite tree already totals allocation costs (tmcounts.total for
 209  * each site includes tmcounts.direct for that site, plus tmcounts.total for
 210  * all kid sites), then the node->low watermarks should be set from the tree
 211  * level when walking the callsite tree, and should be set to non-zero values
 212  * only if zero (the root is at level 0).  A low watermark should be cleared
 213  * when the tree walk unwinds past the level at which it was set non-zero.
 214  *
 215  * Return 0 on error (malloc failure) and 1 on success.
 216  */
 217 extern int tmgraphnode_connect(tmgraphnode *from, tmgraphnode *to,
 218                                tmcallsite *site);
 219
 220 PR_END_EXTERN_C
 221
 222 #endif /* tmreader_h___ */