Simon Jakobi pushed to branch wip/sjakobi/nonmoving-gc-test-fixes at Glasgow Haskell Compiler / GHC

Commits:

• 80465707
  by Simon Jakobi at 2026-08-09T05:46:40+02:00

  rts/js: Implement eq_thread, and test Eq/Ord ThreadId (#16761)
  
  Since d1f3c63701 (#16761), Eq ThreadId is implemented via the RTS
  function eq_thread, but the JS RTS never provided it, so comparing
  ThreadIds for equality on the JS backend crashed with
  
      ReferenceError: h$eq_thread is not defined
  
  Like the C implementation, h$eq_thread uses pointer equality: The JS
  RTS has exactly one thread object per thread.
  
  Previously no test exercised eq_thread directly — the missing JS
  implementation was only caught incidentally by listThreads1. Add a
  test covering equality, its stability across GC, and agreement with
  Ord.
  
  Assisted-by: Claude Fable 5
  

• 91790b45
  by Simon Jakobi at 2026-08-09T05:46:40+02:00

  testsuite: Make listThreads1 insensitive to the RTS's own threads
  
  listThreads1 expected `listThreads` to return exactly [ThreadId 1]. That
  holds only under a non-threaded RTS. Under a threaded RTS however there
  are more threads present, so we change the test to simply check that
  `myThreadId` is present in the list.
  
  Assisted-by: Claude Opus 5
  

6 changed files:

• libraries/base/tests/listThreads1.hs
• libraries/base/tests/listThreads1.stdout
• rts/js/thread.js
• + testsuite/tests/concurrent/should_run/T16761.hs
• + testsuite/tests/concurrent/should_run/T16761.stdout
• testsuite/tests/concurrent/should_run/all.T

Changes:

 import GHC.Conc.Sync

+-- Regression test for the JS backend's ListThreadsOp, which used to omit the

+-- running thread. Whatever other threads the RTS has is irrelevant here.

 main :: IO ()

-main = listThreads >>= print

+main = do

+  tid <- myThreadId

+  ts <- listThreads

+  print (tid `elem` ts)

-[ThreadId 1]

+True

   RETURN_UBX_TUP2((t.tid / Math.pow(2,32))>>>0, (t.tid & 0xFFFFFFFF)>>>0);

 }

+function h$eq_thread(t1,t2) {

+  return t1 === t2 ? 1 : 0;

+}

+

 function h$cmp_thread(t1,t2) {

   if(t1.tid < t2.tid) return -1;

   if(t1.tid > t2.tid) return 1;

+-- Test that Eq ThreadId is based on thread identity (eq_thread),

+-- not on the numeric thread id, which may wrap around (#16761).

+module Main (main) where

+

+import Control.Concurrent

+import System.Mem (performGC)

+

+main :: IO ()

+main = do

+  t0 <- myThreadId

+  print (t0 == t0)

+

+  mv <- newEmptyMVar

+  _ <- forkIO (myThreadId >>= putMVar mv)

+  tChild <- takeMVar mv

+  print (t0 == tChild)

+  print (tChild == tChild)

+

+  -- Equality must be stable even after the GC moves the TSOs.

+  performGC

+  print (t0 == t0)

+

+  -- Ord must agree with Eq.

+  print (compare t0 tChild /= EQ)

+  print (compare t0 t0 == EQ)

+True

+False

+True

+True

+True

+True

 # Check forkIO exception determinism under optimization

 test('T13330', normal, compile_and_run, ['-O'])

+test('T16761', normal, compile_and_run, [''])

+

 test('T26341', normal, compile_and_run, [''])

 # Test EINTR for async I/O interrupted by an exception (#26341)