Home | History | Annotate | Download | only in drd
      1 /*
      2   This file is part of drd, a thread error detector.
      3 
      4   Copyright (C) 2006-2012 Bart Van Assche <bvanassche (at) acm.org>.
      5 
      6   This program is free software; you can redistribute it and/or
      7   modify it under the terms of the GNU General Public License as
      8   published by the Free Software Foundation; either version 2 of the
      9   License, or (at your option) any later version.
     10 
     11   This program is distributed in the hope that it will be useful, but
     12   WITHOUT ANY WARRANTY; without even the implied warranty of
     13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14   General Public License for more details.
     15 
     16   You should have received a copy of the GNU General Public License
     17   along with this program; if not, write to the Free Software
     18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
     19   02111-1307, USA.
     20 
     21   The GNU General Public License is contained in the file COPYING.
     22 */
     23 
     24 
     25 #include "drd_error.h"
     26 #include "drd_segment.h"
     27 #include "drd_thread.h"
     28 #include "pub_tool_basics.h"      // Addr, SizeT
     29 #include "pub_tool_libcassert.h"  // tl_assert()
     30 #include "pub_tool_libcbase.h"    // VG_(strlen)()
     31 #include "pub_tool_libcprint.h"   // VG_(printf)()
     32 #include "pub_tool_machine.h"     // VG_(get_SP)()
     33 #include "pub_tool_mallocfree.h"  // VG_(malloc)(), VG_(free)()
     34 #include "pub_tool_threadstate.h" // VG_INVALID_THREADID
     35 
     36 
     37 /* Global variables. */
     38 
     39 Segment* DRD_(g_sg_list);
     40 
     41 
     42 /* Local variables. */
     43 
     44 static ULong s_segment_merge_count;
     45 static ULong s_segments_created_count;
     46 static ULong s_segments_alive_count;
     47 static ULong s_max_segments_alive_count;
     48 static Bool s_trace_segment;
     49 
     50 
     51 /* Function definitions. */
     52 
     53 /**
     54  * Initialize the memory 'sg' points at.
     55  *
     56  * @note The creator and created thread ID's may be equal.
     57  * @note This function copies the vector clock of thread 'creator', a technique
     58  *   also known as clock snooping. This will only work reliably if the thread
     59  *   that called pthread_create() waits until the created thread has copied
     60  *   the vector clock.
     61  */
     62 static void sg_init(Segment* const sg,
     63                     const DrdThreadId creator,
     64                     const DrdThreadId created)
     65 {
     66    Segment* creator_sg;
     67    ThreadId vg_created = DRD_(DrdThreadIdToVgThreadId)(created);
     68 
     69    tl_assert(sg);
     70    tl_assert(creator == DRD_INVALID_THREADID
     71              || DRD_(IsValidDrdThreadId)(creator));
     72 
     73    creator_sg = (creator != DRD_INVALID_THREADID
     74                  ? DRD_(thread_get_segment)(creator) : 0);
     75 
     76    sg->g_next = NULL;
     77    sg->g_prev = NULL;
     78    sg->thr_next = NULL;
     79    sg->thr_prev = NULL;
     80    sg->tid = created;
     81    sg->refcnt = 1;
     82 
     83    if (vg_created != VG_INVALID_THREADID && VG_(get_SP)(vg_created) != 0)
     84       sg->stacktrace = VG_(record_ExeContext)(vg_created, 0);
     85    else
     86       sg->stacktrace = 0;
     87 
     88    if (creator_sg)
     89       DRD_(vc_copy)(&sg->vc, &creator_sg->vc);
     90    else
     91       DRD_(vc_init)(&sg->vc, 0, 0);
     92    DRD_(vc_increment)(&sg->vc, created);
     93    DRD_(bm_init)(&sg->bm);
     94 
     95    if (s_trace_segment)
     96    {
     97       char* vc;
     98 
     99       vc = DRD_(vc_aprint)(&sg->vc);
    100       VG_(message)(Vg_DebugMsg, "New segment for thread %d with vc %s\n",
    101                    created, vc);
    102       VG_(free)(vc);
    103    }
    104 }
    105 
    106 /** Deallocate the memory that was allocated by sg_init(). */
    107 static void DRD_(sg_cleanup)(Segment* const sg)
    108 {
    109    tl_assert(sg);
    110    tl_assert(sg->refcnt == 0);
    111 
    112    DRD_(vc_cleanup)(&sg->vc);
    113    DRD_(bm_cleanup)(&sg->bm);
    114 }
    115 
    116 /** Allocate and initialize a new segment. */
    117 Segment* DRD_(sg_new)(const DrdThreadId creator, const DrdThreadId created)
    118 {
    119    Segment* sg;
    120 
    121    s_segments_created_count++;
    122    s_segments_alive_count++;
    123    if (s_max_segments_alive_count < s_segments_alive_count)
    124       s_max_segments_alive_count = s_segments_alive_count;
    125 
    126    sg = VG_(malloc)("drd.segment.sn.1", sizeof(*sg));
    127    tl_assert(sg);
    128    sg_init(sg, creator, created);
    129    if (DRD_(g_sg_list)) {
    130       DRD_(g_sg_list)->g_prev = sg;
    131       sg->g_next = DRD_(g_sg_list);
    132    }
    133    DRD_(g_sg_list) = sg;
    134    return sg;
    135 }
    136 
    137 static void DRD_(sg_delete)(Segment* const sg)
    138 {
    139    if (DRD_(sg_get_trace)())
    140    {
    141       char* vc;
    142 
    143       vc = DRD_(vc_aprint)(&sg->vc);
    144       VG_(message)(Vg_DebugMsg, "Discarding the segment with vector clock %s\n",
    145                    vc);
    146       VG_(free)(vc);
    147    }
    148 
    149    s_segments_alive_count--;
    150 
    151    tl_assert(sg);
    152    if (sg->g_next)
    153       sg->g_next->g_prev = sg->g_prev;
    154    if (sg->g_prev)
    155       sg->g_prev->g_next = sg->g_next;
    156    else
    157       DRD_(g_sg_list) = sg->g_next;
    158    DRD_(sg_cleanup)(sg);
    159    VG_(free)(sg);
    160 }
    161 
    162 /** Increment the reference count of the specified segment. */
    163 Segment* DRD_(sg_get)(Segment* const sg)
    164 {
    165    tl_assert(sg);
    166 
    167    sg->refcnt++;
    168    return sg;
    169 }
    170 
    171 /**
    172  * Decrement the reference count of the specified segment and deallocate the
    173  * segment if the reference count became zero.
    174  */
    175 void DRD_(sg_put)(Segment* const sg)
    176 {
    177    if (sg == 0)
    178       return;
    179 
    180    if (s_trace_segment)
    181    {
    182       char* vc;
    183 
    184       vc = DRD_(vc_aprint)(&sg->vc);
    185       VG_(message)(Vg_DebugMsg,
    186                    "Decrementing segment reference count %d -> %d with vc %s\n",
    187                    sg->refcnt, sg->refcnt - 1, vc);
    188       VG_(free)(vc);
    189    }
    190 
    191    tl_assert(sg->refcnt >= 1);
    192 
    193    if (--sg->refcnt == 0)
    194    {
    195       DRD_(sg_delete)(sg);
    196    }
    197 }
    198 
    199 /** Merge sg1 and sg2 into sg1. */
    200 void DRD_(sg_merge)(Segment* const sg1, Segment* const sg2)
    201 {
    202    tl_assert(sg1);
    203    tl_assert(sg1->refcnt == 1);
    204    tl_assert(sg2);
    205    tl_assert(sg2->refcnt == 1);
    206 
    207    if (s_trace_segment)
    208    {
    209       char *vc1, *vc2;
    210 
    211       vc1 = DRD_(vc_aprint)(&sg1->vc);
    212       vc2 = DRD_(vc_aprint)(&sg2->vc);
    213 
    214       VG_(message)(Vg_DebugMsg,
    215 		   "Merging segments with vector clocks %s and %s\n", vc1, vc2);
    216       VG_(free)(vc1);
    217       VG_(free)(vc2);
    218    }
    219 
    220    s_segment_merge_count++;
    221 
    222    // Keep sg1->stacktrace.
    223    // Keep sg1->vc.
    224    // Merge sg2->bm into sg1->bm.
    225    DRD_(bm_merge2)(&sg1->bm, &sg2->bm);
    226 }
    227 
    228 /** Print the vector clock and the bitmap of the specified segment. */
    229 void DRD_(sg_print)(Segment* const sg)
    230 {
    231    tl_assert(sg);
    232    VG_(printf)("vc: ");
    233    DRD_(vc_print)(&sg->vc);
    234    VG_(printf)("\n");
    235    DRD_(bm_print)(&sg->bm);
    236 }
    237 
    238 /** Query whether segment tracing has been enabled. */
    239 Bool DRD_(sg_get_trace)(void)
    240 {
    241    return s_trace_segment;
    242 }
    243 
    244 /** Enable or disable segment tracing. */
    245 void DRD_(sg_set_trace)(Bool const trace_segment)
    246 {
    247    tl_assert(trace_segment == False || trace_segment == True);
    248    s_trace_segment = trace_segment;
    249 }
    250 
    251 ULong DRD_(sg_get_segments_created_count)(void)
    252 {
    253    return s_segments_created_count;
    254 }
    255 
    256 ULong DRD_(sg_get_segments_alive_count)(void)
    257 {
    258    return s_segments_alive_count;
    259 }
    260 
    261 ULong DRD_(sg_get_max_segments_alive_count)(void)
    262 {
    263    return s_max_segments_alive_count;
    264 }
    265 
    266 ULong DRD_(sg_get_segment_merge_count)(void)
    267 {
    268    return s_segment_merge_count;
    269 }
    270