I am beginning to have second thoughts on whether the thunk update protocol we currently use (see `Note [Heap memory barriers]` in `SMP.h`) is safe on weakly ordered platforms. The problem is that lazy blackholing may mean that multiple threads race to update a thunk, resulting in a value being exposed via an indirection before being made available to other cores. Specifically, I am worried about interleavings like the following (where `t` is a thunk being updated and `a` and `b` are two evaluation results): ``` Thread A Thread B Thread C --------- --------- --------- t.indirectee=a t.indirectee=b release fence t.info=BLACKHOLE read t.info inspect t.indirectee release fence t.info=BLACKHOLE ``` Specifically, we see here that Thread A writes its result, `a` to the indirectee. Typically, the soundness of the update of the `indirectee` field is guaranteed by the release ordering of the `t.info=BLACKHOLE` store, guaranteeing that `a` is visible to readers when the closure becomes a blackhole. However, in this case Thread B races to update `indirectee`, storing its own result `b`. Meanwhile, thread `C` enters `t` (which is now a blackhole), inspects `t.indirectee`, and is therefore exposed to `b` before Thread B has guaranteed that it is visible. This seems like an extrodinarily narrow race, but AFAICT it's a race nevertheless.