You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
| S | M | T | W | T | F | S |
|---|---|---|---|---|---|---|
|
|
1
(4) |
2
(3) |
3
(7) |
4
(7) |
5
(6) |
6
(5) |
|
7
(21) |
8
(14) |
9
(8) |
10
(10) |
11
(7) |
12
(4) |
13
|
|
14
(3) |
15
(11) |
16
(4) |
17
|
18
|
19
|
20
|
|
21
(3) |
22
(4) |
23
(2) |
24
(3) |
25
|
26
(4) |
27
(2) |
|
28
(6) |
29
|
30
(2) |
31
(7) |
|
|
|
|
From: <sv...@va...> - 2010-03-03 23:03:58
|
Author: sewardj
Date: 2010-03-03 23:03:40 +0000 (Wed, 03 Mar 2010)
New Revision: 11062
Log:
Rollup fixes for Helgrind:
* tracking of barriers: add support for resizable barriers
* resync TSan-compatible client requests with latest changes
* add direct access to the client requests used in hg_intercepts.c
* add a client request pair to disable and re-enable tracking
of arbitrary address ranges
Modified:
trunk/helgrind/helgrind.h
trunk/helgrind/hg_intercepts.c
trunk/helgrind/hg_main.c
trunk/helgrind/libhb.h
trunk/helgrind/libhb_core.c
Modified: trunk/helgrind/helgrind.h
===================================================================
--- trunk/helgrind/helgrind.h 2010-03-03 22:57:47 UTC (rev 11061)
+++ trunk/helgrind/helgrind.h 2010-03-03 23:03:40 UTC (rev 11062)
@@ -97,7 +97,7 @@
_VG_USERREQ__HG_POSIX_SEM_DESTROY_PRE, /* sem_t* */
_VG_USERREQ__HG_POSIX_SEM_POST_PRE, /* sem_t* */
_VG_USERREQ__HG_POSIX_SEM_WAIT_POST, /* sem_t* */
- _VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE, /* pth_bar_t*, ulong */
+ _VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE, /* pth_bar_t*, ulong, ulong */
_VG_USERREQ__HG_PTHREAD_BARRIER_WAIT_PRE, /* pth_bar_t* */
_VG_USERREQ__HG_PTHREAD_BARRIER_DESTROY_PRE, /* pth_bar_t* */
_VG_USERREQ__HG_PTHREAD_SPIN_INIT_OR_UNLOCK_PRE, /* pth_slk_t* */
@@ -109,29 +109,192 @@
_VG_USERREQ__HG_USERSO_SEND_PRE, /* arbitrary UWord SO-tag */
_VG_USERREQ__HG_USERSO_RECV_POST, /* arbitrary UWord SO-tag */
_VG_USERREQ__HG_RESERVED1, /* Do not use */
- _VG_USERREQ__HG_RESERVED2 /* Do not use */
+ _VG_USERREQ__HG_RESERVED2, /* Do not use */
+ _VG_USERREQ__HG_RESERVED3, /* Do not use */
+ _VG_USERREQ__HG_RESERVED4, /* Do not use */
+ _VG_USERREQ__HG_ARANGE_MAKE_UNTRACKED, /* Addr a, ulong len */
+ _VG_USERREQ__HG_ARANGE_MAKE_TRACKED, /* Addr a, ulong len */
+ _VG_USERREQ__HG_PTHREAD_BARRIER_RESIZE_PRE /* pth_bar_t*, ulong */
} Vg_TCheckClientRequest;
/*----------------------------------------------------------------*/
-/*--- An implementation-only request -- not for end user use ---*/
+/*--- ---*/
+/*--- Implementation-only facilities. Not for end-user use. ---*/
+/*--- For end-user facilities see below (the next section in ---*/
+/*--- this file.) ---*/
+/*--- ---*/
/*----------------------------------------------------------------*/
-#define _HG_CLIENTREQ_UNIMP(_qzz_str) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
- _VG_USERREQ__HG_CLIENTREQ_UNIMP, \
- _qzz_str, 0, 0, 0, 0); \
- (void)0; \
- } while(0)
+/* Do a client request. These are macros rather than a functions so
+ as to avoid having an extra frame in stack traces.
+ NB: these duplicate definitions in hg_intercepts.c. But here, we
+ have to make do with weaker typing (no definition of Word etc) and
+ no assertions, whereas in helgrind.h we can use those facilities.
+ Obviously it's important the two sets of definitions are kept in
+ sync.
+ The commented-out asserts should actually hold, but unfortunately
+ they can't be allowed to be visible here, because that would
+ require the end-user code to #include <assert.h>.
+*/
+
+#define DO_CREQ_v_W(_creqF, _ty1F,_arg1F) \
+ do { \
+ long int _unused_res, _arg1; \
+ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \
+ _arg1 = (long int)(_arg1F); \
+ VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \
+ (_creqF), \
+ _arg1, 0,0,0,0); \
+ } while (0)
+
+#define DO_CREQ_v_WW(_creqF, _ty1F,_arg1F, _ty2F,_arg2F) \
+ do { \
+ long int _unused_res, _arg1, _arg2; \
+ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \
+ /* assert(sizeof(_ty2F) == sizeof(long int)); */ \
+ _arg1 = (long int)(_arg1F); \
+ _arg2 = (long int)(_arg2F); \
+ VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \
+ (_creqF), \
+ _arg1,_arg2,0,0,0); \
+ } while (0)
+
+#define DO_CREQ_v_WWW(_creqF, _ty1F,_arg1F, \
+ _ty2F,_arg2F, _ty3F, _arg3F) \
+ do { \
+ long int _unused_res, _arg1, _arg2, _arg3; \
+ /* assert(sizeof(_ty1F) == sizeof(long int)); */ \
+ /* assert(sizeof(_ty2F) == sizeof(long int)); */ \
+ /* assert(sizeof(_ty3F) == sizeof(long int)); */ \
+ _arg1 = (long int)(_arg1F); \
+ _arg2 = (long int)(_arg2F); \
+ _arg3 = (long int)(_arg3F); \
+ VALGRIND_DO_CLIENT_REQUEST(_unused_res, 0, \
+ (_creqF), \
+ _arg1,_arg2,_arg3,0,0); \
+ } while (0)
+
+
+#define _HG_CLIENTREQ_UNIMP(_qzz_str) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_CLIENTREQ_UNIMP, \
+ (char*),(_qzz_str))
+
+
/*----------------------------------------------------------------*/
-/*--- Misc requests ---*/
+/*--- ---*/
+/*--- Helgrind-native requests. These allow access to ---*/
+/*--- the same set of annotation primitives that are used ---*/
+/*--- to build the POSIX pthread wrappers. ---*/
+/*--- ---*/
/*----------------------------------------------------------------*/
+/* ----------------------------------------------------------
+ For describing ordinary mutexes (non-rwlocks). For rwlock
+ descriptions see ANNOTATE_RWLOCK_* below.
+ ---------------------------------------------------------- */
+
+/* Notify here immediately after mutex creation. _mbRec == 0 for a
+ non-recursive mutex, 1 for a recursive mutex. */
+#define VALGRIND_HG_MUTEX_INIT_POST(_mutex, _mbRec) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST, \
+ void*,(_mutex), long,(_mbRec))
+
+/* Notify here immediately before mutex acquisition. _isTryLock == 0
+ for a normal acquisition, 1 for a "try" style acquisition. */
+#define VALGRIND_HG_MUTEX_LOCK_PRE(_mutex, _isTryLock) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE, \
+ void*,(_mutex), long,(_isTryLock))
+
+/* Notify here immediately after a successful mutex acquisition. */
+#define VALGRIND_HG_MUTEX_LOCK_POST(_mutex) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST, \
+ void*,(_mutex))
+
+/* Notify here immediately before a mutex release. */
+#define VALGRIND_HG_MUTEX_UNLOCK_PRE(_mutex) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE, \
+ void*,(_mutex))
+
+/* Notify here immediately after a mutex release. */
+#define VALGRIND_HG_MUTEX_UNLOCK_POST(_mutex) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST, \
+ void*,(_mutex))
+
+/* Notify here immediately before mutex destruction. */
+#define VALGRIND_HG_MUTEX_DESTROY_PRE(_mutex) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE, \
+ void*,(_mutex))
+
+/* ----------------------------------------------------------
+ For describing semaphores.
+ ---------------------------------------------------------- */
+
+/* Notify here immediately after semaphore creation. */
+#define VALGRIND_HG_SEM_INIT_POST(_sem, _value) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_POSIX_SEM_INIT_POST, \
+ void*, (_sem), unsigned long, (_value))
+
+/* Notify here immediately after a semaphore wait (an acquire-style
+ operation) */
+#define VALGRIND_HG_SEM_WAIT_POST(_sem) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_WAIT_POST, \
+ void*,(_sem))
+
+/* Notify here immediately before semaphore post (a release-style
+ operation) */
+#define VALGRIND_HG_SEM_POST_PRE(_sem) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_POST_PRE, \
+ void*,(_sem))
+
+/* Notify here immediately before semaphore destruction. */
+#define VALGRIND_HG_SEM_DESTROY_PRE(_sem) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_POSIX_SEM_DESTROY_PRE, \
+ void*, (_sem))
+
+/* ----------------------------------------------------------
+ For describing barriers.
+ ---------------------------------------------------------- */
+
+/* Notify here immediately before barrier creation. _count is the
+ capacity. _resizable == 0 means the barrier may not be resized, 1
+ means it may be. */
+#define VALGRIND_HG_BARRIER_INIT_PRE(_bar, _count, _resizable) \
+ DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE, \
+ void*,(_bar), \
+ unsigned long,(_count), \
+ unsigned long,(_resizable))
+
+/* Notify here immediately before arrival at a barrier. */
+#define VALGRIND_HG_BARRIER_WAIT_PRE(_bar) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_BARRIER_WAIT_PRE, \
+ void*,(_bar))
+
+/* Notify here immediately before a resize (change of barrier
+ capacity). If _newcount >= the existing capacity, then there is no
+ change in the state of any threads waiting at the barrier. If
+ _newcount < the existing capacity, and >= _newcount threads are
+ currently waiting at the barrier, then this notification is
+ considered to also have the effect of telling the checker that all
+ waiting threads have now moved past the barrier. (I can't think of
+ any other sane semantics.) */
+#define VALGRIND_HG_BARRIER_RESIZE_PRE(_bar, _newcount) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_BARRIER_RESIZE_PRE, \
+ void*,(_bar), \
+ unsigned long,(_newcount))
+
+/* Notify here immediately before barrier destruction. */
+#define VALGRIND_HG_BARRIER_DESTROY_PRE(_bar) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_BARRIER_DESTROY_PRE, \
+ void*,(_bar))
+
+/* ----------------------------------------------------------
+ For describing memory ownership changes.
+ ---------------------------------------------------------- */
+
/* Clean memory state. This makes Helgrind forget everything it knew
about the specified memory range. Effectively this announces that
the specified memory range now "belongs" to the calling thread, so
@@ -139,27 +302,51 @@
synchronisation, and (2) all other threads must sync with this one
to access it safely. This is particularly useful for memory
allocators that wish to recycle memory. */
-#define VALGRIND_HG_CLEAN_MEMORY(_qzz_start, _qzz_len) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST( \
- (_qzz_res), 0, VG_USERREQ__HG_CLEAN_MEMORY, \
- (_qzz_start), (_qzz_len), 0, 0, 0 \
- ); \
- (void)0; \
- } while(0)
+#define VALGRIND_HG_CLEAN_MEMORY(_qzz_start, _qzz_len) \
+ DO_CREQ_v_WW(VG_USERREQ__HG_CLEAN_MEMORY, \
+ void*,(_qzz_start), \
+ unsigned long,(_qzz_len))
+/* ----------------------------------------------------------
+ For error control.
+ ---------------------------------------------------------- */
+/* Tell H that an address range is not to be "tracked" until further
+ notice. This puts it in the NOACCESS state, in which case we
+ ignore all reads and writes to it. Useful for ignoring ranges of
+ memory where there might be races we don't want to see. If the
+ memory is subsequently reallocated via malloc/new/stack allocation,
+ then it is put back in the trackable state. Hence it is safe in
+ the situation where checking is disabled, the containing area is
+ deallocated and later reallocated for some other purpose. */
+#define VALGRIND_HG_DISABLE_CHECKING(_qzz_start, _qzz_len) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_ARANGE_MAKE_UNTRACKED, \
+ void*,(_qzz_start), \
+ unsigned long,(_qzz_len))
+
+/* And put it back into the normal "tracked" state, that is, make it
+ once again subject to the normal race-checking machinery. This
+ puts it in the same state as new memory allocated by this thread --
+ that is, basically owned exclusively by this thread. */
+#define VALGRIND_HG_ENABLE_CHECKING(_qzz_start, _qzz_len) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_ARANGE_MAKE_TRACKED, \
+ void*,(_qzz_start), \
+ unsigned long,(_qzz_len))
+
+
/*----------------------------------------------------------------*/
+/*--- ---*/
/*--- ThreadSanitizer-compatible requests ---*/
+/*--- (mostly unimplemented) ---*/
+/*--- ---*/
/*----------------------------------------------------------------*/
/* A quite-broad set of annotations, as used in the ThreadSanitizer
project. This implementation aims to be a (source-level)
compatible implementation of the macros defined in:
- http://code.google.com/p/google-perftools/source \
- /browse/trunk/src/base/dynamic_annotations.h
+ http://code.google.com/p/data-race-test/source
+ /browse/trunk/dynamic_annotations/dynamic_annotations.h
(some of the comments below are taken from the above file)
@@ -240,22 +427,10 @@
----------------------------------------------------------------
*/
#define ANNOTATE_HAPPENS_BEFORE(obj) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
- _VG_USERREQ__HG_USERSO_SEND_PRE, \
- obj, 0, 0, 0, 0); \
- (void)0; \
- } while (0)
+ DO_CREQ_v_W(_VG_USERREQ__HG_USERSO_SEND_PRE, void*,(obj))
#define ANNOTATE_HAPPENS_AFTER(obj) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST(_qzz_res, 0, \
- _VG_USERREQ__HG_USERSO_RECV_POST, \
- obj, 0, 0, 0, 0); \
- (void)0; \
- } while (0)
+ DO_CREQ_v_W(_VG_USERREQ__HG_USERSO_RECV_POST, void*,(obj))
/* ----------------------------------------------------------------
@@ -274,7 +449,13 @@
#define ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \
_HG_CLIENTREQ_UNIMP("ANNOTATE_PUBLISH_MEMORY_RANGE")
+/* DEPRECATED. Don't use it. */
+/* #define ANNOTATE_UNPUBLISH_MEMORY_RANGE(pointer, size) */
+/* DEPRECATED. Don't use it. */
+/* #define ANNOTATE_SWAP_MEMORY_RANGE(pointer, size) */
+
+
/* ----------------------------------------------------------------
TSan sources say:
@@ -289,10 +470,13 @@
behaviour.
----------------------------------------------------------------
*/
-#define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) \
- _HG_CLIENTREQ_UNIMP("ANNOTATE_MUTEX_IS_USED_AS_CONDVAR")
+#define ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX")
+/* Deprecated. Use ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX. */
+/* #define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) */
+
/* ----------------------------------------------------------------
TSan sources say:
@@ -354,17 +538,22 @@
----------------------------------------------------------------
*/
-/* Report that we may have a benign race on ADDRESS. Insert at the
- point where ADDRESS has been allocated, preferably close to the
- point where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC.
+/* Report that we may have a benign race at "pointer", with size
+ "sizeof(*(pointer))". "pointer" must be a non-void* pointer. Insert at the
+ point where "pointer" has been allocated, preferably close to the point
+ where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC.
XXX: what's this actually supposed to do? And what's the type of
DESCRIPTION? When does the annotation stop having an effect?
*/
-#define ANNOTATE_BENIGN_RACE(address, description) \
+#define ANNOTATE_BENIGN_RACE(pointer, description) \
_HG_CLIENTREQ_UNIMP("ANNOTATE_BENIGN_RACE")
-
+/* Same as ANNOTATE_BENIGN_RACE(address, description), but applies to
+ the memory range [address, address+size). */
+#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_BENIGN_RACE_SIZED")
+
/* Request the analysis tool to ignore all reads in the current thread
until ANNOTATE_IGNORE_READS_END is called. Useful to ignore
intentional racey reads, while still checking other reads and all
@@ -429,51 +618,53 @@
----------------------------------------------------------------
*/
/* Report that a lock has just been created at address LOCK. */
-#define ANNOTATE_RWLOCK_CREATE(lock) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST( \
- _qzz_res, 0, _VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST, \
- lock, 0, 0, 0, 0 \
- ); \
- (void)0; \
- } while(0)
+#define ANNOTATE_RWLOCK_CREATE(lock) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST, \
+ void*,(lock))
/* Report that the lock at address LOCK is about to be destroyed. */
-#define ANNOTATE_RWLOCK_DESTROY(lock) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST( \
- _qzz_res, 0, _VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE, \
- lock, 0, 0, 0, 0 \
- ); \
- (void)0; \
- } while(0)
+#define ANNOTATE_RWLOCK_DESTROY(lock) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE, \
+ void*,(lock))
/* Report that the lock at address LOCK has just been acquired.
is_w=1 for writer lock, is_w=0 for reader lock. */
-#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST( \
- _qzz_res, 0, _VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST, \
- lock, is_w ? 1 : 0, 0, 0, 0 \
- ); \
- (void)0; \
- } while(0)
+#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
+ DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_RWLOCK_LOCK_POST, \
+ void*,(lock), unsigned long,(is_w))
/* Report that the lock at address LOCK is about to be released. */
- #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
- do { \
- unsigned long _qzz_res; \
- VALGRIND_DO_CLIENT_REQUEST( \
- _qzz_res, 0, _VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE, \
- lock, 0, 0, 0, 0 \
- ); \
- (void)0; \
- } while(0)
+#define ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
+ DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_RWLOCK_UNLOCK_PRE, \
+ void*,(lock)) /* is_w is ignored */
+/* -------------------------------------------------------------
+ Annotations useful when implementing barriers. They are not
+ normally needed by modules that merely use barriers.
+ The "barrier" argument is a pointer to the barrier object.
+ ----------------------------------------------------------------
+*/
+
+/* Report that the "barrier" has been initialized with initial
+ "count". If 'reinitialization_allowed' is true, initialization is
+ allowed to happen multiple times w/o calling barrier_destroy() */
+#define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_BARRIER_INIT")
+
+/* Report that we are about to enter barrier_wait("barrier"). */
+#define ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_BARRIER_DESTROY")
+
+/* Report that we just exited barrier_wait("barrier"). */
+#define ANNOTATE_BARRIER_WAIT_AFTER(barrier) \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_BARRIER_DESTROY")
+
+/* Report that the "barrier" has been destroyed. */
+#define ANNOTATE_BARRIER_DESTROY(barrier) \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_BARRIER_DESTROY")
+
+
/* ----------------------------------------------------------------
Annotations useful for testing race detectors.
----------------------------------------------------------------
@@ -488,5 +679,9 @@
#define ANNOTATE_NO_OP(arg) \
_HG_CLIENTREQ_UNIMP("ANNOTATE_NO_OP")
+/* Force the race detector to flush its state. The actual effect depends on
+ * the implementation of the detector. */
+#define ANNOTATE_FLUSH_STATE() \
+ _HG_CLIENTREQ_UNIMP("ANNOTATE_FLUSH_STATE")
#endif /* __HELGRIND_H */
Modified: trunk/helgrind/hg_intercepts.c
===================================================================
--- trunk/helgrind/hg_intercepts.c 2010-03-03 22:57:47 UTC (rev 11061)
+++ trunk/helgrind/hg_intercepts.c 2010-03-03 23:03:40 UTC (rev 11062)
@@ -70,9 +70,20 @@
ret_ty I_WRAP_SONAME_FNNAME_ZZ(VG_Z_LIBPTHREAD_SONAME,f)(args); \
ret_ty I_WRAP_SONAME_FNNAME_ZZ(VG_Z_LIBPTHREAD_SONAME,f)(args)
-// Do a client request. This is a macro rather than a function
-// so as to avoid having an extra function in the stack trace.
+// Do a client request. These are macros rather than a functions so
+// as to avoid having an extra frame in stack traces.
+// NB: these duplicate definitions in helgrind.h. But here, we
+// can have better typing (Word etc) and assertions, whereas
+// in helgrind.h we can't. Obviously it's important the two
+// sets of definitions are kept in sync.
+
+// nuke the previous definitions
+#undef DO_CREQ_v_W
+#undef DO_CREQ_v_WW
+#undef DO_CREQ_W_WW
+#undef DO_CREQ_v_WWW
+
#define DO_CREQ_v_W(_creqF, _ty1F,_arg1F) \
do { \
Word _unused_res, _arg1; \
@@ -957,9 +968,10 @@
fflush(stderr);
}
- DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE,
- pthread_barrier_t*,bar,
- unsigned long,count);
+ DO_CREQ_v_WWW(_VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE,
+ pthread_barrier_t*, bar,
+ unsigned long, count,
+ unsigned long, 0/*!resizable*/);
CALL_FN_W_WWW(ret, fn, bar,attr,count);
Modified: trunk/helgrind/hg_main.c
===================================================================
--- trunk/helgrind/hg_main.c 2010-03-03 22:57:47 UTC (rev 11061)
+++ trunk/helgrind/hg_main.c 2010-03-03 23:03:40 UTC (rev 11062)
@@ -1084,7 +1084,14 @@
libhb_srange_noaccess( thr->hbthr, aIN, len );
}
+static void shadow_mem_make_Untracked ( Thread* thr, Addr aIN, SizeT len )
+{
+ if (0 && len > 500)
+ VG_(printf)("make Untracked ( %#lx, %ld )\n", aIN, len );
+ libhb_srange_untrack( thr->hbthr, aIN, len );
+}
+
/*----------------------------------------------------------------*/
/*--- Event handlers (evh__* functions) ---*/
/*--- plus helpers (evhH__* functions) ---*/
@@ -1531,6 +1538,7 @@
static
void evh__die_mem ( Addr a, SizeT len ) {
+ // urr, libhb ignores this.
if (SHOW_EVENTS >= 2)
VG_(printf)("evh__die_mem(%p, %lu)\n", (void*)a, len );
shadow_mem_make_NoAccess( get_current_Thread(), a, len );
@@ -1539,6 +1547,16 @@
}
static
+void evh__untrack_mem ( Addr a, SizeT len ) {
+ // whereas it doesn't ignore this
+ if (SHOW_EVENTS >= 2)
+ VG_(printf)("evh__untrack_mem(%p, %lu)\n", (void*)a, len );
+ shadow_mem_make_Untracked( get_current_Thread(), a, len );
+ if (len >= SCE_BIGRANGE_T && (HG_(clo_sanity_flags) & SCE_BIGRANGE))
+ all__sanity_check("evh__untrack_mem-post");
+}
+
+static
void evh__copy_mem ( Addr src, Addr dst, SizeT len ) {
if (SHOW_EVENTS >= 2)
VG_(printf)("evh__copy_mem(%p, %p, %lu)\n", (void*)src, (void*)dst, len );
@@ -2701,6 +2719,7 @@
typedef
struct {
Bool initted; /* has it yet been initted by guest? */
+ Bool resizable; /* is resizing allowed? */
UWord size; /* declared size */
XArray* waiting; /* XA of Thread*. # present is 0 .. .size */
}
@@ -2760,15 +2779,16 @@
static void evh__HG_PTHREAD_BARRIER_INIT_PRE ( ThreadId tid,
void* barrier,
- UWord count )
+ UWord count,
+ UWord resizable )
{
Thread* thr;
Bar* bar;
if (SHOW_EVENTS >= 1)
VG_(printf)("evh__HG_PTHREAD_BARRIER_INIT_PRE"
- "(tid=%d, barrier=%p, count=%lu)\n",
- (Int)tid, (void*)barrier, count );
+ "(tid=%d, barrier=%p, count=%lu, resizable=%lu)\n",
+ (Int)tid, (void*)barrier, count, resizable );
thr = map_threads_maybe_lookup( tid );
tl_assert(thr); /* cannot fail - Thread* must already exist */
@@ -2779,6 +2799,12 @@
);
}
+ if (resizable != 0 && resizable != 1) {
+ HG_(record_error_Misc)(
+ thr, "pthread_barrier_init: invalid 'resizable' argument"
+ );
+ }
+
bar = map_barrier_to_Bar_lookup_or_alloc(barrier);
tl_assert(bar);
@@ -2802,8 +2828,9 @@
tl_assert(bar->waiting);
tl_assert(VG_(sizeXA)(bar->waiting) == 0);
- bar->initted = True;
- bar->size = count;
+ bar->initted = True;
+ bar->resizable = resizable == 1 ? True : False;
+ bar->size = count;
}
@@ -2851,6 +2878,43 @@
}
+/* All the threads have arrived. Now do the Interesting Bit. Get a
+ new synchronisation object and do a weak send to it from all the
+ participating threads. This makes its vector clocks be the join of
+ all the individual threads' vector clocks. Then do a strong
+ receive from it back to all threads, so that their VCs are a copy
+ of it (hence are all equal to the join of their original VCs.) */
+static void do_barrier_cross_sync_and_empty ( Bar* bar )
+{
+ /* XXX check bar->waiting has no duplicates */
+ UWord i;
+ SO* so = libhb_so_alloc();
+
+ tl_assert(bar->waiting);
+ tl_assert(VG_(sizeXA)(bar->waiting) == bar->size);
+
+ /* compute the join ... */
+ for (i = 0; i < bar->size; i++) {
+ Thread* t = *(Thread**)VG_(indexXA)(bar->waiting, i);
+ Thr* hbthr = t->hbthr;
+ libhb_so_send( hbthr, so, False/*weak send*/ );
+ }
+ /* ... and distribute to all threads */
+ for (i = 0; i < bar->size; i++) {
+ Thread* t = *(Thread**)VG_(indexXA)(bar->waiting, i);
+ Thr* hbthr = t->hbthr;
+ libhb_so_recv( hbthr, so, True/*strong recv*/ );
+ }
+
+ /* finally, we must empty out the waiting vector */
+ VG_(dropTailXA)(bar->waiting, VG_(sizeXA)(bar->waiting));
+
+ /* and we don't need this any more. Perhaps a stack-allocated
+ SO would be better? */
+ libhb_so_dealloc(so);
+}
+
+
static void evh__HG_PTHREAD_BARRIER_WAIT_PRE ( ThreadId tid,
void* barrier )
{
@@ -2896,8 +2960,7 @@
*/
Thread* thr;
Bar* bar;
- SO* so;
- UWord present, i;
+ UWord present;
if (SHOW_EVENTS >= 1)
VG_(printf)("evh__HG_PTHREAD_BARRIER_WAIT_PRE"
@@ -2930,39 +2993,74 @@
if (present < bar->size)
return;
- /* All the threads have arrived. Now do the Interesting Bit. Get
- a new synchronisation object and do a weak send to it from all
- the participating threads. This makes its vector clocks be the
- join of all the individual threads' vector clocks. Then do a
- strong receive from it back to all threads, so that their VCs
- are a copy of it (hence are all equal to the join of their
- original VCs.) */
- so = libhb_so_alloc();
+ do_barrier_cross_sync_and_empty(bar);
+}
- /* XXX check ->waiting has no duplicates */
- tl_assert(bar->waiting);
- tl_assert(VG_(sizeXA)(bar->waiting) == bar->size);
+static void evh__HG_PTHREAD_BARRIER_RESIZE_PRE ( ThreadId tid,
+ void* barrier,
+ UWord newcount )
+{
+ Thread* thr;
+ Bar* bar;
+ UWord present;
- /* compute the join ... */
- for (i = 0; i < bar->size; i++) {
- Thread* t = *(Thread**)VG_(indexXA)(bar->waiting, i);
- Thr* hbthr = t->hbthr;
- libhb_so_send( hbthr, so, False/*weak send*/ );
+ if (SHOW_EVENTS >= 1)
+ VG_(printf)("evh__HG_PTHREAD_BARRIER_RESIZE_PRE"
+ "(tid=%d, barrier=%p, newcount=%lu)\n",
+ (Int)tid, (void*)barrier, newcount );
+
+ thr = map_threads_maybe_lookup( tid );
+ tl_assert(thr); /* cannot fail - Thread* must already exist */
+
+ bar = map_barrier_to_Bar_lookup_or_alloc(barrier);
+ tl_assert(bar);
+
+ if (!bar->initted) {
+ HG_(record_error_Misc)(
+ thr, "pthread_barrier_resize: barrier is uninitialised"
+ );
+ return; /* client is broken .. avoid assertions below */
}
- /* ... and distribute to all threads */
- for (i = 0; i < bar->size; i++) {
- Thread* t = *(Thread**)VG_(indexXA)(bar->waiting, i);
- Thr* hbthr = t->hbthr;
- libhb_so_recv( hbthr, so, True/*strong recv*/ );
+
+ if (!bar->resizable) {
+ HG_(record_error_Misc)(
+ thr, "pthread_barrier_resize: barrier is may not be resized"
+ );
+ return; /* client is broken .. avoid assertions below */
}
- /* finally, we must empty out the waiting vector */
- VG_(dropTailXA)(bar->waiting, VG_(sizeXA)(bar->waiting));
+ if (newcount == 0) {
+ HG_(record_error_Misc)(
+ thr, "pthread_barrier_resize: 'newcount' argument is zero"
+ );
+ return; /* client is broken .. avoid assertions below */
+ }
- /* and we don't need this any more. Perhaps a stack-allocated
- SO would be better? */
- libhb_so_dealloc(so);
+ /* guaranteed by _INIT_PRE above */
+ tl_assert(bar->size > 0);
+ tl_assert(bar->waiting);
+ /* Guaranteed by this fn */
+ tl_assert(newcount > 0);
+
+ if (newcount >= bar->size) {
+ /* Increasing the capacity. There's no possibility of threads
+ moving on from the barrier in this situation, so just note
+ the fact and do nothing more. */
+ bar->size = newcount;
+ } else {
+ /* Decreasing the capacity. If we decrease it to be equal or
+ below the number of waiting threads, they will now move past
+ the barrier, so need to mess with dep edges in the same way
+ as if the barrier had filled up normally. */
+ present = VG_(sizeXA)(bar->waiting);
+ tl_assert(present >= 0 && present <= bar->size);
+ if (newcount <= present) {
+ bar->size = present; /* keep the cross_sync call happy */
+ do_barrier_cross_sync_and_empty(bar);
+ }
+ bar->size = newcount;
+ }
}
@@ -4157,6 +4255,22 @@
}
break;
+ case _VG_USERREQ__HG_ARANGE_MAKE_UNTRACKED:
+ if (0) VG_(printf)("HG_ARANGE_MAKE_UNTRACKED(%#lx,%ld)\n",
+ args[1], args[2]);
+ if (args[2] > 0) { /* length */
+ evh__untrack_mem(args[1], args[2]);
+ }
+ break;
+
+ case _VG_USERREQ__HG_ARANGE_MAKE_TRACKED:
+ if (0) VG_(printf)("HG_ARANGE_MAKE_TRACKED(%#lx,%ld)\n",
+ args[1], args[2]);
+ if (args[2] > 0) { /* length */
+ evh__new_mem(args[1], args[2]);
+ }
+ break;
+
/* --- --- Client requests for Helgrind's use only --- --- */
/* Some thread is telling us its pthread_t value. Record the
@@ -4327,10 +4441,17 @@
break;
case _VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE:
- /* pth_bar_t*, ulong */
- evh__HG_PTHREAD_BARRIER_INIT_PRE( tid, (void*)args[1], args[2] );
+ /* pth_bar_t*, ulong count, ulong resizable */
+ evh__HG_PTHREAD_BARRIER_INIT_PRE( tid, (void*)args[1],
+ args[2], args[3] );
break;
+ case _VG_USERREQ__HG_PTHREAD_BARRIER_RESIZE_PRE:
+ /* pth_bar_t*, ulong newcount */
+ evh__HG_PTHREAD_BARRIER_RESIZE_PRE ( tid, (void*)args[1],
+ args[2] );
+ break;
+
case _VG_USERREQ__HG_PTHREAD_BARRIER_WAIT_PRE:
/* pth_bar_t* */
evh__HG_PTHREAD_BARRIER_WAIT_PRE( tid, (void*)args[1] );
Modified: trunk/helgrind/libhb.h
===================================================================
--- trunk/helgrind/libhb.h 2010-03-03 22:57:47 UTC (rev 11061)
+++ trunk/helgrind/libhb.h 2010-03-03 23:03:40 UTC (rev 11062)
@@ -126,7 +126,8 @@
/* Set memory address ranges to new (freshly allocated), or noaccess
(no longer accessible). */
void libhb_srange_new ( Thr*, Addr, SizeT );
-void libhb_srange_noaccess ( Thr*, Addr, SizeT );
+void libhb_srange_noaccess ( Thr*, Addr, SizeT ); /* IS IGNORED */
+void libhb_srange_untrack ( Thr*, Addr, SizeT );
/* For the convenience of callers, we offer to store one void* item in
a Thr, which we ignore, but the caller can get or set any time. */
Modified: trunk/helgrind/libhb_core.c
===================================================================
--- trunk/helgrind/libhb_core.c 2010-03-03 22:57:47 UTC (rev 11061)
+++ trunk/helgrind/libhb_core.c 2010-03-03 23:03:40 UTC (rev 11062)
@@ -5716,6 +5716,16 @@
/* do nothing */
}
+void libhb_srange_untrack ( Thr* thr, Addr a, SizeT szB )
+{
+ SVal sv = SVal_NOACCESS;
+ tl_assert(is_sane_SVal_C(sv));
+ if (0 && TRACEME(a,szB)) trace(thr,a,szB,"untrack-before");
+ zsm_sset_range( a, szB, sv );
+ Filter__clear_range( thr->filter, a, szB );
+ if (0 && TRACEME(a,szB)) trace(thr,a,szB,"untrack-after ");
+}
+
void* libhb_get_Thr_opaque ( Thr* thr ) {
tl_assert(thr);
return thr->opaque;
|
|
From: <sv...@va...> - 2010-03-03 22:58:06
|
Author: sewardj Date: 2010-03-03 22:57:47 +0000 (Wed, 03 Mar 2010) New Revision: 11061 Log: Make the version number available in the valgrind.h headers, so clients can do version-specific client requests. This is something we should have done long ago. Still needs a way to regtest this, to check that the embedded version matches what's stated in configure.in. Modified: trunk/include/valgrind.h Modified: trunk/include/valgrind.h =================================================================== --- trunk/include/valgrind.h 2010-03-03 22:55:42 UTC (rev 11060) +++ trunk/include/valgrind.h 2010-03-03 22:57:47 UTC (rev 11061) @@ -73,6 +73,17 @@ #ifndef __VALGRIND_H #define __VALGRIND_H + +/* ------------------------------------------------------------------ */ +/* VERSION NUMBER OF VALGRIND */ +/* ------------------------------------------------------------------ */ + +/* Specify Valgrind's version number, so that user code can + conditionally compile based on our version number. */ +#define __VALGRIND__ 3 +#define __VALGRIND_MINOR__ 6 + + #include <stdarg.h> /* Nb: this file might be included in a file compiled with -ansi. So |
|
From: <sv...@va...> - 2010-03-03 22:56:01
|
Author: sewardj
Date: 2010-03-03 22:55:42 +0000 (Wed, 03 Mar 2010)
New Revision: 11060
Log:
Show the requesting thread (tid) for each translation.
Modified:
trunk/coregrind/m_translate.c
Modified: trunk/coregrind/m_translate.c
===================================================================
--- trunk/coregrind/m_translate.c 2010-03-02 08:57:50 UTC (rev 11059)
+++ trunk/coregrind/m_translate.c 2010-03-03 22:55:42 UTC (rev 11060)
@@ -1343,8 +1343,8 @@
Char fnname[64] = "";
VG_(get_fnname_w_offset)(addr, fnname, 64);
VG_(printf)(
- "==== BB %d %s(0x%llx) BBs exec'd %lld ====\n",
- VG_(get_bbs_translated)(), fnname, addr,
+ "==== SB %d [tid %d] %s(0x%llx) SBs exec'd %lld ====\n",
+ VG_(get_bbs_translated)(), (Int)tid, fnname, addr,
bbs_done);
}
|
|
From: Bart V. A. <bar...@gm...> - 2010-03-03 16:35:24
|
Nightly build on cellbuzz-native ( cellbuzz, ppc64, Fedora 7, native ) Started at 2010-03-03 02:26:06 EST Ended at 2010-03-03 11:15:40 EST Results differ from 24 hours ago Checking out valgrind source tree ... done Configuring valgrind ... done Building valgrind ... done Running regression tests ... done Regression test results follow == 449 tests, 43 stderr failures, 10 stdout failures, 0 post failures == memcheck/tests/deep_templates (stdout) memcheck/tests/leak-cases-full (stderr) memcheck/tests/leak-cases-summary (stderr) memcheck/tests/leak-cycle (stderr) memcheck/tests/linux/timerfd-syscall (stdout) memcheck/tests/linux-syscalls-2007 (stderr) memcheck/tests/origin5-bz2 (stderr) memcheck/tests/varinfo1 (stderr) memcheck/tests/varinfo2 (stderr) memcheck/tests/varinfo3 (stderr) memcheck/tests/varinfo4 (stderr) memcheck/tests/varinfo5 (stderr) memcheck/tests/varinfo6 (stderr) memcheck/tests/wrap8 (stdout) memcheck/tests/wrap8 (stderr) none/tests/empty-exe (stderr) none/tests/linux/mremap (stderr) none/tests/ppc32/jm-fp (stdout) none/tests/ppc32/jm-vmx (stdout) none/tests/ppc32/round (stdout) none/tests/ppc32/test_gx (stdout) none/tests/ppc64/jm-fp (stdout) none/tests/ppc64/jm-vmx (stdout) none/tests/ppc64/round (stdout) none/tests/shell_valid2 (stderr) none/tests/shell_valid3 (stderr) none/tests/shell_zerolength (stderr) helgrind/tests/hg05_race2 (stderr) helgrind/tests/tc06_two_races_xml (stderr) helgrind/tests/tc22_exit_w_lock (stderr) helgrind/tests/tc23_bogus_condwait (stderr) exp-ptrcheck/tests/bad_percentify (stderr) exp-ptrcheck/tests/base (stderr) exp-ptrcheck/tests/ccc (stderr) exp-ptrcheck/tests/fp (stderr) exp-ptrcheck/tests/globalerr (stderr) exp-ptrcheck/tests/hackedbz2 (stderr) exp-ptrcheck/tests/hp_bounds (stderr) exp-ptrcheck/tests/hp_dangle (stderr) exp-ptrcheck/tests/hsg (stderr) exp-ptrcheck/tests/justify (stderr) exp-ptrcheck/tests/partial_bad (stderr) exp-ptrcheck/tests/partial_good (stderr) exp-ptrcheck/tests/preen_invars (stderr) exp-ptrcheck/tests/pth_create (stderr) exp-ptrcheck/tests/pth_specific (stderr) exp-ptrcheck/tests/realloc (stderr) exp-ptrcheck/tests/stackerr (stderr) exp-ptrcheck/tests/strcpy (stderr) exp-ptrcheck/tests/supp (stderr) exp-ptrcheck/tests/tricky (stderr) exp-ptrcheck/tests/unaligned (stderr) exp-ptrcheck/tests/zero (stderr) ================================================= == Results from 24 hours ago == ================================================= Checking out valgrind source tree ... done Configuring valgrind ... done Building valgrind ... done Running regression tests ... done Last 20 lines of verbose log follow echo Checking out valgrind source tree ... svn co svn://svn.valgrind.org/valgrind/trunk -r {2010-03-02T02:26:06} valgrind-old Job ID = 1158.cell-user.cell.buzz svn: Working copy 'valgrind-old' locked svn: run 'svn cleanup' to remove locks (type 'svn help cleanup' for details) Configuring valgrind ... cd valgrind-old && ./autogen.sh && ./configure --prefix=/home/bart/software/valgrind/nightly/valgrind-old/Inst Job ID = 1162.cell-user.cell.buzz /var/spool/torque/mom_priv/jobs/1162.cell-user.cell.buzz.SC: line 1: ./autogen.sh: No such file or directory Building valgrind ... cd valgrind-old && make -j 2 && make -j 2 check && make install Job ID = 1163.cell-user.cell.buzz make: *** No targets specified and no makefile found. Stop. Running regression tests ... cd valgrind-old && make regtest Job ID = 1164.cell-user.cell.buzz make: *** No rule to make target `regtest'. Stop. ================================================= == Difference between 24 hours ago and now == ================================================= *** old.short Wed Mar 3 10:34:54 2010 --- new.short Wed Mar 3 11:15:40 2010 *************** *** 6,21 **** ! Last 20 lines of verbose log follow echo - Checking out valgrind source tree ... svn co svn://svn.valgrind.org/valgrind/trunk -r {2010-03-02T02:26:06} valgrind-old - Job ID = 1158.cell-user.cell.buzz - svn: Working copy 'valgrind-old' locked - svn: run 'svn cleanup' to remove locks (type 'svn help cleanup' for details) - Configuring valgrind ... cd valgrind-old && ./autogen.sh && ./configure --prefix=/home/bart/software/valgrind/nightly/valgrind-old/Inst - Job ID = 1162.cell-user.cell.buzz - /var/spool/torque/mom_priv/jobs/1162.cell-user.cell.buzz.SC: line 1: ./autogen.sh: No such file or directory - Building valgrind ... cd valgrind-old && make -j 2 && make -j 2 check && make install - Job ID = 1163.cell-user.cell.buzz - make: *** No targets specified and no makefile found. Stop. - Running regression tests ... cd valgrind-old && make regtest - Job ID = 1164.cell-user.cell.buzz - make: *** No rule to make target `regtest'. Stop. --- 6,63 ---- ! Regression test results follow ! ! == 449 tests, 43 stderr failures, 10 stdout failures, 0 post failures == ! memcheck/tests/deep_templates (stdout) ! memcheck/tests/leak-cases-full (stderr) ! memcheck/tests/leak-cases-summary (stderr) ! memcheck/tests/leak-cycle (stderr) ! memcheck/tests/linux/timerfd-syscall (stdout) ! memcheck/tests/linux-syscalls-2007 (stderr) ! memcheck/tests/origin5-bz2 (stderr) ! memcheck/tests/varinfo1 (stderr) ! memcheck/tests/varinfo2 (stderr) ! memcheck/tests/varinfo3 (stderr) ! memcheck/tests/varinfo4 (stderr) ! memcheck/tests/varinfo5 (stderr) ! memcheck/tests/varinfo6 (stderr) ! memcheck/tests/wrap8 (stdout) ! memcheck/tests/wrap8 (stderr) ! none/tests/empty-exe (stderr) ! none/tests/linux/mremap (stderr) ! none/tests/ppc32/jm-fp (stdout) ! none/tests/ppc32/jm-vmx (stdout) ! none/tests/ppc32/round (stdout) ! none/tests/ppc32/test_gx (stdout) ! none/tests/ppc64/jm-fp (stdout) ! none/tests/ppc64/jm-vmx (stdout) ! none/tests/ppc64/round (stdout) ! none/tests/shell_valid2 (stderr) ! none/tests/shell_valid3 (stderr) ! none/tests/shell_zerolength (stderr) ! helgrind/tests/hg05_race2 (stderr) ! helgrind/tests/tc06_two_races_xml (stderr) ! helgrind/tests/tc22_exit_w_lock (stderr) ! helgrind/tests/tc23_bogus_condwait (stderr) ! exp-ptrcheck/tests/bad_percentify (stderr) ! exp-ptrcheck/tests/base (stderr) ! exp-ptrcheck/tests/ccc (stderr) ! exp-ptrcheck/tests/fp (stderr) ! exp-ptrcheck/tests/globalerr (stderr) ! exp-ptrcheck/tests/hackedbz2 (stderr) ! exp-ptrcheck/tests/hp_bounds (stderr) ! exp-ptrcheck/tests/hp_dangle (stderr) ! exp-ptrcheck/tests/hsg (stderr) ! exp-ptrcheck/tests/justify (stderr) ! exp-ptrcheck/tests/partial_bad (stderr) ! exp-ptrcheck/tests/partial_good (stderr) ! exp-ptrcheck/tests/preen_invars (stderr) ! exp-ptrcheck/tests/pth_create (stderr) ! exp-ptrcheck/tests/pth_specific (stderr) ! exp-ptrcheck/tests/realloc (stderr) ! exp-ptrcheck/tests/stackerr (stderr) ! exp-ptrcheck/tests/strcpy (stderr) ! exp-ptrcheck/tests/supp (stderr) ! exp-ptrcheck/tests/tricky (stderr) ! exp-ptrcheck/tests/unaligned (stderr) ! exp-ptrcheck/tests/zero (stderr) |
|
From: Dmitry Z. <zh...@is...> - 2010-03-03 15:17:42
|
Hello. We want to share our work on implementing ARM NEON support for Valgrind. We have been working on it for some time already and think that it reached such state that it may be considered useful. Currently the whole integer part of NEON is supported and our next goal is implementing support for the remaining floating-point instructions. It would help us a lot if we receive any feedback from the community. Please see more details and patches at https://bugs.kde.org/show_bug.cgi?id=222560 . Regards, Dmitry |
|
From: Tom H. <th...@cy...> - 2010-03-03 04:34:10
|
Nightly build on mg ( x86_64, Fedora 9 ) Started at 2010-03-03 03:10:07 GMT Ended at 2010-03-03 03:36:32 GMT Results unchanged from 24 hours ago Checking out valgrind source tree ... done Configuring valgrind ... done Building valgrind ... done Running regression tests ... failed Regression test results follow == 538 tests, 1 stderr failure, 0 stdout failures, 0 post failures == helgrind/tests/tc06_two_races_xml (stderr) |
|
From: Tom H. <th...@cy...> - 2010-03-03 04:34:00
|
Nightly build on lloyd ( x86_64, Fedora 7 ) Started at 2010-03-03 03:05:03 GMT Ended at 2010-03-03 03:45:20 GMT Results unchanged from 24 hours ago Checking out valgrind source tree ... done Configuring valgrind ... done Building valgrind ... done Running regression tests ... failed Regression test results follow == 531 tests, 1 stderr failure, 0 stdout failures, 0 post failures == helgrind/tests/tc06_two_races_xml (stderr) |