io-sim-por: renamed ThreadId constructors

* `RacyThreadId`, previously `ThreadId`
* `ThreadId`, previously `TestThreadId`.

Author: coot

io-sim/how-to-use-IOSimPOR.txt

@@ -200,27 +200,26 @@ small number of tests.
 IOSimPOR Scheduling
 -------------------
 
-IOSimPOR distinguishes between test threads and system threads; test
-threads are intended to be part of the test itself, whereas system
-threads are part of the system under test. The main thread in a test
-is always a test thread; test threads can fork system threads, but not
-vice versa. Test threads always take priority over system threads, and
-IOSimPOR does not attempt to reverse races involving test threads. So
-when writing a test, one can assume that whatever the test threads do
-takes place first (at each simulated time point), and then the system
-threads run and any races between them are explored. Likewise, if a
-blocked test thread responds to an event in a system thread, then the
-test thread's response will take place before the system threads
-continue execution. Distinguishing test threads from system threads
-drastically reduces the set of races that IOSimPOR needs to consider.
-
-To start a system thread, a test thread may call
+IOSimPOR distinguishes between non-racy threads and system threads; test
+threads are intended to be part of the test itself, whereas system threads are
+part of the system under test. The main thread in a test is always a non-racy
+thread; non-racy threads can fork system threads, but not vice versa. Test
+threads always take priority over system threads, and IOSimPOR does not
+attempt to reverse races involving test threads. So when writing a test, one
+can assume that whatever the test threads do takes place first (at each
+simulated time point), and then the system threads run and any races between
+them are explored. Likewise, if a blocked non-racy thread responds to an event
+in a system thread, then the test thread's response will take place before the
+system threads continue execution. Distinguishing non-racy threads from system
+threads drastically reduces the set of races that IOSimPOR needs to consider.
+
+To start a system thread, a non-racy thread may call
 
     exploreRaces :: MonadTest m => m ()
 
 All threads forked (using forkIO) after such a call will be system
 threads. If there is no call to exploreRaces in a test, then all the
-threads forked will be test threads, and IOSimPOR will not reverse any
+threads forked will be non-racy threads, and IOSimPOR will not reverse any
 races---so it is necessary to include a call to exploreRaces somewhere
 in a test.
 
@@ -234,7 +233,7 @@ easy to see which thread forked which other, and relatively easy to
 map thread ids in debugging output to threads in the source code.
 
 Except when reversing races, IOSimPOR schedules threads using
-priorities. Test threads take priority over system threads, but
+priorities. Non-racy threads take priority over system threads, but
 otherwise priorities are determined by the thread ids: the thread with
 the lexicographically greatest thread Id has the highest priority. As
 a result, threads behave in a very predictable manner: newly forked

io-sim/src/Control/Monad/IOSim/Types.hs

@@ -627,17 +627,17 @@ data SimEventType
 type TraceEvent = SimEventType
 {-# DEPRECATED TraceEvent "Use 'SimEventType' instead." #-}
 
-data ThreadId = ThreadId  [Int]
-              | TestThreadId [Int]    -- test threads have higher priority
+data ThreadId = RacyThreadId [Int]
+              | ThreadId     [Int]    -- non racy threads have higher priority
   deriving (Eq, Ord, Show)
 
 childThreadId :: ThreadId -> Int -> ThreadId
+childThreadId (RacyThreadId is) i = RacyThreadId (is ++ [i])
 childThreadId (ThreadId     is) i = ThreadId     (is ++ [i])
-childThreadId (TestThreadId is) i = TestThreadId (is ++ [i])
 
-setNonTestThread :: ThreadId -> ThreadId
-setNonTestThread (TestThreadId is) = ThreadId is
-setNonTestThread tid@ThreadId{}    = tid
+setRacyThread :: ThreadId -> ThreadId
+setRacyThread (ThreadId is)      = RacyThreadId is
+setRacyThread tid@RacyThreadId{} = tid
 
 newtype TVarId      = TVarId    Int   deriving (Eq, Ord, Enum, Show)
 newtype TimeoutId   = TimeoutId Int   deriving (Eq, Ord, Enum, Show)

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

@@ -105,9 +105,14 @@ data Thread s a = Thread {
   }
   deriving Show
 
-isTestThreadId :: ThreadId -> Bool
-isTestThreadId (TestThreadId _) = True
-isTestThreadId _                = False
+isRacyThreadId :: ThreadId -> Bool
+isRacyThreadId (RacyThreadId _) = True
+isRacyThreadId _                = True
+
+isNotRacyThreadId :: ThreadId -> Bool
+isNotRacyThreadId (ThreadId _) = True
+isNotRacyThreadId _            = False
+
 
 bottomVClock :: VectorClock
 bottomVClock = VectorClock Map.empty
@@ -449,7 +454,7 @@ schedule thread@Thread{
 
     Fork a k -> do
       let nextTId = threadNextTId thread
-          tid' | threadRacy thread = setNonTestThread $ childThreadId tid nextTId
+          tid' | threadRacy thread = setRacyThread $ childThreadId tid nextTId
                | otherwise         = childThreadId tid nextTId
           thread'  = thread { threadControl = ThreadControl (k tid') ctl,
                               threadNextTId = nextTId + 1,
@@ -913,7 +918,7 @@ controlSimTraceST limit control mainAction =
   where
     mainThread =
       Thread {
-        threadId      = TestThreadId [],
+        threadId      = ThreadId [],
         threadControl = ThreadControl (runIOSim mainAction) MainFrame,
         threadBlocked = False,
         threadDone    = False,
@@ -923,7 +928,7 @@ controlSimTraceST limit control mainAction =
         threadLabel   = Just "main",
         threadNextTId = 1,
         threadStep    = 0,
-        threadVClock  = insertVClock (TestThreadId []) 0 bottomVClock,
+        threadVClock  = insertVClock (ThreadId []) 0 bottomVClock,
         threadEffect  = mempty,
         threadRacy    = False
       }
@@ -1353,7 +1358,7 @@ updateRaces newStep@Step{ stepThreadId = tid, stepEffect = newEffect }
 
       -- a new step cannot race with any threads that it just woke up
       new :: [StepInfo]
-      new | isTestThreadId tid  = []  -- test threads do not race
+      new | isNotRacyThreadId tid  = []  -- non-racy threads do not race
           | Set.null newConcurrent = []  -- cannot race with anything
           | justBlocking           = []  -- no need to defer a blocking transaction
           | otherwise              =
@@ -1373,7 +1378,7 @@ updateRaces newStep@Step{ stepThreadId = tid, stepEffect = newEffect }
           -- then any threads that it wakes up become non-concurrent also.
           let lessConcurrent = foldr Set.delete concurrent (effectWakeup newEffect) in
           if tid `elem` concurrent then
-            let theseStepsRace = not (isTestThreadId tid) && racingSteps step newStep
+            let theseStepsRace = isRacyThreadId tid && racingSteps step newStep
                 happensBefore  = step `happensBeforeStep` newStep
                 nondep' | happensBefore = nondep
                         | otherwise     = newStep : nondep