callgrind/context.c

   1 /*--------------------------------------------------------------------*/
   2 /*--- Callgrind                                                    ---*/
   3 /*---                                                 ct_context.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Callgrind, a Valgrind tool for call tracing.
   8
   9    Copyright (C) 2002-2013, Josef Weidendorfer (Josef.Weidendorfer@gmx.de)
  10
  11    This program is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU General Public License as
  13    published by the Free Software Foundation; either version 2 of the
  14    License, or (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful, but
  17    WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  24    02111-1307, USA.
  25
  26    The GNU General Public License is contained in the file COPYING.
  27 */
  28
  29 #include "global.h"
  30
  31
  32 /*------------------------------------------------------------*/
  33 /*--- Context operations                                   ---*/
  34 /*------------------------------------------------------------*/
  35
  36 #define N_FNSTACK_INITIAL_ENTRIES 500
  37 #define N_CXT_INITIAL_ENTRIES 2537
  38
  39 fn_stack CLG_(current_fn_stack);
  40
  41 void CLG_(init_fn_stack)(fn_stack* s)
  42 {
  43   CLG_ASSERT(s != 0);
  44
  45   s->size   = N_FNSTACK_INITIAL_ENTRIES;
  46   s->bottom = (fn_node**) CLG_MALLOC("cl.context.ifs.1",
  47                                      s->size * sizeof(fn_node*));
  48   s->top    = s->bottom;
  49   s->bottom[0] = 0;
  50 }
  51
  52 void CLG_(copy_current_fn_stack)(fn_stack* dst)
  53 {
  54   CLG_ASSERT(dst != 0);
  55
  56   dst->size   = CLG_(current_fn_stack).size;
  57   dst->bottom = CLG_(current_fn_stack).bottom;
  58   dst->top    = CLG_(current_fn_stack).top;
  59 }
  60
  61 void CLG_(set_current_fn_stack)(fn_stack* s)
  62 {
  63   CLG_ASSERT(s != 0);
  64
  65   CLG_(current_fn_stack).size   = s->size;
  66   CLG_(current_fn_stack).bottom = s->bottom;
  67   CLG_(current_fn_stack).top    = s->top;
  68 }
  69
  70 static cxt_hash cxts;
  71
  72 void CLG_(init_cxt_table)()
  73 {
  74    Int i;
  75
  76    cxts.size    = N_CXT_INITIAL_ENTRIES;
  77    cxts.entries = 0;
  78    cxts.table   = (Context**) CLG_MALLOC("cl.context.ict.1",
  79                                          cxts.size * sizeof(Context*));
  80
  81    for (i = 0; i < cxts.size; i++)
  82      cxts.table[i] = 0;
  83 }
  84
  85 /* double size of cxt table  */
  86 static void resize_cxt_table(void)
  87 {
  88     UInt i, new_size, conflicts1 = 0, conflicts2 = 0;
  89     Context **new_table, *curr, *next;
  90     UInt new_idx;
  91
  92     new_size  = 2* cxts.size +3;
  93     new_table = (Context**) CLG_MALLOC("cl.context.rct.1",
  94                                        new_size * sizeof(Context*));
  95
  96     for (i = 0; i < new_size; i++)
  97       new_table[i] = NULL;
  98
  99     for (i = 0; i < cxts.size; i++) {
 100         if (cxts.table[i] == NULL) continue;
 101
 102         curr = cxts.table[i];
 103         while (NULL != curr) {
 104             next = curr->next;
 105
 106             new_idx = (UInt) (curr->hash % new_size);
 107
 108             curr->next = new_table[new_idx];
 109             new_table[new_idx] = curr;
 110             if (curr->next) {
 111                 conflicts1++;
 112                 if (curr->next->next)
 113                     conflicts2++;
 114             }
 115
 116             curr = next;
 117         }
 118     }
 119
 120     VG_(free)(cxts.table);
 121
 122
 123     CLG_DEBUG(0, "Resize Context Hash: %d => %d (entries %d, conflicts %d/%d)\n",
 124              cxts.size, new_size,
 125              cxts.entries, conflicts1, conflicts2);
 126
 127     cxts.size  = new_size;
 128     cxts.table = new_table;
 129     CLG_(stat).cxt_hash_resizes++;
 130 }
 131
 132 __inline__
 133 static UWord cxt_hash_val(fn_node** fn, UInt size)
 134 {
 135     UWord hash = 0;
 136     UInt count = size;
 137     while(*fn != 0) {
 138         hash = (hash<<7) + (hash>>25) + (UWord)(*fn);
 139         fn--;
 140         count--;
 141         if (count==0) break;
 142     }
 143     return hash;
 144 }
 145
 146 __inline__
 147 static Bool is_cxt(UWord hash, fn_node** fn, Context* cxt)
 148 {
 149     int count;
 150     fn_node** cxt_fn;
 151
 152     if (hash != cxt->hash) return False;
 153
 154     count = cxt->size;
 155     cxt_fn = &(cxt->fn[0]);
 156     while((*fn != 0) && (count>0)) {
 157         if (*cxt_fn != *fn) return False;
 158         fn--;
 159         cxt_fn++;
 160         count--;
 161     }
 162     return True;
 163 }
 164
 165 /**
 166  * Allocate new Context structure
 167  */
 168 static Context* new_cxt(fn_node** fn)
 169 {
 170     Context* cxt;
 171     UInt idx, offset;
 172     UWord hash;
 173     int size, recs;
 174     fn_node* top_fn;
 175
 176     CLG_ASSERT(fn);
 177     top_fn = *fn;
 178     if (top_fn == 0) return 0;
 179
 180     size = top_fn->separate_callers +1;
 181     recs = top_fn->separate_recursions;
 182     if (recs<1) recs=1;
 183
 184     /* check fill degree of context hash table and resize if needed (>80%) */
 185     cxts.entries++;
 186     if (10 * cxts.entries / cxts.size > 8)
 187         resize_cxt_table();
 188
 189     cxt = (Context*) CLG_MALLOC("cl.context.nc.1",
 190                                 sizeof(Context)+sizeof(fn_node*)*size);
 191
 192     // hash value calculation similar to cxt_hash_val(), but additionally
 193     // copying function pointers in one run
 194     hash = 0;
 195     offset = 0;
 196     while(*fn != 0) {
 197         hash = (hash<<7) + (hash>>25) + (UWord)(*fn);
 198         cxt->fn[offset] = *fn;
 199         offset++;
 200         fn--;
 201         if (offset >= size) break;
 202     }
 203     if (offset < size) size = offset;
 204
 205     cxt->size        = size;
 206     cxt->base_number = CLG_(stat).context_counter;
 207     cxt->hash        = hash;
 208
 209     CLG_(stat).context_counter += recs;
 210     CLG_(stat).distinct_contexts++;
 211
 212     /* insert into Context hash table */
 213     idx = (UInt) (hash % cxts.size);
 214     cxt->next = cxts.table[idx];
 215     cxts.table[idx] = cxt;
 216
 217 #if CLG_ENABLE_DEBUG
 218     CLG_DEBUGIF(3) {
 219       VG_(printf)("  new_cxt ox%p: ", cxt);
 220       CLG_(print_cxt)(12, cxt, 0);
 221     }
 222 #endif
 223
 224     return cxt;
 225 }
 226
 227 /* get the Context structure for current context */
 228 Context* CLG_(get_cxt)(fn_node** fn)
 229 {
 230     Context* cxt;
 231     UInt size, idx;
 232     UWord hash;
 233
 234     CLG_ASSERT(fn != 0);
 235     if (*fn == 0) return 0;
 236     size = (*fn)->separate_callers+1;
 237     if (size<=0) { size = -size+1; }
 238
 239     CLG_DEBUG(5, "+ get_cxt(fn '%s'): size %d\n",
 240                 (*fn)->name, size);
 241
 242     hash = cxt_hash_val(fn, size);
 243
 244     if ( ((cxt = (*fn)->last_cxt) != 0) && is_cxt(hash, fn, cxt)) {
 245         CLG_DEBUG(5, "- get_cxt: %p\n", cxt);
 246         return cxt;
 247     }
 248
 249     CLG_(stat).cxt_lru_misses++;
 250
 251     idx = (UInt) (hash % cxts.size);
 252     cxt = cxts.table[idx];
 253
 254     while(cxt) {
 255         if (is_cxt(hash,fn,cxt)) break;
 256         cxt = cxt->next;
 257     }
 258
 259     if (!cxt)
 260         cxt = new_cxt(fn);
 261
 262     (*fn)->last_cxt = cxt;
 263
 264     CLG_DEBUG(5, "- get_cxt: %p\n", cxt);
 265
 266     return cxt;
 267 }
 268
 269
 270 /**
 271  * Change execution context by calling a new function from current context
 272  * Pushing 0x0 specifies a marker for a signal handler entry
 273  */
 274 void CLG_(push_cxt)(fn_node* fn)
 275 {
 276   call_stack* cs = &CLG_(current_call_stack);
 277   Int fn_entries;
 278
 279   CLG_DEBUG(5, "+ push_cxt(fn '%s'): old ctx %d\n",
 280             fn ? fn->name : "0x0",
 281             CLG_(current_state).cxt ?
 282             CLG_(current_state).cxt->base_number : -1);
 283
 284   /* save old context on stack (even if not changed at all!) */
 285   CLG_ASSERT(cs->sp < cs->size);
 286   CLG_ASSERT(cs->entry[cs->sp].cxt == 0);
 287   cs->entry[cs->sp].cxt = CLG_(current_state).cxt;
 288   cs->entry[cs->sp].fn_sp = CLG_(current_fn_stack).top - CLG_(current_fn_stack).bottom;
 289
 290   if (fn && (*(CLG_(current_fn_stack).top) == fn)) return;
 291   if (fn && (fn->group>0) &&
 292       ((*(CLG_(current_fn_stack).top))->group == fn->group)) return;
 293
 294   /* resizing needed ? */
 295   fn_entries = CLG_(current_fn_stack).top - CLG_(current_fn_stack).bottom;
 296   if (fn_entries == CLG_(current_fn_stack).size-1) {
 297     int new_size = CLG_(current_fn_stack).size *2;
 298     fn_node** new_array = (fn_node**) CLG_MALLOC("cl.context.pc.1",
 299                                                  new_size * sizeof(fn_node*));
 300     int i;
 301     for(i=0;i<CLG_(current_fn_stack).size;i++)
 302       new_array[i] = CLG_(current_fn_stack).bottom[i];
 303     VG_(free)(CLG_(current_fn_stack).bottom);
 304     CLG_(current_fn_stack).top = new_array + fn_entries;
 305     CLG_(current_fn_stack).bottom = new_array;
 306
 307     CLG_DEBUG(0, "Resize Context Stack: %d => %d (pushing '%s')\n",
 308              CLG_(current_fn_stack).size, new_size,
 309              fn ? fn->name : "0x0");
 310
 311     CLG_(current_fn_stack).size = new_size;
 312   }
 313
 314   if (fn && (*(CLG_(current_fn_stack).top) == 0)) {
 315     UInt *pactive;
 316
 317     /* this is first function: increment its active count */
 318     pactive = CLG_(get_fn_entry)(fn->number);
 319     (*pactive)++;
 320   }
 321
 322   CLG_(current_fn_stack).top++;
 323   *(CLG_(current_fn_stack).top) = fn;
 324   CLG_(current_state).cxt = CLG_(get_cxt)(CLG_(current_fn_stack).top);
 325
 326   CLG_DEBUG(5, "- push_cxt(fn '%s'): new cxt %d, fn_sp %ld\n",
 327             fn ? fn->name : "0x0",
 328             CLG_(current_state).cxt ?
 329               CLG_(current_state).cxt->base_number : -1,
 330             CLG_(current_fn_stack).top - CLG_(current_fn_stack).bottom + 0L);
 331 }
 332