These state transition descriptions are very helpful, but what is not clear is the details of these transitions when there are concurrent wake/waits. I do not know enough about the kernel code to be able to read the implementation and answer my own questions. For example, imagine two worker threads W1 and W2. W1 adds itself to a concurrent list and calls umcg_wait(next_tid = 0). W2 pops from the list and calls umcg_wait(UMCG_WAIT_WAKE_ONLY | UMCG_WAIT_WF_CURRENT_CPU) on the popped worker, W1 in this example. If W1 calls umcg_wait first, W2 context-switches to W1 and W2's state changes to IDLE. My understanding is that wake detection/block does not apply to this case. If W2 calls umcg_wait first, what happens? I can imagine two different behaviour in this case: 1. W2 waits for W1 to call umcg_wait, by spinning or blocking, and then execution proceed like the first ordering. 2. W2 sets W1's state to RUNNING. When W1 eventually calls umcg_wait, it simply notices the state change and returns without context-switching. In this case, W1 is not migrated to W2's CPU. Behaviour 1 makes me uncomfortable since it means umcg_wait must wait for cooperation that potentially never comes. But in Behaviour 2, the state of W2 after both calls to umcg_wait is not clear to me, either. I could imagine that W2 is set to IDLE, but since W1 is not migrated, W2 could also simply be left RUNNING. Which behaviour is correct and in what state does W2 end up? Thierry
