MINOR: threads: make thread_release() not wait for other ones to complete

The original intent of making thread_release() wait for other requesters to
proceed was more of a fairness trade, guaranteeing that a thread that was
granted an access to the CPU would be in turn giving back once its job is
done. But this is counter-productive as it forces such threads to spin
instead of going back to the poller, and it prevents us from implementing
multiple levels of guarantees, as a thread_release() call could spin
waiting for another requester to pass while that requester expects
stronger guarantees than the current thread may be able to offer.

Let's just remove that wait period and let the thread go back to the
poller, a-la "race to idle".

While in theory it could possibly slightly increase the perceived
latency of concurrent slow operations like "show fd" or "show sess",
it is not the case at all in tests, probably because the time needed
to reach the poller remains extremely low anyway.

diff --git a/src/thread.c b/src/thread.c
index a8b231aca65ae35d6a28047edc9eb07efd17dd1a..d1f88a3e7861fa32055d83ef0920707af59060fd 100644 (file)
--- a/src/thread.c
+++ b/src/thread.c
@@ -63,9 +63,10 @@ void thread_harmless_till_end()
 }
 
 /* Isolates the current thread : request the ability to work while all other
- * threads are harmless. Only returns once all of them are harmless, with the
- * current thread's bit in threads_harmless_mask cleared. Needs to be completed
- * using thread_release().
+ * threads are harmless, as defined by thread_harmless_now() (i.e. they're not
+ * going to touch any visible memory area). Only returns once all of them are
+ * harmless, with the current thread's bit in threads_harmless_mask cleared.
+ * Needs to be completed using thread_release().
  */
 void thread_isolate()
 {
@@ -92,18 +93,13 @@ void thread_isolate()
 }
 
 /* Cancels the effect of thread_isolate() by releasing the current thread's bit
- * in threads_want_rdv_mask and by marking this thread as harmless until the
- * last worker finishes.
+ * in threads_want_rdv_mask. This immediately allows other threads to expect be
+ * executed, though they will first have to wait for this thread to become
+ * harmless again (possibly by reaching the poller again).
  */
 void thread_release()
 {
        _HA_ATOMIC_AND(&threads_want_rdv_mask, ~tid_bit);
-       while (threads_want_rdv_mask & all_threads_mask) {
-               _HA_ATOMIC_OR(&threads_harmless_mask, tid_bit);
-               while (threads_want_rdv_mask & all_threads_mask)
-                       ha_thread_relax();
-               HA_ATOMIC_AND(&threads_harmless_mask, ~tid_bit);
-       }
 }
 
 /* Cancels the effect of thread_isolate() by releasing the current thread's bit