Could you override the yield method for a thread, and output some log
file after calling the super.yield() method?

j1mb0jay

Java can't tell you but your OS might.

For example Solaris stores context switch counters for each LWP in the
prusage struct in the process file system. You'll need to write some
native code or use one of the proc tools to read it.

See:
http://docs.sun.com/app/docs/doc/816-5174/proc-4?a=view
http://docs.sun.com/app/docs/doc/816-5165/proc-1?a=view

On Linux, /proc/stat contains a system wide context switch counter,
and per-thread information can be found in /proc/PID/stat.

On a lightly loaded system, the information reported by e.g. vmstat
might be sufficient:

http://docs.sun.com/app/docs/doc/816-5166/vmstat-1m?a=view
http://www.linuxmanpages.com/man8/vmstat.8.php

Both platforms also provide information about CPU time per thread,
which might be more helpful depending on what you need it for.

/gordon

--

the only tool you have I can think of is the nanotimer. See
http://mindprod.com/jgloss/timer.html.

If you keep sampling the time, and you know the minimum possible time
between two samplings, you know how long the CPU was away doing
something else on that particular run.

If you are just trying to figure out what the overhead is when the
system decides to switch threads, and so the threads don't have to be
doing useful work, something like this might work.

1. Give each thread an ID number.

2. Have a variable, cur_thread.

3. Each thread does something like this (psuedocode):

  int switchcount = 0
  while (true) {
     if ( cur_thread != our thread ID )
        ++switchcount
     cur_thread = our thread ID
  }

In switchcount, you should have a close approximation at any given time
of the number of times there was a context switch from this thread.

If you put cur_thread in shared memory, you can use this same technique
on many systems to also get process switch counts.

You can also get context switch times by adding an array that has one
entry per thread.  In that array, the thread, each time through the
loop, writes the current time.  When the thread sees that cur_thread is
not its own ID, it can use cur_thread to look in that array for the last
time the other thread ran, and subtract from the current time, to get
the context switch time.

Note that it is quite possible that context switch times when the
context switch is due to a preemptive thread or process switch could
well be quite different from context switch times when a thread or
process does an operation that yields, so don't try to use any benchmark
results such as these where they are not appropriate.