Design and Verification of Adaptive Cache Coherence Protocols ...

4.5.2 Mapping from Base to CRF
We de ne a mapping function that maps terms of Base to terms of CRF. For Base terms in
which the message queues are all empty, it is straightforward to nd the corresponding CRF
terms. We call such Base terms drained terms. There is a one-to-one correspondence between
the drained terms of Base and the terms of CRF. For Base terms that contain non-empty
message queues, we apply a set of draining rules so that all the messages in transit will be
removed from the queues eventually.
The intuition behind the draining rules is that message queues can always be drained via
forward or backward draining. With forward draining, we canmove a message to its destination
and consume the message at the destination with backward draining, we canmove a message
back to its source and reclaim the message at the source. While forward draining is preferred
since it can be achieved by employing some existing rules, backward draining is needed when
forward draining would lead to non-deterministic results. This can happen, for example, when
multiple Wb messages (from di erent caches) regarding the same address are in transit to the
memory.
There are many di erentways to drain messages from the network. We use forward draining
for messages from the memory to caches, and backward draining for messages from caches to
the memory. For example, to drain a Cache message in the memory's outgoing queue, we rst
pass the message to the destination's incoming queue, and then cache the data in the cache.
To drain a Wb message in the memory's incoming queue, we rst pass the message back to the
source's outgoing queue and then restore the cache state.
Backward Rules: The Backward-Message-Cache-to-Mem rule passes a message from the
incoming queue of the memory back to the outgoing queue of the source cache. The Backward-
C-Send-Wb and Backward-C-Send-CacheReq rules allow acache to retrieve Wb and CacheReq
messages from the network and recover corresponding cache cells.
Backward-Message-Cache-to-Mem Rule
Sys(Msite(mem, min msg, mout), Site(id , cache, cin, cout, pmb, mpb, proc) j sites)
if Src(msg)=id
! Sys(Msite(mem, min, mout), Site(id , cache, cin, msg cout, pmb, mpb, proc) j sites)
Backward-C-Send-Wb Rule
Site(id , Cell(a,v,WbPending) j cache, in, out Msg(id ,H,Wb,a,v), pmb, mpb, proc)
! Site(id , Cell(a,v,Dirty) j cache, in, out, pmb, mpb, proc)
Backward-C-Send-CacheReq Rule
Site(id , Cell(a,-,CachePending) j cache, in, out Msg(id ,H,CacheReq,a), pmb, mpb, proc)
! Site(id , cache, in, out, pmb, mpb, proc)
The backward rules above are the backward version of the Message-Cache-to-Mem, C-Send-
Wb and C-Send-CacheReq rules, and can be used to drain the Wb and CacheReq messages. It
is trivial to show that Lemmas 1 and 2 still hold in the presence of the backward rules.
77