io-sim-por: don't follow threads which are after any of the races

Consider the following sequence of events

x
⋮
y
⋮
z

If x is racing with z, we will reverse x and z (e.g. postpone x after
z).  If y is also racing with x, then we should not include in the
schedule any event which happens after it.  Originally we used a policy
to remove y's thread from the list of racing threads with the x's
thread.  But this turns out to be too week.  While we are visiting new
events we need to remove their threads as soon as the event happens
after any of the so far discovered races.  Otherwise we can end with
a schedule which contains events that can only happen after the racing
event was executed, and thus likely will block and violate internal
invariant: all steps which we follow should be in the runqueue (e.g.
should not be blocked).

Author: coot

io-sim/src/Control/Monad/IOSimPOR/Internal.hs

@@ -1777,16 +1777,19 @@ updateRaces thread@Thread { threadId = tid }
             else let theseStepsRace = step `racingSteps` newStep
                      -- `step` happened before `newStep` (`newStep` happened after
                      -- `step`)
-                     happensBefore  = step `happensBeforeStep` newStep
+                     happensBefore   = step `happensBeforeStep` newStep
+                     -- `newStep` happens after any of the racing steps
+                     afterRacingStep = any (`happensBeforeStep` newStep) stepInfoRaces
 
                      -- We will only record the first race with each thread.
                      -- Reversing the first race makes the next race detectable.
                      -- Thus we remove a thread from the concurrent set after the
                      -- first race.
                      !concurrent'
-                       | happensBefore  = Set.delete tid lessConcurrent
-                       | theseStepsRace = Set.delete tid concurrent
-                       | otherwise      = concurrent
+                       | happensBefore   = Set.delete tid lessConcurrent
+                       | theseStepsRace  = Set.delete tid concurrent
+                       | afterRacingStep = Set.delete tid concurrent
+                       | otherwise       = concurrent
 
                      !stepInfoNonDep'
                        -- `newStep` happened after `step`