Prevent context-switching in timed section of code (or measure then subtract time not actually spent in thread)

问题

I have a multi-threaded application, and in a certain section of code I use a Stopwatch to measure the time of an operation:

MatchCollection matches = regex.Matches(text); //lazy evaluation
Int32 matchCount;
//inside this bracket program should not context switch
{
    //start timer
    MyStopwatch matchDuration = MyStopwatch.StartNew();
    //actually evaluate regex
    matchCount = matches.Count;
    //adds the time regex took to a list
    durations.AddDuration(matchDuration.Stop());
}

Now, the problem is if the program switches control to another thread somewhere else while the stopwatch is started, then the timed duration will be wrong. The other thread could have done any amount of work before the context switches back to this section.

Note that I am not asking about locking, these are all local variables so there is no need for that. I just want the timed section to execute continuously.

edit: another solution could be to subtract the context-switched time to get the actual time done doing work in the timed section. Don't know if that's possible.

回答1:

You can't do that. Otherwise it would be very easy for any application to get complete control over the CPU timeslices assigned to it.

You can, however, give your process a high priority to reduce the probability of a context-switch.

Here is another thought:
Assuming that you don't measure the execution time of a regular expression just once but multiple times, you should not see the average execution time as an absolute value but as a relative value compared to the average execution times of other regular expressions.
With this thinking you can compare the average execution times of different regular expressions without knowing the times lost to context switches. The time lost to context switches would be about the same in every average, assuming the environment is relatively stable with regards to CPU utilization.

回答2:

I don't think you can do that.

A "best effort", for me, would be to put your method in a separate thread, and use

Thread.CurrentThread.Priority = ThreadPriority.Highest;

to avoid as much as possible context switching.

If I may ask, why do you need such a precise measurement, and why can't you extract the function, and benchmark it in its own program if that's the point ?

Edit : Depending on the use case it may be useful to use

Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(2); // Or whatever core you want to stick to

to avoid switch between cores.

来源：https://stackoverflow.com/questions/16917092/prevent-context-switching-in-timed-section-of-code-or-measure-then-subtract-tim

标签

multithreading

performance

timing

context-switch