(cherry picked from commit a3b8375e)

The mark thread is not joinable as we detach from it on creation.

(cherry picked from commit ca1ef0e7)

pthread_join returns its error code and apparently doesn't set errno.

(cherry picked from commit c488ac73)

Ensure that the the free variables have been pushed to the update
remembered set before we zero the slop.

(cherry picked from commit 134f7599)

(cherry picked from commit 35c22991)

After a THROWTO message has been handle the message closure is
overwritten by a NULL message. We must ensure that the original
closure's pointers continue to be visible to the nonmoving GC.

(cherry picked from commit 6c2faf15)

The TSAN rework (specifically aad1f803) introduced a subtle regression
in GC.c, swapping `g0` in place of `gen`. Whoops!

Fixes #18997.

(cherry picked from commit 21c807df)

See Note [Racing weak pointer evacuation] for all of the gory details.

When fixing #17962 I neglected to consider that --export-dynamic is only
supported on ELF platforms.

(cherry picked from commit 35799dda)

Fix the previous backport; this function was dead code in master but is
still needed due to ProfHeap.c in ghc-8.10.

Since the latter wants to call getRTSStats.

While on face value this seems a bit heavy, I think it's far better than
enforcing ordering on every access.

We can generally be pretty relaxed in the barriers here since the timer
thread is a loop.

Previously `initScheduler` would attempt to pause the ticker and in so
doing acquire the ticker mutex. However, initTicker, which is
responsible for initializing said mutex, hadn't been called
yet.

This avoids #17289.

This suppresses the other side of a race during shutdown.

Previously the `current_value`, `first_watch_queue_entry`, and
`num_updates` fields of `StgTVar` were marked as `volatile` in an
attempt to provide strong ordering. Of course, this isn't sufficient.

We now use proper atomic operations. In most of these cases I strengthen
the ordering all the way to SEQ_CST although it's possible that some
could be weakened with some thought.

This fixes a potentially harmful race where we failed to synchronize
before looking at a TVar's current_value.

Also did a bit of refactoring to avoid abstract over management of
max_commits.

GHC GitLab CI authored 4 years ago and Ben Gamari committed 4 years ago

Here we are doing lazy initialization; it's okay if we do the check more
than once, hence relaxed operation is fine.

Fixes #17275.

After a few attempts at shoring up the previous implementation, I ended
up turning to the literature and now use the proven implementation,

> N.M. Lê, A. Pop, A.Cohen, and F.Z. Nardelli. "Correct and Efficient
> Work-Stealing for Weak Memory Models". PPoPP'13, February 2013,
> ACM 978-1-4503-1922/13/02.

Note only is this approach formally proven correct under C11 semantics
but it is also proved to be a bit faster in practice.

Not only is this in general a good idea, but it turns out that GCC
unrolls the retry loop, resulting is massive code bloat in critical
parts of the RTS (e.g. `evacuate`).

GHC GitLab CI authored 4 years ago and Ben Gamari committed 4 years ago

Ensure that the GC leader synchronizes with workers before calling
stat_endGC.

Previously we would take all capabilities but fail to join on the thread
itself, potentially resulting in a leaked thread.

By taking all_tasks_mutex in stat_exit. Also better-document the fact
that the task statistics are protected by all_tasks_mutex.

This fixes two potentially problematic data races in the StablePtr
implementation:

 * We would fail to RELEASE the stable pointer table when enlarging it,
   causing other cores to potentially see uninitialized memory.

 * We would fail to ACQUIRE when dereferencing a stable pointer.