Home | History | Annotate | Download | only in callgrind
      1 /*--------------------------------------------------------------------*/
      2 /*--- Callgrind                                                    ---*/
      3 /*---                                                 ct_threads.c ---*/
      4 /*--------------------------------------------------------------------*/
      5 
      6 /*
      7    This file is part of Callgrind, a Valgrind tool for call tracing.
      8 
      9    Copyright (C) 2002-2012, Josef Weidendorfer (Josef.Weidendorfer (at) 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 #include "pub_tool_threadstate.h"
     32 
     33 /* forward decls */
     34 static exec_state* exec_state_save(void);
     35 static exec_state* exec_state_restore(void);
     36 static exec_state* push_exec_state(int);
     37 static exec_state* top_exec_state(void);
     38 
     39 static exec_stack current_states;
     40 
     41 
     42 /*------------------------------------------------------------*/
     43 /*--- Support for multi-threading                          ---*/
     44 /*------------------------------------------------------------*/
     45 
     46 
     47 /*
     48  * For Valgrind, MT is cooperative (no preemting in our code),
     49  * so we don't need locks...
     50  *
     51  * Per-thread data:
     52  *  - BBCCs
     53  *  - call stack
     54  *  - call hash
     55  *  - event counters: last, current
     56  *
     57  * Even when ignoring MT, we need this functions to set up some
     58  * datastructures for the process (= Thread 1).
     59  */
     60 
     61 /* current running thread */
     62 ThreadId CLG_(current_tid);
     63 
     64 static thread_info* thread[VG_N_THREADS];
     65 
     66 thread_info** CLG_(get_threads)()
     67 {
     68   return thread;
     69 }
     70 
     71 thread_info* CLG_(get_current_thread)()
     72 {
     73   return thread[CLG_(current_tid)];
     74 }
     75 
     76 void CLG_(init_threads)()
     77 {
     78     Int i;
     79     for(i=0;i<VG_N_THREADS;i++)
     80 	thread[i] = 0;
     81     CLG_(current_tid) = VG_INVALID_THREADID;
     82 }
     83 
     84 /* switches through all threads and calls func */
     85 void CLG_(forall_threads)(void (*func)(thread_info*))
     86 {
     87   Int t, orig_tid = CLG_(current_tid);
     88 
     89   for(t=1;t<VG_N_THREADS;t++) {
     90     if (!thread[t]) continue;
     91     CLG_(switch_thread)(t);
     92     (*func)(thread[t]);
     93   }
     94   CLG_(switch_thread)(orig_tid);
     95 }
     96 
     97 
     98 static
     99 thread_info* new_thread(void)
    100 {
    101     thread_info* t;
    102 
    103     t = (thread_info*) CLG_MALLOC("cl.threads.nt.1",
    104                                   sizeof(thread_info));
    105 
    106     /* init state */
    107     CLG_(init_exec_stack)( &(t->states) );
    108     CLG_(init_call_stack)( &(t->calls) );
    109     CLG_(init_fn_stack)  ( &(t->fns) );
    110     /* t->states.entry[0]->cxt = CLG_(get_cxt)(t->fns.bottom); */
    111 
    112     /* event counters */
    113     t->lastdump_cost   = CLG_(get_eventset_cost)( CLG_(sets).full );
    114     t->sighandler_cost = CLG_(get_eventset_cost)( CLG_(sets).full );
    115     CLG_(init_cost)( CLG_(sets).full, t->lastdump_cost );
    116     CLG_(init_cost)( CLG_(sets).full, t->sighandler_cost );
    117 
    118     /* init data containers */
    119     CLG_(init_fn_array)( &(t->fn_active) );
    120     CLG_(init_bbcc_hash)( &(t->bbccs) );
    121     CLG_(init_jcc_hash)( &(t->jccs) );
    122 
    123     return t;
    124 }
    125 
    126 
    127 void CLG_(switch_thread)(ThreadId tid)
    128 {
    129   if (tid == CLG_(current_tid)) return;
    130 
    131   CLG_DEBUG(0, ">> thread %d (was %d)\n", tid, CLG_(current_tid));
    132 
    133   if (CLG_(current_tid) != VG_INVALID_THREADID) {
    134     /* save thread state */
    135     thread_info* t = thread[CLG_(current_tid)];
    136 
    137     CLG_ASSERT(t != 0);
    138 
    139     /* current context (including signal handler contexts) */
    140     exec_state_save();
    141     CLG_(copy_current_exec_stack)( &(t->states) );
    142     CLG_(copy_current_call_stack)( &(t->calls) );
    143     CLG_(copy_current_fn_stack)  ( &(t->fns) );
    144 
    145     CLG_(copy_current_fn_array) ( &(t->fn_active) );
    146     /* If we cumulate costs of threads, use TID 1 for all jccs/bccs */
    147     if (!CLG_(clo).separate_threads) t = thread[1];
    148     CLG_(copy_current_bbcc_hash)( &(t->bbccs) );
    149     CLG_(copy_current_jcc_hash) ( &(t->jccs) );
    150   }
    151 
    152   CLG_(current_tid) = tid;
    153   CLG_ASSERT(tid < VG_N_THREADS);
    154 
    155   if (tid != VG_INVALID_THREADID) {
    156     thread_info* t;
    157 
    158     /* load thread state */
    159 
    160     if (thread[tid] == 0) thread[tid] = new_thread();
    161     t = thread[tid];
    162 
    163     /* current context (including signal handler contexts) */
    164     CLG_(set_current_exec_stack)( &(t->states) );
    165     exec_state_restore();
    166     CLG_(set_current_call_stack)( &(t->calls) );
    167     CLG_(set_current_fn_stack)  ( &(t->fns) );
    168 
    169     CLG_(set_current_fn_array)  ( &(t->fn_active) );
    170     /* If we cumulate costs of threads, use TID 1 for all jccs/bccs */
    171     if (!CLG_(clo).separate_threads) t = thread[1];
    172     CLG_(set_current_bbcc_hash) ( &(t->bbccs) );
    173     CLG_(set_current_jcc_hash)  ( &(t->jccs) );
    174   }
    175 }
    176 
    177 
    178 void CLG_(run_thread)(ThreadId tid)
    179 {
    180     /* check for dumps needed */
    181     static ULong bbs_done = 0;
    182     static Char buf[512];
    183 
    184     if (CLG_(clo).dump_every_bb >0) {
    185        if (CLG_(stat).bb_executions - bbs_done > CLG_(clo).dump_every_bb) {
    186            VG_(sprintf)(buf, "--dump-every-bb=%llu", CLG_(clo).dump_every_bb);
    187 	   CLG_(dump_profile)(buf, False);
    188            bbs_done = CLG_(stat).bb_executions;
    189        }
    190     }
    191 
    192     /* now check for thread switch */
    193     CLG_(switch_thread)(tid);
    194 }
    195 
    196 void CLG_(pre_signal)(ThreadId tid, Int sigNum, Bool alt_stack)
    197 {
    198     exec_state *es;
    199 
    200     CLG_DEBUG(0, ">> pre_signal(TID %d, sig %d, alt_st %s)\n",
    201 	     tid, sigNum, alt_stack ? "yes":"no");
    202 
    203     /* switch to the thread the handler runs in */
    204     CLG_(switch_thread)(tid);
    205 
    206     /* save current execution state */
    207     exec_state_save();
    208 
    209     /* setup new cxtinfo struct for this signal handler */
    210     es = push_exec_state(sigNum);
    211     CLG_(zero_cost)( CLG_(sets).full, es->cost );
    212     CLG_(current_state).cost = es->cost;
    213     es->call_stack_bottom = CLG_(current_call_stack).sp;
    214 
    215     /* setup current state for a spontaneous call */
    216     CLG_(init_exec_state)( &CLG_(current_state) );
    217     CLG_(current_state).sig = sigNum;
    218     CLG_(push_cxt)(0);
    219 }
    220 
    221 /* Run post-signal if the stackpointer for call stack is at
    222  * the bottom in current exec state (e.g. a signal handler)
    223  *
    224  * Called from CLG_(pop_call_stack)
    225  */
    226 void CLG_(run_post_signal_on_call_stack_bottom)()
    227 {
    228     exec_state* es = top_exec_state();
    229     CLG_ASSERT(es != 0);
    230     CLG_ASSERT(CLG_(current_state).sig >0);
    231 
    232     if (CLG_(current_call_stack).sp == es->call_stack_bottom)
    233 	CLG_(post_signal)( CLG_(current_tid), CLG_(current_state).sig );
    234 }
    235 
    236 void CLG_(post_signal)(ThreadId tid, Int sigNum)
    237 {
    238     exec_state* es;
    239     UInt fn_number, *pactive;
    240 
    241     CLG_DEBUG(0, ">> post_signal(TID %d, sig %d)\n",
    242 	     tid, sigNum);
    243 
    244     /* thread switching potentially needed, eg. with instrumentation off */
    245     CLG_(switch_thread)(tid);
    246     CLG_ASSERT(sigNum == CLG_(current_state).sig);
    247 
    248     /* Unwind call stack of this signal handler.
    249      * This should only be needed at finalisation time
    250      */
    251     es = top_exec_state();
    252     CLG_ASSERT(es != 0);
    253     while(CLG_(current_call_stack).sp > es->call_stack_bottom)
    254       CLG_(pop_call_stack)();
    255 
    256     if (CLG_(current_state).cxt) {
    257       /* correct active counts */
    258       fn_number = CLG_(current_state).cxt->fn[0]->number;
    259       pactive = CLG_(get_fn_entry)(fn_number);
    260       (*pactive)--;
    261       CLG_DEBUG(0, "  set active count of %s back to %d\n",
    262 	       CLG_(current_state).cxt->fn[0]->name, *pactive);
    263     }
    264 
    265     if (CLG_(current_fn_stack).top > CLG_(current_fn_stack).bottom) {
    266 	/* set fn_stack_top back.
    267 	 * top can point to 0 if nothing was executed in the signal handler;
    268 	 * this is possible at end on unwinding handlers.
    269 	 */
    270 	if (*(CLG_(current_fn_stack).top) != 0) {
    271 	    CLG_(current_fn_stack).top--;
    272 	    CLG_ASSERT(*(CLG_(current_fn_stack).top) == 0);
    273 	}
    274       if (CLG_(current_fn_stack).top > CLG_(current_fn_stack).bottom)
    275 	CLG_(current_fn_stack).top--;
    276     }
    277 
    278     /* sum up costs */
    279     CLG_ASSERT(CLG_(current_state).cost == es->cost);
    280     CLG_(add_and_zero_cost)( CLG_(sets).full,
    281 			    thread[CLG_(current_tid)]->sighandler_cost,
    282 			    CLG_(current_state).cost );
    283 
    284     /* restore previous context */
    285     es->sig = -1;
    286     current_states.sp--;
    287     es = top_exec_state();
    288     CLG_(current_state).sig = es->sig;
    289     exec_state_restore();
    290 
    291     /* There is no way to reliable get the thread ID we are switching to
    292      * after this handler returns. So we sync with actual TID at start of
    293      * CLG_(setup_bb)(), which should be the next for callgrind.
    294      */
    295 }
    296 
    297 
    298 
    299 /*------------------------------------------------------------*/
    300 /*--- Execution states in a thread & signal handlers       ---*/
    301 /*------------------------------------------------------------*/
    302 
    303 /* Each thread can be interrupted by a signal handler, and they
    304  * themselves again. But as there's no scheduling among handlers
    305  * of the same thread, we don't need additional stacks.
    306  * So storing execution contexts and
    307  * adding separators in the callstack(needed to not intermix normal/handler
    308  * functions in contexts) should be enough.
    309  */
    310 
    311 /* not initialized: call_stack_bottom, sig */
    312 void CLG_(init_exec_state)(exec_state* es)
    313 {
    314   es->collect = CLG_(clo).collect_atstart;
    315   es->cxt  = 0;
    316   es->jmps_passed = 0;
    317   es->bbcc = 0;
    318   es->nonskipped = 0;
    319 }
    320 
    321 
    322 static exec_state* new_exec_state(Int sigNum)
    323 {
    324     exec_state* es;
    325     es = (exec_state*) CLG_MALLOC("cl.threads.nes.1",
    326                                   sizeof(exec_state));
    327 
    328     /* allocate real cost space: needed as incremented by
    329      * simulation functions */
    330     es->cost       = CLG_(get_eventset_cost)(CLG_(sets).full);
    331     CLG_(zero_cost)( CLG_(sets).full, es->cost );
    332     CLG_(init_exec_state)(es);
    333     es->sig        = sigNum;
    334     es->call_stack_bottom  = 0;
    335 
    336     return es;
    337 }
    338 
    339 void CLG_(init_exec_stack)(exec_stack* es)
    340 {
    341   Int i;
    342 
    343   /* The first element is for the main thread */
    344   es->entry[0] = new_exec_state(0);
    345   for(i=1;i<MAX_SIGHANDLERS;i++)
    346     es->entry[i] = 0;
    347   es->sp = 0;
    348 }
    349 
    350 void CLG_(copy_current_exec_stack)(exec_stack* dst)
    351 {
    352   Int i;
    353 
    354   dst->sp = current_states.sp;
    355   for(i=0;i<MAX_SIGHANDLERS;i++)
    356     dst->entry[i] = current_states.entry[i];
    357 }
    358 
    359 void CLG_(set_current_exec_stack)(exec_stack* dst)
    360 {
    361   Int i;
    362 
    363   current_states.sp = dst->sp;
    364   for(i=0;i<MAX_SIGHANDLERS;i++)
    365     current_states.entry[i] = dst->entry[i];
    366 }
    367 
    368 
    369 /* Get top context info struct of current thread */
    370 static
    371 exec_state* top_exec_state(void)
    372 {
    373   Int sp = current_states.sp;
    374   exec_state* es;
    375 
    376   CLG_ASSERT((sp >= 0) && (sp < MAX_SIGHANDLERS));
    377   es = current_states.entry[sp];
    378   CLG_ASSERT(es != 0);
    379   return es;
    380 }
    381 
    382 /* Allocates a free context info structure for a new entered
    383  * signal handler, putting it on the context stack.
    384  * Returns a pointer to the structure.
    385  */
    386 static exec_state* push_exec_state(int sigNum)
    387 {
    388   Int sp;
    389   exec_state* es;
    390 
    391   current_states.sp++;
    392   sp = current_states.sp;
    393 
    394   CLG_ASSERT((sigNum > 0) && (sigNum <= _VKI_NSIG));
    395   CLG_ASSERT((sp > 0) && (sp < MAX_SIGHANDLERS));
    396   es = current_states.entry[sp];
    397   if (!es) {
    398     es = new_exec_state(sigNum);
    399     current_states.entry[sp] = es;
    400   }
    401   else
    402     es->sig = sigNum;
    403 
    404   return es;
    405 }
    406 
    407 /* Save current context to top cxtinfo struct */
    408 static
    409 exec_state* exec_state_save(void)
    410 {
    411   exec_state* es = top_exec_state();
    412 
    413   es->cxt         = CLG_(current_state).cxt;
    414   es->collect     = CLG_(current_state).collect;
    415   es->jmps_passed = CLG_(current_state).jmps_passed;
    416   es->bbcc        = CLG_(current_state).bbcc;
    417   es->nonskipped  = CLG_(current_state).nonskipped;
    418   CLG_ASSERT(es->cost == CLG_(current_state).cost);
    419 
    420   CLG_DEBUGIF(1) {
    421     CLG_DEBUG(1, "  cxtinfo_save(sig %d): collect %s, jmps_passed %d\n",
    422 	     es->sig, es->collect ? "Yes": "No", es->jmps_passed);
    423     CLG_(print_bbcc)(-9, es->bbcc);
    424     CLG_(print_cost)(-9, CLG_(sets).full, es->cost);
    425   }
    426 
    427   /* signal number does not need to be saved */
    428   CLG_ASSERT(CLG_(current_state).sig == es->sig);
    429 
    430   return es;
    431 }
    432 
    433 static
    434 exec_state* exec_state_restore(void)
    435 {
    436   exec_state* es = top_exec_state();
    437 
    438   CLG_(current_state).cxt     = es->cxt;
    439   CLG_(current_state).collect = es->collect;
    440   CLG_(current_state).jmps_passed = es->jmps_passed;
    441   CLG_(current_state).bbcc    = es->bbcc;
    442   CLG_(current_state).nonskipped = es->nonskipped;
    443   CLG_(current_state).cost    = es->cost;
    444   CLG_(current_state).sig     = es->sig;
    445 
    446   CLG_DEBUGIF(1) {
    447 	CLG_DEBUG(1, "  exec_state_restore(sig %d): collect %s, jmps_passed %d\n",
    448 		  es->sig, es->collect ? "Yes": "No", es->jmps_passed);
    449 	CLG_(print_bbcc)(-9, es->bbcc);
    450 	CLG_(print_cxt)(-9, es->cxt, 0);
    451 	CLG_(print_cost)(-9, CLG_(sets).full, es->cost);
    452   }
    453 
    454   return es;
    455 }
    456 
    457