From a3412bbd3d319f26507f1ea968bda97df7d21c0c Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Fri, 8 Aug 1997 00:36:47 +0000 Subject: (profile_waiter): Do vm_deallocate after releasing lock. Use special RPC stubs and avoid assert, thus making this function entirely independent of the threadvar mechanism and of cthreads. (lock): Convert to be a spin lock instead of a mutex, so that the waiter thread need not use cthreads. Use a fork prepare hook instead of _hurd_fork_locks to make sure we are clean before forking. (fork_profil_child): Renamed from fork_profil. (profil_reply_port): New variable. (profil_vm_deallocate, profil_task_get_sampled_pcs): Special RPC stubs made by special hacks. (fetch_samples): New function, guts from profile_waiter. (profile_waiter): Use fetch_samples. (profil): When turning off profiling, fetch the last bunch of samples before disabling PC sampling. (fetch_samples): Add prototype. (fetch_samples): Sample buffer need not be vm_deallocated; it's a stack buffer. (profil_vm_deallocate): Delete prototype. (#include <../mach/RPC_vm_deallocate_rpc.c>): Drop this inclusion. (fetch_samples): Initialize NSAMPLES. (fetch_samples): Do arithmetic on PC's in long long to avoid overflow. (fetch_samples): Put parens in the right place. --- sysdeps/mach/hurd/profil.c | 181 ++++++++++++++++++++++++++++++++++----------- 1 file changed, 138 insertions(+), 43 deletions(-) diff --git a/sysdeps/mach/hurd/profil.c b/sysdeps/mach/hurd/profil.c index 41c7c4b956..d76cc25a3c 100644 --- a/sysdeps/mach/hurd/profil.c +++ b/sysdeps/mach/hurd/profil.c @@ -1,21 +1,21 @@ /* Low-level statistical profiling support function. Mach/Hurd version. -Copyright (C) 1995, 1996 Free Software Foundation, Inc. -This file is part of the GNU C Library. + Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc. + This file is part of the GNU C Library. -The GNU C Library is free software; you can redistribute it and/or -modify it under the terms of the GNU Library General Public License as -published by the Free Software Foundation; either version 2 of the -License, or (at your option) any later version. + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. -The GNU C Library is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -Library General Public License for more details. + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. -You should have received a copy of the GNU Library General Public -License along with the GNU C Library; see the file COPYING.LIB. If -not, write to the Free Software Foundation, Inc., 675 Mass Ave, -Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include #include @@ -34,10 +34,20 @@ static size_t maxsamples; static size_t pc_offset; static size_t sample_scale; static sampled_pc_seqno_t seqno; -static struct mutex lock = MUTEX_INITIALIZER; +static spin_lock_t lock = SPIN_LOCK_INITIALIZER; static mach_msg_timeout_t collector_timeout; /* ms between collections. */ static int profile_tick; +/* Reply port used by profiler thread */ +static mach_port_t profil_reply_port; + +/* Forwards */ +static kern_return_t profil_task_get_sampled_pcs (mach_port_t, + sampled_pc_seqno_t *, + sampled_pc_array_t, + mach_msg_type_number_t *); +static void fetch_samples (void); + /* Enable statistical profiling, writing samples of the PC into at most SIZE bytes of SAMPLE_BUFFER; every processor clock tick while profiling is enabled, the system examines the user PC and increments @@ -87,7 +97,7 @@ update_waiter (u_short *sample_buffer, size_t size, size_t offset, u_int scale) } int -__profile_frequency () +__profile_frequency (void) { return profile_tick; } @@ -97,13 +107,20 @@ profil (u_short *sample_buffer, size_t size, size_t offset, u_int scale) { error_t err; - __mutex_lock (&lock); + __spin_lock (&lock); if (scale == 0) { /* Disable profiling. */ int count; - __thread_suspend (profile_thread); + + if (profile_thread != MACH_PORT_NULL) + __thread_suspend (profile_thread); + + /* Fetch the last set of samples */ + if (sample_scale) + fetch_samples (); + err = __task_disable_pc_sampling (__mach_task_self (), &count); sample_scale = 0; seqno = 0; @@ -111,57 +128,102 @@ profil (u_short *sample_buffer, size_t size, size_t offset, u_int scale) else err = update_waiter (sample_buffer, size, offset, scale); - __mutex_unlock (&lock); + __spin_unlock (&lock); return err ? __hurd_fail (err) : 0; } +/* Fetch PC samples. This function must be very careful not to depend + on Hurd threadvar variables. We arrange that by using a special + stub arranged for at the end of this file. */ static void -profile_waiter (void) +fetch_samples (void) { sampled_pc_t pc_samples[MAX_PC_SAMPLES]; mach_msg_type_number_t nsamples, i; - mach_port_t rcv = __mach_reply_port (); - mach_msg_header_t msg; error_t err; - while (1) + nsamples = MAX_PC_SAMPLES; + + err = profil_task_get_sampled_pcs (__mach_task_self (), &seqno, + pc_samples, &nsamples); + if (err) { - __mutex_lock (&lock); + static error_t special_profil_failure; + static volatile int a, b, c; - nsamples = sizeof pc_samples / sizeof pc_samples[0]; - err = __task_get_sampled_pcs (__mach_task_self (), &seqno, - pc_samples, &nsamples); - assert_perror (err); + special_profil_failure = err; + a = 1; + b = 0; + while (1) + c = a / b; + } - for (i = 0; i < nsamples; ++i) - { - size_t idx = (((pc_samples[i].pc - pc_offset) / 2) * - sample_scale / 65536); - if (idx < maxsamples) - ++samples[idx]; - } + for (i = 0; i < nsamples; ++i) + { + /* Do arithmetic in long long to avoid overflow problems. */ + long long pc_difference = pc_samples[i].pc - pc_offset; + size_t idx = ((pc_difference / 2) * sample_scale) / 65536; + if (idx < maxsamples) + ++samples[idx]; + } +} + + +/* This function must be very careful not to depend on Hurd threadvar + variables. We arrange that by using special stubs arranged for at the + end of this file. */ +static void +profile_waiter (void) +{ + mach_msg_header_t msg; + mach_port_t timeout_reply_port; + + profil_reply_port = __mach_reply_port (); + timeout_reply_port = __mach_reply_port (); - __vm_deallocate (__mach_task_self (), - (vm_address_t) pc_samples, - nsamples * sizeof *pc_samples); + while (1) + { + __spin_lock (&lock); + + fetch_samples (); - __mutex_unlock (&lock); + __spin_unlock (&lock); __mach_msg (&msg, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof msg, - rcv, collector_timeout, MACH_PORT_NULL); + timeout_reply_port, collector_timeout, MACH_PORT_NULL); } } -data_set_element (_hurd_fork_locks, lock); +/* Fork interaction */ + +/* Before fork, lock the interlock so that we are in a clean state. */ +static void +fork_profil_prepare (void) +{ + __spin_lock (&lock); +} +text_set_element (_hurd_fork_prepare_hook, fork_profil_prepare); + +/* In the parent, unlock the interlock once fork is complete. */ +static void +fork_profil_parent (void) +{ + __spin_unlock (&lock); +} +text_set_element (_hurd_fork_parent_hook, fork_profil_parent); +/* In the childs, unlock the interlock, and start a profiling thread up + if necessary. */ static void -fork_profil (void) +fork_profil_child (void) { u_short *sb; size_t n, o, ss; error_t err; + __spin_unlock (&lock); + if (profile_thread != MACH_PORT_NULL) { __mach_port_deallocate (__mach_task_self (), profile_thread); @@ -183,4 +245,37 @@ fork_profil (void) assert_perror (err); } } -text_set_element (_hurd_fork_child_hook, fork_profil); +text_set_element (_hurd_fork_child_hook, fork_profil_child); + + + + +/* Special RPC stubs for profile_waiter are made by including the normal + source code, with special CPP state to prevent it from doing the + usual thing. */ + +/* Include these first; then our #define's will take full effect, not + being overridden. */ +#include + +/* This need not do anything; it is always associated with errors, which + are fatal in profile_waiter anyhow. */ +#define __mig_put_reply_port(foo) + +/* Use our static variable instead of the usual threadvar mechanism for + this. */ +#define __mig_get_reply_port() profil_reply_port + +/* Make the functions show up as static */ +#define mig_external static + +/* Turn off the attempt to generate ld aliasing records. */ +#undef weak_alias +#define weak_alias(a,b) + +/* And change their names to avoid confusing disasters. */ +#define __vm_deallocate_rpc profil_vm_deallocate +#define __task_get_sampled_pcs profil_task_get_sampled_pcs + +/* And include the source code */ +#include <../mach/RPC_task_get_sampled_pcs.c> -- cgit v1.2.3