From: Julian Seward Date: Wed, 24 Apr 2002 19:51:31 +0000 (+0000) Subject: - Fast-track pthread_mutex_trylock(), even though programs which use X-Git-Tag: svn/VALGRIND_1_0_3~316 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=9bb983694b0f7299d4b1247c7bd521b88b2f4003;p=thirdparty%2Fvalgrind.git - Fast-track pthread_mutex_trylock(), even though programs which use it extensively are probably badly designed -- they are polling. - VG_(deliver_signals): return a Bool indicating if any signals really were delivered. Used only to try and reduce excessive frequency of system sanity checks. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@135 --- diff --git a/coregrind/vg_include.h b/coregrind/vg_include.h index 0c00e1ab83..19b635fb10 100644 --- a/coregrind/vg_include.h +++ b/coregrind/vg_include.h @@ -626,7 +626,7 @@ extern Int VG_(longjmpd_on_signal); extern void VG_(sigstartup_actions) ( void ); -extern void VG_(deliver_signals) ( ThreadId ); +extern Bool VG_(deliver_signals) ( ThreadId ); extern void VG_(unblock_host_signal) ( Int sigNo ); diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c index a8d575e879..d95ebf75fe 100644 --- a/coregrind/vg_scheduler.c +++ b/coregrind/vg_scheduler.c @@ -672,6 +672,10 @@ Bool maybe_do_trivial_clientreq ( ThreadId tid ) do_pthread_mutex_lock( tid, False, (void *)(arg[1]) ); return True; + case VG_USERREQ__PTHREAD_MUTEX_TRYLOCK: + do_pthread_mutex_lock( tid, True, (void *)(arg[1]) ); + return True; + default: /* Too hard; wimp out. */ return False; @@ -1095,6 +1099,7 @@ VgSchedReturnCode VG_(scheduler) ( void ) Int request_code, done_this_time, n_in_fdwait_or_sleep; Char msg_buf[100]; Addr trans_addr; + Bool sigs_delivered; /* For the LRU structures, records when the epoch began. */ ULong lru_epoch_started_at = 0; @@ -1155,8 +1160,9 @@ VgSchedReturnCode VG_(scheduler) ( void ) even if, as a result, it has missed the unlocking of it. Potential deadlock. This sounds all very strange, but the POSIX standard appears to require this behaviour. */ - VG_(deliver_signals)( 1 /*HACK*/ ); - VG_(do_sanity_checks)( 1 /*HACK*/, False ); + sigs_delivered = VG_(deliver_signals)( 1 /*HACK*/ ); + if (sigs_delivered) + VG_(do_sanity_checks)( 1 /*HACK*/, False ); /* Try and find a thread (tid) to run. */ tid_next = tid; @@ -2335,18 +2341,6 @@ void do_nontrivial_clientreq ( ThreadId tid ) do_pthread_join( tid, arg[1], (void**)(arg[2]) ); break; - case VG_USERREQ__PTHREAD_MUTEX_LOCK: - do_pthread_mutex_lock( tid, False, (pthread_mutex_t *)(arg[1]) ); - break; - - case VG_USERREQ__PTHREAD_MUTEX_TRYLOCK: - do_pthread_mutex_lock( tid, True, (pthread_mutex_t *)(arg[1]) ); - break; - - case VG_USERREQ__PTHREAD_MUTEX_UNLOCK: - do_pthread_mutex_unlock( tid, (pthread_mutex_t *)(arg[1]) ); - break; - case VG_USERREQ__PTHREAD_CANCEL: do_pthread_cancel( tid, (pthread_t)(arg[1]) ); break; diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c index fd89bde398..d0359767e5 100644 --- a/coregrind/vg_signals.c +++ b/coregrind/vg_signals.c @@ -304,8 +304,8 @@ Bool VG_(signal_returns) ( ThreadId tid ) /* Deliver all pending signals, by building stack frames for their - handlers. */ -void VG_(deliver_signals) ( ThreadId tid ) + handlers. Return True if any signals were delivered. */ +Bool VG_(deliver_signals) ( ThreadId tid ) { vki_ksigset_t saved_procmask; Int sigNo; @@ -322,7 +322,7 @@ void VG_(deliver_signals) ( ThreadId tid ) if (VG_(sigpending)[sigNo] != VG_SIGIDLE && VG_(sigpending)[sigNo] != VG_SIGRUNNING) found = True; - if (!found) return; + if (!found) return False; /* Now we have to do it properly. Get exclusive access by blocking all the host's signals. That means vg_oursignalhandler @@ -351,7 +351,7 @@ void VG_(deliver_signals) ( ThreadId tid ) /* Unlock and return. */ VG_(restore_host_signals)( &saved_procmask ); - return; + return True; } diff --git a/vg_include.h b/vg_include.h index 0c00e1ab83..19b635fb10 100644 --- a/vg_include.h +++ b/vg_include.h @@ -626,7 +626,7 @@ extern Int VG_(longjmpd_on_signal); extern void VG_(sigstartup_actions) ( void ); -extern void VG_(deliver_signals) ( ThreadId ); +extern Bool VG_(deliver_signals) ( ThreadId ); extern void VG_(unblock_host_signal) ( Int sigNo ); diff --git a/vg_scheduler.c b/vg_scheduler.c index a8d575e879..d95ebf75fe 100644 --- a/vg_scheduler.c +++ b/vg_scheduler.c @@ -672,6 +672,10 @@ Bool maybe_do_trivial_clientreq ( ThreadId tid ) do_pthread_mutex_lock( tid, False, (void *)(arg[1]) ); return True; + case VG_USERREQ__PTHREAD_MUTEX_TRYLOCK: + do_pthread_mutex_lock( tid, True, (void *)(arg[1]) ); + return True; + default: /* Too hard; wimp out. */ return False; @@ -1095,6 +1099,7 @@ VgSchedReturnCode VG_(scheduler) ( void ) Int request_code, done_this_time, n_in_fdwait_or_sleep; Char msg_buf[100]; Addr trans_addr; + Bool sigs_delivered; /* For the LRU structures, records when the epoch began. */ ULong lru_epoch_started_at = 0; @@ -1155,8 +1160,9 @@ VgSchedReturnCode VG_(scheduler) ( void ) even if, as a result, it has missed the unlocking of it. Potential deadlock. This sounds all very strange, but the POSIX standard appears to require this behaviour. */ - VG_(deliver_signals)( 1 /*HACK*/ ); - VG_(do_sanity_checks)( 1 /*HACK*/, False ); + sigs_delivered = VG_(deliver_signals)( 1 /*HACK*/ ); + if (sigs_delivered) + VG_(do_sanity_checks)( 1 /*HACK*/, False ); /* Try and find a thread (tid) to run. */ tid_next = tid; @@ -2335,18 +2341,6 @@ void do_nontrivial_clientreq ( ThreadId tid ) do_pthread_join( tid, arg[1], (void**)(arg[2]) ); break; - case VG_USERREQ__PTHREAD_MUTEX_LOCK: - do_pthread_mutex_lock( tid, False, (pthread_mutex_t *)(arg[1]) ); - break; - - case VG_USERREQ__PTHREAD_MUTEX_TRYLOCK: - do_pthread_mutex_lock( tid, True, (pthread_mutex_t *)(arg[1]) ); - break; - - case VG_USERREQ__PTHREAD_MUTEX_UNLOCK: - do_pthread_mutex_unlock( tid, (pthread_mutex_t *)(arg[1]) ); - break; - case VG_USERREQ__PTHREAD_CANCEL: do_pthread_cancel( tid, (pthread_t)(arg[1]) ); break; diff --git a/vg_signals.c b/vg_signals.c index fd89bde398..d0359767e5 100644 --- a/vg_signals.c +++ b/vg_signals.c @@ -304,8 +304,8 @@ Bool VG_(signal_returns) ( ThreadId tid ) /* Deliver all pending signals, by building stack frames for their - handlers. */ -void VG_(deliver_signals) ( ThreadId tid ) + handlers. Return True if any signals were delivered. */ +Bool VG_(deliver_signals) ( ThreadId tid ) { vki_ksigset_t saved_procmask; Int sigNo; @@ -322,7 +322,7 @@ void VG_(deliver_signals) ( ThreadId tid ) if (VG_(sigpending)[sigNo] != VG_SIGIDLE && VG_(sigpending)[sigNo] != VG_SIGRUNNING) found = True; - if (!found) return; + if (!found) return False; /* Now we have to do it properly. Get exclusive access by blocking all the host's signals. That means vg_oursignalhandler @@ -351,7 +351,7 @@ void VG_(deliver_signals) ( ThreadId tid ) /* Unlock and return. */ VG_(restore_host_signals)( &saved_procmask ); - return; + return True; }