Paul A. Clayton (paaronclayton.delete@this.gmail.com) on August 21, 2018 9:09 am wrote:

> (Rather than skipping a preemption, a thread might query how many cycles it has in its execution allocation before
> entering the critical section and yield with a request for continuation, possibly giving a length in the request,
> if the allocation is insufficient for desired likelihood of completion of a phase. Hardware support seems likely
> to be helpful in this, at least some means to cheaply determine approximately how much execution time a thread
> has remaining; hardware support might also make such less helpful for timing side channels.)

That's a pretty interesting idea. I had always thought about the opposite: extending the timeslice as you mentioned elsewhere, but having the thread voluntarily yeild() when its timeslice is almost up, rather than trying to extend its timeslice seems like it could potentially work.

Of course you'd want to find a fast way to do this: something like a timeslice deadline set in a per-thread area could work if you had a fast "read clock" operation, but things like rdtsc take dozens of cycles. One option would be to just have the scheduler or some other coordinating part of the kernel set a "timeslice is almost up" flag in a per-thread area (there are some parallels to how rseq registers a user structure that the kernel updates), which user space could check - so the fast path would just be a be a single read, and if the flag is set you yield (or at least consider it).

You could also just skip any per-critical-section work, and just have a call you make periodically at any quiescent point (where you are not in any CS - kind of like what you have to do for some RCU implementations) which checks to see if you are 99% done your timeslice and yeilds if so. This could even be a system call since you aren't doing it that often (so you could bundle it into the yield() call). This only works if you have such a quiescent point that occurs frequently enough that you can set a reasonable threshold for minimum slice remaining.