@@ -118,14 +118,12 @@ def exprs_dimensions(self):
         dims_implicit = {d for e in self.exprs for d in e.implicit_dims}
         return dims_explicit | dims_implicit
 
-    @cached_property
+    @property
     def guards_dimensions(self):
         """
         The Dimensions that appear explicitly in the guards.
         """
-        syms_guards = {d for e in self.guards.values() for d in e.free_symbols}
-        dims_guards = {i for i in syms_guards if i.is_Dimension}
-        return dims_guards
+        return self.guards.dimensions
 
     @cached_property
     def used_dimensions(self):
 
@@ -18,7 +18,7 @@
     AFFINE, INBOUND, PARALLEL, PARALLEL_IF_ATOMIC, PARALLEL_IF_PVT, SEQUENTIAL,
     VECTORIZED, Forward, PrefetchUpdate, Property, WithLock
 )
-from devito.symbolics import CallFromPointer, ListInitializer
+from devito.symbolics import CallFromPointer, ListInitializer, Macro
 from devito.tools import (
     Signer, as_tuple, ctypes_to_cstr, filter_ordered, filter_sorted, flatten
 )
@@ -61,6 +61,7 @@
     'Section',
     'Switch',
     'SyncSpot',
+    'ThreadFence',
     'TimedList',
     'Transfer',
     'Using',
@@ -1302,6 +1303,31 @@ def size(self):
         return self.ispace.size
 
 
+class ThreadFence(Call):
+
+    """
+    A memory fence, ordering a thread's accesses either side of it.
+
+    Threads exchanging work through a shared flag need memory ordering on both
+    sides: a release before publishing the flag, and an acquire after observing it.
+    This ensures the state associated with the flag is visible before it is used.
+    Without this ordering, updates may be observed in the wrong order and lost.
+
+    `__atomic_thread_fence` is a compiler builtin, so this renders the same in C
+    and in C++ and needs no header.
+    """
+
+    def __init__(self, order):
+        assert order in ('acquire', 'release')
+        super().__init__('__atomic_thread_fence',
+                         [Macro(f'__ATOMIC_{order.upper()}')])
+        self._order = order
+
+    @property
+    def order(self):
+        return self._order
+
+
 class Prodder(Call):
 
     """
 
@@ -5,14 +5,15 @@
 """
 
 from collections import Counter, defaultdict
-from functools import singledispatch
+from functools import cached_property, singledispatch
 from operator import ge, gt, le, lt
 
 import numpy as np
 from sympy import And, Expr, Ge, Gt, Le, Lt, Mul, true
 from sympy.logic.boolalg import BooleanFunction
 
 from devito.ir.support.space import Forward, IterationDirection
+from devito.ir.support.utils import pull_dims
 from devito.symbolics import CondEq, CondNe, IntDiv, search
 from devito.symbolics.manipulation import _uxreplace_handle, _uxreplace_registry
 from devito.tools import Pickable, as_tuple, frozendict, split
@@ -280,6 +281,15 @@ class Guards(frozendict):
     def get(self, d, v=true):
         return super().get(d, v)
 
+    @cached_property
+    def dimensions(self):
+        """
+        The Dimensions the guards read, that is those a guarded object must
+        be evaluated within.
+        """
+        return frozenset({d for v in self.values()
+                          for d in pull_dims(v, flag=False)})
+
     def has(self, d, cls):
         """
         True if the guard registered for `d` contains an instance of `cls`.
 
@@ -9,8 +9,9 @@
 from devito.finite_differences import EvalDerivative, IndexDerivative, Weights
 from devito.ir import (
     PARALLEL_IF_PVT, SEPARABLE, SEQUENTIAL, Cluster, ClusterGroup, ExprGeometry, Forward,
-    Interval, IntervalGroup, IterationSpace, LabeledVector, Queue, Vector, extrema,
-    maximum, minimum, normalize_properties, relax_properties, unbounded, vmax, vmin
+    Interval, IntervalGroup, IterationSpace, LabeledVector, Properties, Queue, Vector,
+    extrema, maximum, minimum, normalize_properties, relax_properties, unbounded, vmax,
+    vmin
 )
 from devito.passes.clusters.cse import _cse
 from devito.passes.clusters.utils import expose_tuning_knobs
@@ -19,8 +20,8 @@
     uxreplace
 )
 from devito.tools import (
-    Reconstructable, Stamp, as_mapper, as_tuple, flatten, frozendict, generator,
-    is_integer, split, timed_pass
+    Reconstructable, Stamp, as_mapper, as_tuple, flatten, generator, is_integer, split,
+    timed_pass
 )
 from devito.types import (
     CustomDimension, Eq, Hyperplane, IncrDimension, Indexed, ModuloDimension, Size,
@@ -288,6 +289,7 @@ def _do_generate(self, exprs, exclude, cbk_search, cbk_compose=None):
                     free_symbols = i.free_symbols
                 if {a.function for a in free_symbols} & exclude:
                     continue
+
                 mapper.add(i, make, terms)
 
         return mapper
@@ -304,6 +306,31 @@ def __init__(self, sregistry, options, platform):
     def process(self, clusters):
         return self._process_fatd(clusters, 1, xtracted=[])
 
+    @classmethod
+    def _make_exclude(cls, clusters, d, p):
+        """
+        The symbols an extraction must not touch.
+        """
+        # Rule out extractions that would break data dependencies
+        exclude = set().union(*[c.scope.writes for c in clusters])
+
+        # Rule out extractions that depend on the Dimension currently investigated,
+        # as they clearly wouldn't be invariants
+        exclude.update({d, *p.sub_iterators})
+
+        # An extraction is hoisted out of `d`, but it inherits its guard as it
+        # is, so it must not be hoisted past any Dimension the guard reads, or
+        # the guard would be evaluated where it is not defined. Excluding those
+        # Dimensions keeps the extraction inside the loops defining them. A
+        # SEQUENTIAL Dimension is exempt, its loop enclosing the extraction's own
+        for c in clusters:
+            exclude.update(
+                i for i in c.guards.dimensions
+                if not c.properties.is_sequential(i._defines)
+            )
+
+        return exclude
+
     def callback(self, clusters, prefix, xtracted=None):
         if not prefix:
             return clusters
@@ -314,12 +341,7 @@ def callback(self, clusters, prefix, xtracted=None):
         if d.is_Virtual:
             return clusters
 
-        # Rule out extractions that would break data dependencies
-        exclude = set().union(*[c.scope.writes for c in clusters])
-
-        # Rule out extractions that depend on the Dimension currently investigated,
-        # as they clearly wouldn't be invariants
-        exclude.update({d, *p.sub_iterators})
+        exclude = self._make_exclude(clusters, d, p)
 
         key = lambda c: self._lookup_key(c, d)
         processed = list(clusters)
@@ -343,7 +365,7 @@ def callback(self, clusters, prefix, xtracted=None):
     def _lookup_key(self, c, d):
         ispace = c.ispace.reset()
         intervals = c.ispace.intervals.drop(d).reset()
-        properties = frozendict({d: relax_properties(v) for d, v in c.properties.items()})
+        properties = Properties({d: relax_properties(v) for d, v in c.properties.items()})
 
         return AliasKey(ispace, intervals, c.dtype, c.guards, properties)
 
 
@@ -7,7 +7,7 @@
 from devito.ir import (
     AsyncCall, AsyncCallable, BlankLine, Call, Callable, Conditional, DummyEq, DummyExpr,
     EntryFunction, FindNodes, FindSymbols, Increment, Iteration, List, PointerCast,
-    Return, ThreadCallable, Transformer, While, make_callable, maybe_alias
+    Return, ThreadCallable, ThreadFence, Transformer, While, make_callable, maybe_alias
 )
 from devito.passes.iet.definitions import DataManager
 from devito.passes.iet.engine import iet_pass
@@ -86,6 +86,11 @@ def _lower_async_objs(iet, tracker=None, sregistry=None, **kwargs):
                 arguments.append(i)
         activation.extend([DummyExpr(FieldFromComposite(i.base, sdata[d]), i)
                            for i in arguments])
+
+        # Publishing the request must happen last. Everything the thread depends on
+        # must be visible before this flag is set. `volatile` does not provide that
+        # ordering, so weakly ordered targets could otherwise observe stale state.
+        activation.append(ThreadFence('release'))
         activation.append(
             DummyExpr(FieldFromComposite(sdata.symbolic_flag, sdata[d]), 2)
         )
@@ -138,12 +143,17 @@ def _(iet, key=None, tracker=None, sregistry=None, **kwargs):
     tbase = threads.indexed
 
     # Prepend the SharedData fields available upon thread activation
-    preactions = [DummyExpr(i, FieldFromPointer(i.base, sbase)) for i in ncfields]
+    preactions = [ThreadFence('acquire')]
+    preactions.extend(DummyExpr(i, FieldFromPointer(i.base, sbase))
+                      for i in ncfields)
     preactions.append(BlankLine)
 
     # Append the flag reset
     postactions = [List(body=[
         BlankLine,
+        # Whatever the task produced -- data in a buffer, a lock handed back --
+        # has to be visible before the flag says it is done.
+        ThreadFence('release'),
         DummyExpr(FieldFromPointer(sdata.symbolic_flag, sbase), 1)
     ])]
 
 
@@ -7,7 +7,7 @@
 from devito.exceptions import CompilationError
 from devito.ir.iet import (
     AsyncCall, AsyncCallable, BlankLine, Block, BusyWait, Call, Callable, Conditional,
-    DummyExpr, List, SyncSpot, Transformer, derive_parameters, make_callable
+    DummyExpr, List, SyncSpot, ThreadFence, Transformer, derive_parameters, make_callable
 )
 from devito.ir.iet.visitors import Visitor
 from devito.ir.support import (
@@ -53,7 +53,11 @@ def _make_waitlock(self, iet, sync_ops, *args):
     def _make_releaselock(self, iet, sync_ops, *args):
         pre = []
         pre.append(BusyWait(Or(*[CondNe(s.handle, 2) for s in sync_ops])))
+        pre.append(ThreadFence('acquire'))
         pre.extend(DummyExpr(s.handle, 0) for s in sync_ops)
+        # Hand the lock back before anything that follows can be observed --
+        # in particular before the request that asks the thread to refill it.
+        pre.append(ThreadFence('release'))
 
         name = self.sregistry.make_name(prefix="release_lock")
         parameters = derive_parameters(pre, ordering='canonical')
 
@@ -10,7 +10,7 @@
 )
 from devito import (  # noqa
     NODE, Abs, ConditionalDimension, Constant, DefaultDimension, Derivative, Dimension,
-    Eq, Function, Ge, Grid, Inc, Lt, Operator, SparseTimeFunction, SubDimension,
+    Eq, Function, Ge, Grid, Inc, Lt, Max, Operator, SparseTimeFunction, SubDimension,
     TimeFunction, configuration, cos, dimensions, div, exp, first_derivative, floor, grad,
     norm, sin, solve, sqrt, switchconfig, transpose
 )
@@ -2512,6 +2512,43 @@ def test_contraction_with_conditional(self):
         assert len(FindNodes(Conditional).visit(op)) == 1
         assert np.all(u.data[6:] == 1.42)
 
+    def test_no_extraction_guarded_by_unspanned_dimension(self):
+        """
+        An alias is scheduled over the Dimensions it spans, but it inherits its
+        guard as it is. A guard reading a Dimension the alias does not span
+        would then be evaluated in a loop nest that does not define it, giving
+        code that does not compile.
+
+        Here `sin(...)` depends on `y` alone while the condition reads both `x`
+        and `y`, which is what an immersed boundary condition produces.
+        """
+        grid = Grid(shape=(16, 16))
+        x, y = grid.dimensions
+
+        sdf = Function(name='sdf', grid=grid)
+        sdf.data[:] = 1.
+
+        cond = ConditionalDimension(name='inside', parent=y, condition=Ge(sdf, 0))
+
+        u = TimeFunction(name='u', grid=grid, space_order=4)
+        u.data[:] = 1.
+
+        # Expensive enough to be extracted, and `y`-only
+        prof = sin(Max(0., 1. - y)) + sin(Max(0., 1. + y))
+
+        eqn = Eq(u.forward, u.laplace + prof*u, implicit_dims=[cond])
+
+        op = Operator(eqn, opt=('advanced', {'cire-mingain': 0, 'openmp': False}))
+
+        # No temporary may be created over fewer Dimensions than the guard reads
+        for i in FindSymbols().visit(op):
+            if i.is_Array:
+                assert {x, y}.issubset(set(i.dimensions))
+
+        # Used to fail to compile with "'x' undeclared"
+        op.apply(time_M=2)
+        assert np.all(np.isfinite(u.data[:]))
+
     def test_collection_from_conditional(self):
         nt = 10
         grid = Grid(shape=(10, 10))
 
@@ -413,11 +413,16 @@ def test_tasking_in_isolation(self, opt):
         assert str(sections[0].body[0].body[0].body[0].body[0]) == 'while(lock0[0] == 0);'
         body = op._func_table['release_lock0'].root.body
         assert str(body.body[0].condition) == 'Ne(lock0[0], 2)'
-        assert str(body.body[1]) == 'lock0[0] = 0;'
+        # An acquire fence pairs with the thread's release before the lock is
+        # read back, and a release fence publishes it before the next request
+        assert 'atomic_thread_fence' in str(body.body[1])
+        assert str(body.body[2]) == 'lock0[0] = 0;'
+        assert 'atomic_thread_fence' in str(body.body[3])
         body = op._func_table['activate0'].root.body
         assert str(body.body[0].condition) == 'Ne(sdata0[0].flag, 1)'
         assert str(body.body[1]) == 'sdata0[0].time = time;'
-        assert str(body.body[2]) == 'sdata0[0].flag = 2;'
+        assert 'atomic_thread_fence' in str(body.body[2])
+        assert str(body.body[3]) == 'sdata0[0].flag = 2;'
 
         op.apply(time_M=nt-2)
 
@@ -529,12 +534,15 @@ def test_tasking_forcefuse(self):
                 'while(lock0[0] == 0 || lock1[0] == 0);')  # Wait-lock
         body = op._func_table['release_lock0'].root.body
         assert str(body.body[0].condition) == 'Ne(lock0[0], 2) | Ne(lock1[0], 2)'
-        assert str(body.body[1]) == 'lock0[0] = 0;'  # Set-lock
-        assert str(body.body[2]) == 'lock1[0] = 0;'  # Set-lock
+        assert 'atomic_thread_fence' in str(body.body[1])
+        assert str(body.body[2]) == 'lock0[0] = 0;'  # Set-lock
+        assert str(body.body[3]) == 'lock1[0] = 0;'  # Set-lock
+        assert 'atomic_thread_fence' in str(body.body[4])
         body = op._func_table['activate0'].root.body
         assert str(body.body[0].condition) == 'Ne(sdata0[0].flag, 1)'  # Wait-thread
         assert str(body.body[1]) == 'sdata0[0].time = time;'
-        assert str(body.body[2]) == 'sdata0[0].flag = 2;'
+        assert 'atomic_thread_fence' in str(body.body[2])
+        assert str(body.body[3]) == 'sdata0[0].flag = 2;'
         assert len(op._func_table) == 5
         exprs = FindNodes(Expression).visit(op._func_table['copy_to_host0'].root)
         b = 21 if configuration['language'] == 'openacc' else 20  # No `qid` w/ OMP
@@ -597,8 +605,9 @@ def test_tasking_multi_output(self):
         assert str(sections[0].body[0].body[0].body[0].body[0]) ==\
             'while(lock0[t2] == 0);'
         body = op1._func_table['release_lock0'].root.body
+        assert 'atomic_thread_fence' in str(body.body[1])
         for i in range(3):
-            assert 'lock0[t' in str(body.body[1 + i])  # Set-lock
+            assert 'lock0[t' in str(body.body[2 + i])  # Set-lock
         body = op1._func_table['activate0'].root.body
         assert str(body.body[-1]) == 'sdata0[wi0].flag = 2;'
         assert len(op1._func_table) == 5
 
@@ -12,7 +12,7 @@
 from devito.ir.iet import (
     Call, Callable, CGen, Conditional, Definition, Dereference, DeviceCall, DummyExpr,
     ElementalFunction, FindNodes, FindSymbols, Iteration, KernelLaunch, Lambda, List,
-    Switch, Transformer, filter_iterations, make_callable, make_efunc,
+    Switch, ThreadFence, Transformer, filter_iterations, make_callable, make_efunc,
     retrieve_iteration_tree
 )
 from devito.ir.iet.visitors import sorted_efuncs
@@ -118,6 +118,23 @@ def test_nested_calls_cgen():
     assert str(code) == 'foo(bar());'
 
 
+def test_thread_fence_cgen():
+    """
+    A fence renders as the builtin, which is valid in C and C++ alike.
+
+    Threads that hand work to each other through a shared flag need one either
+    side of the handshake; without them the stores can be observed out of order
+    and a hand-off is lost.
+    """
+    assert str(CGen().visit(ThreadFence('acquire'))) == \
+        '__atomic_thread_fence(__ATOMIC_ACQUIRE);'
+    assert str(CGen().visit(ThreadFence('release'))) == \
+        '__atomic_thread_fence(__ATOMIC_RELEASE);'
+
+    with pytest.raises(AssertionError):
+        ThreadFence('seq_cst')
+
+
 @pytest.mark.parametrize('mode,expected', [
     ('basics', '["x"]'),
     ('symbolics', '["f"]')