[Valgrind-developers] Valgrind: r14015 - in /trunk/drd: drd.h drd_clientobj.h drd_clientreq.c drd_mutex.c drd_mutex.h drd_pthread_intercepts.c

[<sv...@va...>]

Author: bart
Date: Mon Jun  9 09:19:26 2014
New Revision: 14015

Log:
drd: Ignore ordering introduced by a mutex used in the thread creation wrapper

Modified:
    trunk/drd/drd.h
    trunk/drd/drd_clientobj.h
    trunk/drd/drd_clientreq.c
    trunk/drd/drd_mutex.c
    trunk/drd/drd_mutex.h
    trunk/drd/drd_pthread_intercepts.c

Modified: trunk/drd/drd.h
==============================================================================
--- trunk/drd/drd.h (original)
+++ trunk/drd/drd.h Mon Jun  9 09:19:26 2014
@@ -488,6 +488,10 @@
    VG_USERREQ__DRD_ANNOTATE_SEM_POST_PRE,
    /* args: Addr. */
 
+   /* Tell DRD to ignore the inter-thread ordering introduced by a mutex. */
+   VG_USERREQ__DRD_IGNORE_MUTEX_ORDERING,
+   /* args: Addr. */
+
    /* Tell DRD that a user-defined reader-writer synchronization object
     * has been created. */
    VG_USERREQ__DRD_ANNOTATE_RWLOCK_CREATE

Modified: trunk/drd/drd_clientobj.h
==============================================================================
--- trunk/drd/drd_clientobj.h (original)
+++ trunk/drd/drd_clientobj.h Mon Jun  9 09:19:26 2014
@@ -68,6 +68,7 @@
    ExeContext*     first_observed_at;
    MutexT          mutex_type;      // pthread_mutex_t or pthread_spinlock_t.
    int             recursion_count; // 0 if free, >= 1 if locked.
+   Bool            ignore_ordering;
    DrdThreadId     owner;           // owner if locked, last owner if free.
    struct segment* last_locked_segment;
    ULong           acquiry_time_ms;

Modified: trunk/drd/drd_clientreq.c
==============================================================================
--- trunk/drd/drd_clientreq.c (original)
+++ trunk/drd/drd_clientreq.c Mon Jun  9 09:19:26 2014
@@ -378,6 +378,10 @@
       DRD_(thread_leave_synchr)(drd_tid);
       break;
 
+   case VG_USERREQ__DRD_IGNORE_MUTEX_ORDERING:
+      DRD_(mutex_ignore_ordering)(arg[1]);
+      break;
+
    case VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK:
       if (DRD_(thread_enter_synchr)(drd_tid) == 0)
          DRD_(spinlock_init_or_unlock)(arg[1]);

Modified: trunk/drd/drd_mutex.c
==============================================================================
--- trunk/drd/drd_mutex.c (original)
+++ trunk/drd/drd_mutex.c Mon Jun  9 09:19:26 2014
@@ -76,12 +76,30 @@
       = (void(*)(DrdClientobj*, DrdThreadId))mutex_delete_thread;
    p->mutex_type          = mutex_type;
    p->recursion_count     = 0;
+   p->ignore_ordering     = False;
    p->owner               = DRD_INVALID_THREADID;
    p->last_locked_segment = 0;
    p->acquiry_time_ms     = 0;
    p->acquired_at         = 0;
 }
 
+void DRD_(mutex_ignore_ordering)(const Addr mutex)
+{
+   struct mutex_info* p = DRD_(mutex_get)(mutex);
+
+   if (s_trace_mutex)
+      DRD_(trace_msg)("[%d] mutex_ignore_ordering %s 0x%lx",
+                      DRD_(thread_get_running_tid)(),
+                      p ? DRD_(mutex_type_name)(p->mutex_type) : "(?)",
+                      mutex);
+
+   if (p) {
+      p->ignore_ordering = True;
+   } else {
+      DRD_(not_a_mutex)(mutex);
+   }
+}
+
 /** Deallocate the memory that was allocated by mutex_initialize(). */
 static void mutex_cleanup(struct mutex_info* p)
 {
@@ -302,17 +320,18 @@
       return;
 
    if (p->recursion_count == 0) {
-      if (p->owner != drd_tid && p->owner != DRD_INVALID_THREADID)
-      {
-         tl_assert(p->last_locked_segment);
+      if (!p->ignore_ordering) {
+         if (p->owner != drd_tid && p->owner != DRD_INVALID_THREADID) {
+            tl_assert(p->last_locked_segment);
+
+            DRD_(thread_new_segment_and_combine_vc)(drd_tid,
+                                                    p->last_locked_segment);
+         } else {
+            DRD_(thread_new_segment)(drd_tid);
+         }
 
-         DRD_(thread_new_segment_and_combine_vc)(drd_tid,
-                                                 p->last_locked_segment);
+         s_mutex_segment_creation_count++;
       }
-      else
-         DRD_(thread_new_segment)(drd_tid);
-
-      s_mutex_segment_creation_count++;
 
       p->owner           = drd_tid;
       p->acquiry_time_ms = VG_(read_millisecond_timer)();
@@ -426,7 +445,8 @@
       /* this mutex is locked again.                                        */
 
       DRD_(thread_get_latest_segment)(&p->last_locked_segment, drd_tid);
-      DRD_(thread_new_segment)(drd_tid);
+      if (!p->ignore_ordering)
+         DRD_(thread_new_segment)(drd_tid);
       p->acquired_at = 0;
       s_mutex_segment_creation_count++;
    }

Modified: trunk/drd/drd_mutex.h
==============================================================================
--- trunk/drd/drd_mutex.h (original)
+++ trunk/drd/drd_mutex.h Mon Jun  9 09:19:26 2014
@@ -37,6 +37,7 @@
 void DRD_(mutex_set_trace)(const Bool trace_mutex);
 void DRD_(mutex_set_lock_threshold)(const UInt lock_threshold_ms);
 struct mutex_info* DRD_(mutex_init)(const Addr mutex, const MutexT mutex_type);
+void DRD_(mutex_ignore_ordering)(const Addr mutex);
 void DRD_(mutex_post_destroy)(const Addr mutex);
 void DRD_(not_a_mutex)(const Addr mutex);
 struct mutex_info* DRD_(mutex_get)(const Addr mutex);

Modified: trunk/drd/drd_pthread_intercepts.c
==============================================================================
--- trunk/drd/drd_pthread_intercepts.c (original)
+++ trunk/drd/drd_pthread_intercepts.c Mon Jun  9 09:19:26 2014
@@ -179,10 +179,17 @@
    DRD_(set_main_thread_state)();
 }
 
+static __always_inline void DRD_(ignore_mutex_ordering)(pthread_mutex_t *mutex)
+{
+   VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_IGNORE_MUTEX_ORDERING,
+                                   mutex, 0, 0, 0, 0);
+}
+
 static void DRD_(sema_init)(DrdSema* sema)
 {
-   DRD_IGNORE_VAR(sema->counter);
+   DRD_IGNORE_VAR(*sema);
    pthread_mutex_init(&sema->mutex, NULL);
+   DRD_(ignore_mutex_ordering)(&sema->mutex);
    sema->counter = 0;
    sema->waiters = 0;
 }