From: Charlie Savage <cfis@...>
Date: 2007-07-03T16:26:01+09:00
Subject: Is it possible to detect thread switches?

This is a cryptographically signed message in MIME format.

--------------ms030302080101040103000905
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

Is there a way to detect a thread context switch? I'm interested, due to 
my work on ruby-prof.  Currently ruby-prof will report incorrect times 
for multi-threaded applications.  Take for instance this code:

def test_thread_timings
   RubyProf.start

   sleep(2)

   thread = Thread.new do
     sleep(2)
   end

   thread.join

   result = RubyProf.stop
end

ruby-prof will say the inner thread took 2 seconds, but that the outer 
thread took 4 (when in fact it was asleep doing nothing for 2 of those 
seconds).


ruby-prof works by adding an event hook:

     rb_add_event_hook(prof_event_hook,
           RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
           RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN
           | RUBY_EVENT_LINE);

This method gets invoked when a function is entered or left.  At that 
point ruby-prof knows the current method and thread.  But if a thread 
switch happens in the middle of the method (assumedly most of the time), 
ruby-prof doesn't know it and thus can't stop running the timer on the 
first thread.

Is there anyway to detect this?

Thanks,

Charlie

--------------ms030302080101040103000905
Content-Type: application/x-pkcs7-signature; name="smime.p7s"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="smime.p7s"
Content-Description: S/MIME Cryptographic Signature
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--------------ms030302080101040103000905--