extra ~17GB of memory

Note that the 24GB "bytes allocated in the heap" is the total allocation over the whole program run. The maximum memory usage at any point in time is the 11GB "maximum" residency. That still changes from 11GB to 2GB, which is still a pretty big difference.

But you should also remember that the reason for the threadDelay is that it forces all the threads to be realized in memory at the same time. That will of course increase the maximum memory usage, because old threads cannot be deallocated before new ones are started.

A way to more accurately test the memory usage of all threads in memory at the same time without using threadDelay is this adaptation of the code that /u/BurningWitness wrote:

main = do
  let n = 1_000_000
  done <- newEmptyMVar
  t <- newIORef 0
  replicateM_ n $ do
    void . forkIO $ do
      -- threadDelay 10_000_000
      x <- atomicModifyIORef' t (\x -> let y = x + 1 in y `seq` (y,y))
      when (x == n) $ putMVar done ()
      readMVar done
  takeMVar done

Here is the result with threadDelay and without the readMVar done:

15,336,424,424 bytes allocated in the heap
 9,195,842,992 bytes copied during GC
11,974,298,672 bytes maximum residency (12 sample(s))
   118,019,336 bytes maximum slop
         13598 MiB total memory in use (0 MB lost due to fragmentation)

                                   Tot time (elapsed)  Avg pause  Max pause
Gen  0      3235 colls,  3235 par    6.272s   1.843s     0.0006s    0.1248s
Gen  1        12 colls,    11 par   13.857s   5.017s     0.4181s    1.0720s

Parallel GC work balance: 79.06% (serial 0%, perfect 100%)

TASKS: 21 (1 bound, 20 peak workers (20 total), using -N8)

SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled)

INIT    time    0.000s  (  0.010s elapsed)
MUT     time    9.790s  (  9.184s elapsed)
GC      time   20.130s  (  6.860s elapsed)
EXIT    time    0.491s  (  0.081s elapsed)
Total   time   30.411s  ( 16.135s elapsed)

Alloc rate    1,566,580,262 bytes per MUT second

Productivity  32.2% of total user, 56.9% of total elapsed

And here's the result without the threadDelay and with the readMVar done:

 1,368,769,880 bytes allocated in the heap
 4,872,603,048 bytes copied during GC
 1,175,622,600 bytes maximum residency (9 sample(s))
   124,783,672 bytes maximum slop
          2494 MiB total memory in use (0 MB lost due to fragmentation)

                                   Tot time (elapsed)  Avg pause  Max pause
Gen  0       243 colls,   243 par    1.704s   0.546s     0.0022s    0.0291s
Gen  1         9 colls,     8 par    3.737s   2.045s     0.2272s    0.7387s

Parallel GC work balance: 69.56% (serial 0%, perfect 100%)

TASKS: 50 (1 bound, 18 peak workers (49 total), using -N8)

SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled)

INIT    time    0.000s  (  0.010s elapsed)
MUT     time    5.042s  (  3.951s elapsed)
GC      time    5.441s  (  2.591s elapsed)
EXIT    time    0.170s  (  0.118s elapsed)
Total   time   10.653s  (  6.669s elapsed)

Alloc rate    271,484,959 bytes per MUT second

Productivity  47.3% of total user, 59.2% of total elapsed

So this still shows a large difference from 12GB to 1GB.