MINOR: listener: resync with the thread index before heavy calculations

During heavy accept competition, the CAS will occasionally fail and
we'll have to go through all the calculation again. While the first
two loops look heavy, they're almost never taken so they're quite
cheap. However the rest of the operation is heavy because we have to
consult connection counts and queue indexes for other threads, so
better double-check if the index is still valid before continuing.
Tests show that it's more efficient do retry half-way like this.

diff --git a/src/listener.c b/src/listener.c
index 8e8a1f1327d9bc437ae4b84a806e4314dc09e9fe..c3f1914fd430c289a9b139e3f330eee8f7a822d3 100644 (file)
--- a/src/listener.c
+++ b/src/listener.c
@@ -1324,6 +1324,16 @@ void listener_accept(struct listener *l)
                                        break;
                                }
 
+                               /* tests show that it's worth checking that other threads have not
+                                * already changed the index to save the rest of the calculation,
+                                * or we'd have to redo it anyway.
+                                */
+                               n1 = _HA_ATOMIC_LOAD(thr_idx_ptr);
+                               if (n0 != n1) {
+                                       n0 = n1;
+                                       continue;
+                               }
+
                                /* here we have (r1,g1,t1) that designate the first receiver, its
                                 * thread group and local thread, and (r2,g2,t2) that designate
                                 * the second receiver, its thread group and local thread.