Data-race detection algorithm
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- pthread rwlock state tracking and support.
-- Fix Fedora 7 / Fedora 8 pth_cond_race regression test failure.
- Implement segment merging, such that the number of segments per thread
remains limited even when there is no synchronization between threads.
- Find out why a race is reported on std::string::string(std::string const&)
- Eliminate the upper bounds on the number of mutexes, condition variables,
semaphores and barriers by converting arrays into OSet's.
- Add a regression test for pthread_mutex_timedlock().
+- Find a way for suppressing races on _IO_2_1_stdout (this race is triggered
+ by calling printf() from more than one thread).
- Performance testing and tuning.
- testing on PPC and AIX (current implementation is only tested on X86 and
AMD64).
~~~~~~~~~~
- Gets killed by the OOM handler for realistically sized applications,
e.g. knode and OpenOffice.
+- When pthread_barrier_wait() is called, some real races are suppressed.
+- Does not work with a glibc library compiled with linuxthreads -- NPTL is
+ required for proper operation.
- [x86_64] Reports "Allocation context: unknown" for BSS symbols on AMD64
(works fine on i386). This is a bug in Valgrind's debug info reader
-- VG_(find_seginfo)() returns NULL for BSS symbols on x86_64. Not yet in
}
// pthread_create
-PTH_FUNC(int, pthreadZucreateZAZa, // pthread_create@*
+PTH_FUNC(int, pthreadZucreateZa, // pthread_create*
pthread_t *thread, const pthread_attr_t *attr,
void *(*start) (void *), void *arg)
{
}
// pthread_cond_init
-PTH_FUNC(int, pthreadZucondZuinitZAZa, // pthread_cond_init@*
+PTH_FUNC(int, pthreadZucondZuinitZa, // pthread_cond_init*
pthread_cond_t* cond,
const pthread_condattr_t* attr)
{
}
// pthread_cond_destroy
-PTH_FUNC(int, pthreadZucondZudestroyZAZa, // pthread_cond_destroy@*
+PTH_FUNC(int, pthreadZucondZudestroyZa, // pthread_cond_destroy*
pthread_cond_t* cond)
{
int ret;
}
// pthread_cond_wait
-PTH_FUNC(int, pthreadZucondZuwaitZAZa, // pthread_cond_wait@*
+PTH_FUNC(int, pthreadZucondZuwaitZa, // pthread_cond_wait*
pthread_cond_t *cond,
pthread_mutex_t *mutex)
{
}
// pthread_cond_timedwait
-PTH_FUNC(int, pthreadZucondZutimedwaitZAZa, // pthread_cond_timedwait@*
+PTH_FUNC(int, pthreadZucondZutimedwaitZa, // pthread_cond_timedwait*
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec* abstime)
}
// pthread_cond_signal
-PTH_FUNC(int, pthreadZucondZusignalZAZa, // pthread_cond_signal@*
+PTH_FUNC(int, pthreadZucondZusignalZa, // pthread_cond_signal*
pthread_cond_t* cond)
{
int ret;
}
// pthread_cond_broadcast
-PTH_FUNC(int, pthreadZucondZubroadcastZAZa, // pthread_cond_broadcast@*
+PTH_FUNC(int, pthreadZucondZubroadcastZa, // pthread_cond_broadcast*
pthread_cond_t* cond)
{
int ret;
thread_finished(drd_tid);
}
-void drd_pre_mutex_init(Addr mutex, SizeT size, MutexT mutex_type)
+void drd_pre_mutex_init(const Addr mutex, const SizeT size,
+ const MutexT mutex_type)
{
mutex_init(mutex, size, mutex_type);
}
-void drd_post_mutex_destroy(Addr mutex, MutexT mutex_type)
+void drd_post_mutex_destroy(const Addr mutex, const MutexT mutex_type)
{
- struct mutex_info* p;
-
- p = mutex_get(mutex);
- tl_assert(p);
- if (p)
- {
- // TO DO: report an error in case the recursion count is not zero
- // before asserting.
- tl_assert(mutex_get_recursion_count(mutex) == 0);
- mutex_destroy(p);
- }
+ mutex_post_destroy(mutex);
}
void drd_pre_mutex_lock(const DrdThreadId drd_tid,
static
IRSB* drd_instrument(VgCallbackClosure* const closure,
- IRSB* const bb_in,
- VexGuestLayout* const layout,
- VexGuestExtents* const vge,
- IRType const gWordTy,
- IRType const hWordTy)
+ IRSB* const bb_in,
+ VexGuestLayout* const layout,
+ VexGuestExtents* const vge,
+ IRType const gWordTy,
+ IRType const hWordTy)
{
IRDirty* di;
Int i;
};
+// Local functions.
+
+static void mutex_destroy(struct mutex_info* const p);
+
+
// Local variables.
static Bool s_trace_mutex;
{
struct mutex_info* mutex_p;
- tl_assert(mutex_get(mutex) == 0);
- tl_assert(mutex_type == mutex_type_mutex
- || mutex_type == mutex_type_spinlock);
- mutex_p = mutex_get_or_allocate(mutex, size, mutex_type);
-
if (s_trace_mutex)
{
const ThreadId vg_tid = VG_(get_running_tid)();
VG_(message)(Vg_DebugMsg,
"drd_post_mutex_init tid = %d/%d, %s 0x%lx",
vg_tid, drd_tid,
- mutex_get_typename(mutex_p),
+ mutex_type_name(mutex_type),
mutex);
}
+ tl_assert(mutex_type == mutex_type_mutex
+ || mutex_type == mutex_type_spinlock);
+ mutex_p = mutex_get(mutex);
+ if (mutex_p)
+ {
+ const ThreadId vg_tid = VG_(get_running_tid)();
+ MutexErrInfo MEI
+ = { mutex_p->mutex, mutex_p->recursion_count, mutex_p->owner };
+ VG_(maybe_record_error)(vg_tid,
+ MutexErr,
+ VG_(get_IP)(vg_tid),
+ "Mutex reinitialization",
+ &MEI);
+ mutex_destroy(mutex_p);
+ }
+ mutex_p = mutex_get_or_allocate(mutex, size, mutex_type);
+
return mutex_p;
}
-void mutex_destroy(struct mutex_info* const p)
+static void mutex_destroy(struct mutex_info* const p)
{
if (s_trace_mutex)
{
p->mutex = 0;
}
+void mutex_pre_destroy(struct mutex_info* const p)
+{
+ return mutex_destroy(p);
+}
+
+void mutex_post_destroy(const Addr mutex)
+{
+ struct mutex_info* p;
+
+ p = mutex_get(mutex);
+ tl_assert(p);
+ if (p)
+ {
+ if (mutex_get_recursion_count(mutex) > 0)
+ {
+ const ThreadId vg_tid = VG_(get_running_tid)();
+ MutexErrInfo MEI = { p->mutex, p->recursion_count, p->owner };
+ VG_(maybe_record_error)(vg_tid,
+ MutexErr,
+ VG_(get_IP)(vg_tid),
+ "Destroying locked mutex",
+ &MEI);
+ }
+ mutex_pre_destroy(p);
+ }
+}
+
struct mutex_info* mutex_get(const Addr mutex)
{
int i;
" simultaneously by two threads (recursion count %d,"
" owners %d and %d) !",
p->mutex, p->recursion_count, p->owner, drd_tid);
- tl_assert(0);
+ p->owner = drd_tid;
}
p->recursion_count++;
&MEI);
}
p->recursion_count--;
- tl_assert(p->recursion_count >= 0);
+ if (p->recursion_count < 0)
+ {
+ MutexErrInfo MEI
+ = { p->mutex, p->recursion_count, p->owner };
+ VG_(maybe_record_error)(vg_tid,
+ MutexErr,
+ VG_(get_IP)(vg_tid),
+ "Attempt to unlock a mutex that is not locked",
+ &MEI);
+ p->recursion_count = 0;
+ }
+
if (p->recursion_count == 0)
{
/* This pthread_mutex_unlock() call really unlocks the mutex. Save the */
{
tl_assert(p);
- switch (p->mutex_type)
+ return mutex_type_name(p->mutex_type);
+}
+
+const char* mutex_type_name(const MutexT mt)
+{
+ switch (mt)
{
case mutex_type_mutex:
return "mutex";
{
return s_mutex_lock_count;
}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 3
+ * End:
+ */
void mutex_set_trace(const Bool trace_mutex);
struct mutex_info* mutex_init(const Addr mutex, const SizeT size,
const MutexT mutex_type);
-void mutex_destroy(struct mutex_info* const p);
+void mutex_pre_destroy(struct mutex_info* const p);
+void mutex_post_destroy(const Addr mutex);
struct mutex_info* mutex_get(const Addr mutex);
int mutex_lock(const Addr mutex, const SizeT size, const MutexT mutex_type);
int mutex_unlock(const Addr mutex, const MutexT mutex_type);
const char* mutex_get_typename(struct mutex_info* const p);
+const char* mutex_type_name(const MutexT mt);
Bool mutex_is_locked_by(const Addr mutex, const DrdThreadId tid);
const VectorClock* mutex_get_last_vc(const Addr mutex);
int mutex_get_recursion_count(const Addr mutex);
fp_race2.stdout.exp fp_race2.stderr.exp \
matinv.vgtest \
matinv.stdout.exp matinv.stderr.exp \
+ pth_barrier.vgtest \
+ pth_barrier.stdout.exp pth_barrier.stderr.exp \
pth_broadcast.vgtest \
pth_broadcast.stdout.exp pth_broadcast.stderr.exp \
pth_cond_race.vgtest \
check_PROGRAMS = \
fp_race \
matinv \
+ pth_barrier \
pth_broadcast \
pth_cond_race \
pth_create_chain \
matinv_SOURCES = matinv.c
matinv_LDADD = -lpthread -lm
+pth_barrier_SOURCES = pth_barrier.c
+pth_barrier_LDADD = -lpthread
+
pth_broadcast_SOURCES = pth_broadcast.c
pth_broadcast_LDADD = -lpthread
*/
+#define _GNU_SOURCE
+
/***********************/
/* Include directives. */
/***********************/
-#define _GNU_SOURCE
-
#include <assert.h>
#include <math.h>
#include <pthread.h>
--- /dev/null
+/* Test whether all data races are detected in a multithreaded program with
+ * barriers.
+ */
+
+
+#define _GNU_SOURCE
+
+/***********************/
+/* Include directives. */
+/***********************/
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/*********************/
+/* Type definitions. */
+/*********************/
+
+struct threadinfo
+{
+ pthread_barrier_t* b;
+ pthread_t tid;
+ int* array;
+ int iterations;
+};
+
+
+/********************/
+/* Local variables. */
+/********************/
+
+static int s_silent;
+
+
+/*************************/
+/* Function definitions. */
+/*************************/
+
+static void* threadfunc(struct threadinfo* p)
+{
+ int i;
+ int* const array = p->array;
+ pthread_barrier_t* const b = p->b;
+ if (! s_silent)
+ printf("thread %lx iteration 0\n", pthread_self());
+ pthread_barrier_wait(b);
+ for (i = 0; i < p->iterations; i++)
+ {
+ if (! s_silent)
+ printf("thread %lx iteration %d; writing to %p\n",
+ pthread_self(), i + 1, &array[i]);
+ array[i] = i;
+ pthread_barrier_wait(b);
+ }
+ return 0;
+}
+
+/** Multithreaded Gauss-Jordan algorithm. */
+static void barriers_and_races(const int nthread, const int iterations)
+{
+ int i;
+ struct threadinfo* t;
+ pthread_barrier_t b;
+ int* array;
+
+ t = malloc(nthread * sizeof(struct threadinfo));
+ array = malloc(iterations * sizeof(array[0]));
+
+ pthread_barrier_init(&b, 0, nthread);
+
+ for (i = 0; i < nthread; i++)
+ {
+ t[i].b = &b;
+ t[i].array = array;
+ t[i].iterations = iterations;
+ pthread_create(&t[i].tid, 0, (void*(*)(void*))threadfunc, &t[i]);
+ }
+
+ for (i = 0; i < nthread; i++)
+ {
+ pthread_join(t[i].tid, 0);
+ }
+
+ pthread_barrier_destroy(&b);
+
+ free(array);
+ free(t);
+}
+
+int main(int argc, char** argv)
+{
+ int nthread;
+ int iterations;
+
+ nthread = (argc > 1) ? atoi(argv[1]) : 2;
+ iterations = (argc > 2) ? atoi(argv[2]) : 3;
+ s_silent = (argc > 3) ? atoi(argv[3]) : 0;
+
+ barriers_and_races(nthread, iterations);
+
+ return 0;
+}
--- /dev/null
+
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
--- /dev/null
+prog: pth_barrier
+args: 2 1 1
Thread 2:
Race condition: condition variable 0x........ has been signalled but the associated mutex 0x........ is not locked by the signalling thread
- at 0x........: pthread_cond_signal@* (drd_intercepts.c:?)
+ at 0x........: pthread_cond_signal* (drd_intercepts.c:?)
by 0x........: thread_func (pth_cond_race.c:?)
by 0x........: vg_thread_wrapper (drd_intercepts.c:?)
by 0x........: start_thread (in libpthread-?.?.so)
projects / thirdparty / valgrind.git / commitdiff
