MOESI_CMP_token-L2cache.sm revision 14184 
1/*
2 * Copyright (c) 1999-2013 Mark D. Hill and David A. Wood
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29machine(MachineType:L2Cache, "Token protocol")
30 : CacheMemory * L2cache;
31   int N_tokens;
32   Cycles l2_request_latency := 5;
33   Cycles l2_response_latency := 5;
34   bool filtering_enabled := "True";
35
36   // L2 BANK QUEUES
37   // From local bank of L2 cache TO the network
38 
39   // this L2 bank -> a local L1 || mod-directory
40   MessageBuffer * responseFromL2Cache, network="To", virtual_network="4",
41        vnet_type="response";
42   // this L2 bank -> mod-directory
43   MessageBuffer * GlobalRequestFromL2Cache, network="To", virtual_network="2",
44        vnet_type="request";
45   // this L2 bank -> a local L1
46   MessageBuffer * L1RequestFromL2Cache, network="To", virtual_network="1",
47        vnet_type="request";
48 
49 
50   // FROM the network to this local bank of L2 cache
51 
52   // a local L1 || mod-directory -> this L2 bank
53   MessageBuffer * responseToL2Cache, network="From", virtual_network="4",
54        vnet_type="response";
55   MessageBuffer * persistentToL2Cache, network="From", virtual_network="3",
56        vnet_type="persistent";
57   // mod-directory -> this L2 bank
58   MessageBuffer * GlobalRequestToL2Cache, network="From", virtual_network="2",
59        vnet_type="request";
60   // a local L1 -> this L2 bank
61   MessageBuffer * L1RequestToL2Cache, network="From", virtual_network="1",
62        vnet_type="request";
63
64{
65  // STATES
66  state_declaration(State, desc="L2 Cache states", default="L2Cache_State_I") {
67    // Base states
68    NP, AccessPermission:Invalid, desc="Not Present";
69    I, AccessPermission:Invalid, desc="Idle";
70    S, AccessPermission:Read_Only, desc="Shared, not present in any local L1s";
71    O, AccessPermission:Read_Only, desc="Owned, not present in any L1s";
72    M, AccessPermission:Read_Write, desc="Modified, not present in any L1s";
73
74    // Locked states
75    I_L, AccessPermission:Busy, "I^L", desc="Invalid, Locked";
76    S_L, AccessPermission:Busy, "S^L", desc="Shared, Locked";
77  }
78
79  // EVENTS
80  enumeration(Event, desc="Cache events") {
81
82    // Requests
83    L1_GETS,             desc="local L1 GETS request";
84    L1_GETS_Last_Token,    desc="local L1 GETS request";
85    L1_GETX,             desc="local L1 GETX request";
86    L1_INV,              desc="L1 no longer has tokens";
87    Transient_GETX,      desc="A GetX from another processor";
88    Transient_GETS,      desc="A GetS from another processor";
89    Transient_GETS_Last_Token,   desc="A GetS from another processor";
90
91    // events initiated by this L2
92    L2_Replacement,     desc="L2 Replacement", format="!r";
93
94    // events of external L2 responses
95
96    // Responses
97    Writeback_Tokens,               desc="Received a writeback from L1 with only tokens (no data)";
98    Writeback_Shared_Data,               desc="Received a writeback from L1 that includes clean data";
99    Writeback_All_Tokens,    desc="Received a writeback from L1";
100    Writeback_Owned,                desc="Received a writeback from L1";
101
102
103    Data_Shared,             desc="Received a data message, we are now a sharer";
104    Data_Owner,              desc="Received a data message, we are now the owner";
105    Data_All_Tokens,   desc="Received a data message, we are now the owner, we now have all the tokens";
106    Ack,                     desc="Received an ack message";
107    Ack_All_Tokens,          desc="Received an ack message, we now have all the tokens";
108
109    // Lock/Unlock
110    Persistent_GETX,     desc="Another processor has priority to read/write";
111    Persistent_GETS,     desc="Another processor has priority to read";
112    Persistent_GETS_Last_Token, desc="Another processor has priority to read";
113    Own_Lock_or_Unlock,  desc="This processor now has priority";
114  }
115
116  // TYPES
117
118  // CacheEntry
119  structure(Entry, desc="...", interface="AbstractCacheEntry") {
120    State CacheState,        desc="cache state";
121    bool Dirty,              desc="Is the data dirty (different than memory)?";
122    int Tokens,              desc="The number of tokens we're holding for the line";
123    DataBlock DataBlk,       desc="data for the block";
124  }
125
126  structure(DirEntry, desc="...", interface="AbstractEntry") {
127    Set Sharers,            desc="Set of the internal processors that want the block in shared state";
128    bool exclusive, default="false", desc="if local exclusive is likely";
129  }
130
131  structure(PerfectCacheMemory, external="yes") {
132    void allocate(Addr);
133    void deallocate(Addr);
134    DirEntry lookup(Addr);
135    bool isTagPresent(Addr);
136  }
137
138  structure(PersistentTable, external="yes") {
139    void persistentRequestLock(Addr, MachineID, AccessType);
140    void persistentRequestUnlock(Addr, MachineID);
141    MachineID findSmallest(Addr);
142    AccessType typeOfSmallest(Addr);
143    void markEntries(Addr);
144    bool isLocked(Addr);
145    int countStarvingForAddress(Addr);
146    int countReadStarvingForAddress(Addr);
147  }
148
149  PersistentTable persistentTable;
150  PerfectCacheMemory localDirectory, template="<L2Cache_DirEntry>";
151
152  Tick clockEdge();
153  void set_cache_entry(AbstractCacheEntry b);
154  void unset_cache_entry();
155  MachineID mapAddressToMachine(Addr addr, MachineType mtype);
156
157  Entry getCacheEntry(Addr address), return_by_pointer="yes" {
158    Entry cache_entry := static_cast(Entry, "pointer", L2cache.lookup(address));
159    return cache_entry;
160  }
161
162  DirEntry getDirEntry(Addr address), return_by_pointer="yes" {
163    return localDirectory.lookup(address);
164  }
165
166  void functionalRead(Addr addr, Packet *pkt) {
167    testAndRead(addr, getCacheEntry(addr).DataBlk, pkt);
168  }
169
170  int functionalWrite(Addr addr, Packet *pkt) {
171    int num_functional_writes := 0;
172    num_functional_writes := num_functional_writes +
173        testAndWrite(addr, getCacheEntry(addr).DataBlk, pkt);
174    return num_functional_writes;
175  }
176
177  int getTokens(Entry cache_entry) {
178    if (is_valid(cache_entry)) {
179      return cache_entry.Tokens;
180    } else {
181      return 0;
182    }
183  }
184
185  State getState(Entry cache_entry, Addr addr) {
186    if (is_valid(cache_entry)) {
187      return cache_entry.CacheState;
188    } else if (persistentTable.isLocked(addr)) {
189      return State:I_L;
190    } else {
191      return State:NP;
192    }
193  }
194
195  void setState(Entry cache_entry, Addr addr, State state) {
196
197    if (is_valid(cache_entry)) {
198      // Make sure the token count is in range
199      assert(cache_entry.Tokens >= 0);
200      assert(cache_entry.Tokens <= max_tokens());
201      assert(cache_entry.Tokens != (max_tokens() / 2));
202
203      // Make sure we have no tokens in L
204      if ((state == State:I_L) ) {
205        assert(cache_entry.Tokens == 0);
206      }
207
208      // in M and E you have all the tokens
209      if (state == State:M ) {
210        assert(cache_entry.Tokens == max_tokens());
211      }
212
213      // in NP you have no tokens
214      if (state == State:NP) {
215        assert(cache_entry.Tokens == 0);
216      }
217
218      // You have at least one token in S-like states
219      if (state == State:S ) {
220        assert(cache_entry.Tokens > 0);
221      }
222
223      // You have at least half the token in O-like states
224      if (state == State:O ) {
225        assert(cache_entry.Tokens > (max_tokens() / 2));
226      }
227
228      cache_entry.CacheState := state;
229    }
230  }
231
232  AccessPermission getAccessPermission(Addr addr) {
233    Entry cache_entry := getCacheEntry(addr);
234    if(is_valid(cache_entry)) {
235      return L2Cache_State_to_permission(cache_entry.CacheState);
236    }
237
238    return AccessPermission:NotPresent;
239  }
240
241  void setAccessPermission(Entry cache_entry, Addr addr, State state) {
242    if (is_valid(cache_entry)) {
243      cache_entry.changePermission(L2Cache_State_to_permission(state));
244    }
245  }
246
247  void removeSharer(Addr addr, NodeID id) {
248
249    if (localDirectory.isTagPresent(addr)) {
250      DirEntry dir_entry := getDirEntry(addr);
251      dir_entry.Sharers.remove(id);
252      if (dir_entry.Sharers.count() == 0) {
253        localDirectory.deallocate(addr);
254      }
255    }
256  }
257
258  bool sharersExist(Addr addr) {
259    if (localDirectory.isTagPresent(addr)) {
260      DirEntry dir_entry := getDirEntry(addr);
261      if (dir_entry.Sharers.count() > 0) {
262        return true;
263      }
264      else {
265        return false;
266      }
267    }
268    else {
269      return false;
270    }
271  }
272
273  bool exclusiveExists(Addr addr) {
274    if (localDirectory.isTagPresent(addr)) {
275      DirEntry dir_entry := getDirEntry(addr);
276      if (dir_entry.exclusive) {
277        return true;
278      }
279      else {
280        return false;
281      }
282    }
283    else {
284      return false;
285    }
286  }
287
288  // assumes that caller will check to make sure tag is present
289  Set getSharers(Addr addr) {
290    DirEntry dir_entry := getDirEntry(addr);
291    return dir_entry.Sharers;
292  }
293
294  void setNewWriter(Addr addr, NodeID id) {
295    if (localDirectory.isTagPresent(addr) == false) {
296      localDirectory.allocate(addr);
297    }
298    DirEntry dir_entry := getDirEntry(addr);
299    dir_entry.Sharers.clear();
300    dir_entry.Sharers.add(id);
301    dir_entry.exclusive := true;
302  }
303
304  void addNewSharer(Addr addr, NodeID id) {
305    if (localDirectory.isTagPresent(addr) == false) {
306      localDirectory.allocate(addr);
307    }
308    DirEntry dir_entry := getDirEntry(addr);
309    dir_entry.Sharers.add(id);
310    // dir_entry.exclusive := false;
311  }
312
313  void clearExclusiveBitIfExists(Addr addr) {
314    if (localDirectory.isTagPresent(addr)) {
315      DirEntry dir_entry := getDirEntry(addr);
316      dir_entry.exclusive := false;
317    }
318  }
319
320  // ** OUT_PORTS **
321  out_port(globalRequestNetwork_out, RequestMsg, GlobalRequestFromL2Cache);
322  out_port(localRequestNetwork_out, RequestMsg, L1RequestFromL2Cache);
323  out_port(responseNetwork_out, ResponseMsg, responseFromL2Cache);
324
325
326
327  // ** IN_PORTS **
328
329  // Persistent Network
330  in_port(persistentNetwork_in, PersistentMsg, persistentToL2Cache) {
331    if (persistentNetwork_in.isReady(clockEdge())) {
332      peek(persistentNetwork_in, PersistentMsg) {
333        assert(in_msg.Destination.isElement(machineID));
334
335        if (in_msg.Type == PersistentRequestType:GETX_PERSISTENT) {
336          persistentTable.persistentRequestLock(in_msg.addr, in_msg.Requestor, AccessType:Write);
337        } else if (in_msg.Type == PersistentRequestType:GETS_PERSISTENT) {
338          persistentTable.persistentRequestLock(in_msg.addr, in_msg.Requestor, AccessType:Read);
339        } else if (in_msg.Type == PersistentRequestType:DEACTIVATE_PERSISTENT) {
340          persistentTable.persistentRequestUnlock(in_msg.addr, in_msg.Requestor);
341        } else {
342          error("Unexpected message");
343        }
344
345        Entry cache_entry := getCacheEntry(in_msg.addr);
346        // React to the message based on the current state of the table
347        if (persistentTable.isLocked(in_msg.addr)) {
348
349          if (persistentTable.typeOfSmallest(in_msg.addr) == AccessType:Read) {
350            if (getTokens(cache_entry) == 1 ||
351                getTokens(cache_entry) == (max_tokens() / 2) + 1) {
352              trigger(Event:Persistent_GETS_Last_Token, in_msg.addr,
353                      cache_entry);
354            } else {
355              trigger(Event:Persistent_GETS, in_msg.addr, cache_entry);
356            }
357          } else {
358            trigger(Event:Persistent_GETX, in_msg.addr, cache_entry);
359          }
360        }
361        else {
362            trigger(Event:Own_Lock_or_Unlock, in_msg.addr, cache_entry);
363        }
364      }
365    }
366  }
367
368
369  // Request Network
370  in_port(requestNetwork_in, RequestMsg, GlobalRequestToL2Cache) {
371    if (requestNetwork_in.isReady(clockEdge())) {
372      peek(requestNetwork_in, RequestMsg) {
373        assert(in_msg.Destination.isElement(machineID));
374
375        Entry cache_entry := getCacheEntry(in_msg.addr);
376        if (in_msg.Type == CoherenceRequestType:GETX) {
377            trigger(Event:Transient_GETX, in_msg.addr, cache_entry);
378        } else if (in_msg.Type == CoherenceRequestType:GETS) {
379          if (getTokens(cache_entry) == 1) {
380            trigger(Event:Transient_GETS_Last_Token, in_msg.addr,
381                    cache_entry);
382          }
383          else {
384            trigger(Event:Transient_GETS, in_msg.addr, cache_entry);
385          }
386        } else {
387          error("Unexpected message");
388        }
389      }
390    }
391  }
392
393  in_port(L1requestNetwork_in, RequestMsg, L1RequestToL2Cache) {
394    if (L1requestNetwork_in.isReady(clockEdge())) {
395      peek(L1requestNetwork_in, RequestMsg) {
396        assert(in_msg.Destination.isElement(machineID));
397        Entry cache_entry := getCacheEntry(in_msg.addr);
398        if (in_msg.Type == CoherenceRequestType:GETX) {
399          trigger(Event:L1_GETX, in_msg.addr, cache_entry);
400        } else if (in_msg.Type == CoherenceRequestType:GETS) {
401          if (getTokens(cache_entry) == 1 ||
402              getTokens(cache_entry) == (max_tokens() / 2) + 1) {
403            trigger(Event:L1_GETS_Last_Token, in_msg.addr, cache_entry);
404          }
405          else {
406            trigger(Event:L1_GETS, in_msg.addr, cache_entry);
407          }
408        } else {
409          error("Unexpected message");
410        }
411      }
412    }
413  }
414
415
416  // Response Network
417  in_port(responseNetwork_in, ResponseMsg, responseToL2Cache) {
418    if (responseNetwork_in.isReady(clockEdge())) {
419      peek(responseNetwork_in, ResponseMsg) {
420        assert(in_msg.Destination.isElement(machineID));
421        Entry cache_entry := getCacheEntry(in_msg.addr);
422
423        if (getTokens(cache_entry) + in_msg.Tokens != max_tokens()) {
424          if (in_msg.Type == CoherenceResponseType:ACK) {
425            assert(in_msg.Tokens < (max_tokens() / 2));
426            trigger(Event:Ack, in_msg.addr, cache_entry);
427          } else if (in_msg.Type == CoherenceResponseType:DATA_OWNER) {
428            trigger(Event:Data_Owner, in_msg.addr, cache_entry);
429          } else if (in_msg.Type == CoherenceResponseType:DATA_SHARED) {
430            trigger(Event:Data_Shared, in_msg.addr, cache_entry);
431          } else if (in_msg.Type == CoherenceResponseType:WB_TOKENS ||
432                     in_msg.Type == CoherenceResponseType:WB_OWNED ||
433                     in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
434
435            if (L2cache.cacheAvail(in_msg.addr) || is_valid(cache_entry)) {
436
437              // either room is available or the block is already present
438
439              if (in_msg.Type == CoherenceResponseType:WB_TOKENS) {
440                assert(in_msg.Dirty == false);
441                trigger(Event:Writeback_Tokens, in_msg.addr, cache_entry);
442              } else if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
443                assert(in_msg.Dirty == false);
444                trigger(Event:Writeback_Shared_Data, in_msg.addr, cache_entry);
445              }
446              else if (in_msg.Type == CoherenceResponseType:WB_OWNED) {
447                //assert(in_msg.Dirty == false);
448                trigger(Event:Writeback_Owned, in_msg.addr, cache_entry);
449              }
450            }
451            else {
452                trigger(Event:L2_Replacement,
453                        L2cache.cacheProbe(in_msg.addr),
454                        getCacheEntry(L2cache.cacheProbe(in_msg.addr)));
455            }
456          } else if (in_msg.Type == CoherenceResponseType:INV) {
457            trigger(Event:L1_INV, in_msg.addr, cache_entry);
458          } else {
459            error("Unexpected message");
460          }
461        } else {
462          if (in_msg.Type == CoherenceResponseType:ACK) {
463            assert(in_msg.Tokens < (max_tokens() / 2));
464            trigger(Event:Ack_All_Tokens, in_msg.addr, cache_entry);
465          } else if (in_msg.Type == CoherenceResponseType:DATA_OWNER ||
466                     in_msg.Type == CoherenceResponseType:DATA_SHARED) {
467            trigger(Event:Data_All_Tokens, in_msg.addr, cache_entry);
468          } else if (in_msg.Type == CoherenceResponseType:WB_TOKENS ||
469                     in_msg.Type == CoherenceResponseType:WB_OWNED ||
470                     in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
471            if (L2cache.cacheAvail(in_msg.addr) || is_valid(cache_entry)) {
472
473              // either room is available or the block is already present
474
475              if (in_msg.Type == CoherenceResponseType:WB_TOKENS) {
476                assert(in_msg.Dirty == false);
477                assert(  (getState(cache_entry, in_msg.addr) != State:NP)
478                      && (getState(cache_entry, in_msg.addr) != State:I) );
479                trigger(Event:Writeback_All_Tokens, in_msg.addr, cache_entry);
480              } else if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
481                assert(in_msg.Dirty == false);
482                trigger(Event:Writeback_All_Tokens, in_msg.addr, cache_entry);
483              }
484              else if (in_msg.Type == CoherenceResponseType:WB_OWNED) {
485                trigger(Event:Writeback_All_Tokens, in_msg.addr, cache_entry);
486              }
487            }
488            else {
489                trigger(Event:L2_Replacement,
490                        L2cache.cacheProbe(in_msg.addr),
491                        getCacheEntry(L2cache.cacheProbe(in_msg.addr)));
492            }
493          } else if (in_msg.Type == CoherenceResponseType:INV) {
494            trigger(Event:L1_INV, in_msg.addr, cache_entry);
495          } else {
496            DPRINTF(RubySlicc, "%s\n", in_msg.Type);
497            error("Unexpected message");
498          }
499        }
500      }
501    }
502  }
503
504
505  // ACTIONS
506
507  action(a_broadcastLocalRequest, "a", desc="broadcast local request globally") {
508
509    peek(L1requestNetwork_in, RequestMsg) {
510
511     // if this is a retry or no local sharers, broadcast normally
512        enqueue(globalRequestNetwork_out, RequestMsg, l2_request_latency) {
513           out_msg.addr := in_msg.addr;
514           out_msg.Type := in_msg.Type;
515           out_msg.Requestor := in_msg.Requestor;
516           out_msg.RetryNum := in_msg.RetryNum;
517
518           //
519           // If a statically shared L2 cache, then no other L2 caches can
520           // store the block
521           //
522           //out_msg.Destination.broadcast(MachineType:L2Cache);
523           //out_msg.Destination.addNetDest(getAllPertinentL2Banks(address));
524           //out_msg.Destination.remove(map_L1CacheMachId_to_L2Cache(address, in_msg.Requestor));
525
526           out_msg.Destination.add(mapAddressToMachine(address, MachineType:Directory));
527           out_msg.MessageSize := MessageSizeType:Request_Control;
528           out_msg.AccessMode := in_msg.AccessMode;
529           out_msg.Prefetch := in_msg.Prefetch;
530        } //enqueue
531      // } // if
532
533         //profile_filter_action(0);
534    } // peek
535  } //action
536
537
538  action(bb_bounceResponse, "\b", desc="Bounce tokens and data to memory") {
539    peek(responseNetwork_in, ResponseMsg) {
540      // FIXME, should use a 3rd vnet
541      enqueue(responseNetwork_out, ResponseMsg, 1) {
542        out_msg.addr := address;
543        out_msg.Type := in_msg.Type;
544        out_msg.Sender := machineID;
545        out_msg.Destination.add(mapAddressToMachine(address, MachineType:Directory));
546        out_msg.Tokens := in_msg.Tokens;
547        out_msg.MessageSize := in_msg.MessageSize;
548        out_msg.DataBlk := in_msg.DataBlk;
549        out_msg.Dirty := in_msg.Dirty;
550      }
551    }
552  }
553
554  action(c_cleanReplacement, "c", desc="Issue clean writeback") {
555    assert(is_valid(cache_entry));
556    if (cache_entry.Tokens > 0) {
557      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
558        out_msg.addr := address;
559        out_msg.Type := CoherenceResponseType:ACK;
560        out_msg.Sender := machineID;
561        out_msg.Destination.add(mapAddressToMachine(address, MachineType:Directory));
562        out_msg.Tokens := cache_entry.Tokens;
563        out_msg.MessageSize := MessageSizeType:Writeback_Control;
564      }
565      cache_entry.Tokens := 0;
566    }
567  }
568
569  action(cc_dirtyReplacement, "\c", desc="Issue dirty writeback") {
570    assert(is_valid(cache_entry));
571    enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
572      out_msg.addr := address;
573      out_msg.Sender := machineID;
574      out_msg.Destination.add(mapAddressToMachine(address, MachineType:Directory));
575      out_msg.Tokens := cache_entry.Tokens;
576      out_msg.DataBlk := cache_entry.DataBlk;
577      out_msg.Dirty := cache_entry.Dirty;
578
579      if (cache_entry.Dirty) {
580        out_msg.MessageSize := MessageSizeType:Writeback_Data;
581        out_msg.Type := CoherenceResponseType:DATA_OWNER;
582      } else {
583        out_msg.MessageSize := MessageSizeType:Writeback_Control;
584        out_msg.Type := CoherenceResponseType:ACK_OWNER;
585      }
586    }
587    cache_entry.Tokens := 0;
588  }
589
590  action(d_sendDataWithTokens, "d", desc="Send data and a token from cache to requestor") {
591    peek(requestNetwork_in, RequestMsg) {
592      assert(is_valid(cache_entry));
593      if (cache_entry.Tokens > (N_tokens + (max_tokens() / 2))) {
594        enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
595          out_msg.addr := address;
596          out_msg.Type := CoherenceResponseType:DATA_SHARED;
597          out_msg.Sender := machineID;
598          out_msg.Destination.add(in_msg.Requestor);
599          out_msg.Tokens := N_tokens;
600          out_msg.DataBlk := cache_entry.DataBlk;
601          out_msg.Dirty := false;
602          out_msg.MessageSize := MessageSizeType:Response_Data;
603        }
604        cache_entry.Tokens := cache_entry.Tokens - N_tokens;
605      }
606      else {
607        enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
608          out_msg.addr := address;
609          out_msg.Type := CoherenceResponseType:DATA_SHARED;
610          out_msg.Sender := machineID;
611          out_msg.Destination.add(in_msg.Requestor);
612          out_msg.Tokens := 1;
613          out_msg.DataBlk := cache_entry.DataBlk;
614          out_msg.Dirty := false;
615          out_msg.MessageSize := MessageSizeType:Response_Data;
616        }
617        cache_entry.Tokens := cache_entry.Tokens - 1;
618      }
619    }
620  }
621
622  action(dd_sendDataWithAllTokens, "\d", desc="Send data and all tokens from cache to requestor") {
623    assert(is_valid(cache_entry));
624    peek(requestNetwork_in, RequestMsg) {
625      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
626        out_msg.addr := address;
627        out_msg.Type := CoherenceResponseType:DATA_OWNER;
628        out_msg.Sender := machineID;
629        out_msg.Destination.add(in_msg.Requestor);
630        assert(cache_entry.Tokens >= 1);
631        out_msg.Tokens := cache_entry.Tokens;
632        out_msg.DataBlk := cache_entry.DataBlk;
633        out_msg.Dirty := cache_entry.Dirty;
634        out_msg.MessageSize := MessageSizeType:Response_Data;
635      }
636    }
637    cache_entry.Tokens := 0;
638  }
639
640  action(e_sendAckWithCollectedTokens, "e", desc="Send ack with the tokens we've collected thus far.") {
641    assert(is_valid(cache_entry));
642    if (cache_entry.Tokens > 0) {
643      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
644        out_msg.addr := address;
645        out_msg.Type := CoherenceResponseType:ACK;
646        out_msg.Sender := machineID;
647        out_msg.Destination.add(persistentTable.findSmallest(address));
648        assert(cache_entry.Tokens >= 1);
649        out_msg.Tokens := cache_entry.Tokens;
650        out_msg.MessageSize := MessageSizeType:Response_Control;
651      }
652    }
653    cache_entry.Tokens := 0;
654  }
655
656  action(ee_sendDataWithAllTokens, "\e", desc="Send data and all tokens from cache to starver") {
657    assert(is_valid(cache_entry));
658    enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
659      out_msg.addr := address;
660      out_msg.Type := CoherenceResponseType:DATA_OWNER;
661      out_msg.Sender := machineID;
662      out_msg.Destination.add(persistentTable.findSmallest(address));
663      assert(cache_entry.Tokens >= 1);
664      out_msg.Tokens := cache_entry.Tokens;
665      out_msg.DataBlk := cache_entry.DataBlk;
666      out_msg.Dirty := cache_entry.Dirty;
667      out_msg.MessageSize := MessageSizeType:Response_Data;
668    }
669    cache_entry.Tokens := 0;
670  }
671
672  action(f_sendAckWithAllButOneTokens, "f", desc="Send ack with all our tokens but one to starver.") {
673    //assert(persistentTable.findSmallest(address) != id); // Make sure we never bounce tokens to ourself
674    assert(is_valid(cache_entry));
675    assert(cache_entry.Tokens > 0);
676    if (cache_entry.Tokens > 1) {
677      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
678        out_msg.addr := address;
679        out_msg.Type := CoherenceResponseType:ACK;
680        out_msg.Sender := machineID;
681        out_msg.Destination.add(persistentTable.findSmallest(address));
682        assert(cache_entry.Tokens >= 1);
683        out_msg.Tokens := cache_entry.Tokens - 1;
684        out_msg.MessageSize := MessageSizeType:Response_Control;
685      }
686    }
687    cache_entry.Tokens := 1;
688  }
689
690  action(ff_sendDataWithAllButOneTokens, "\f", desc="Send data and out tokens but one to starver") {
691    //assert(persistentTable.findSmallest(address) != id); // Make sure we never bounce tokens to ourself
692    assert(is_valid(cache_entry));
693    assert(cache_entry.Tokens > (max_tokens() / 2) + 1);
694    enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
695        out_msg.addr := address;
696        out_msg.Type := CoherenceResponseType:DATA_OWNER;
697        out_msg.Sender := machineID;
698        out_msg.Destination.add(persistentTable.findSmallest(address));
699        out_msg.Tokens := cache_entry.Tokens - 1;
700        out_msg.DataBlk := cache_entry.DataBlk;
701        out_msg.Dirty := cache_entry.Dirty;
702        out_msg.MessageSize := MessageSizeType:Response_Data;
703    }
704    cache_entry.Tokens := 1;
705  }
706
707  action(fa_sendDataWithAllTokens, "fa", desc="Send data and out tokens but one to starver") {
708    //assert(persistentTable.findSmallest(address) != id); // Make sure we never bounce tokens to ourself
709    assert(is_valid(cache_entry));
710    assert(cache_entry.Tokens == (max_tokens() / 2) + 1);
711    enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
712        out_msg.addr := address;
713        out_msg.Type := CoherenceResponseType:DATA_OWNER;
714        out_msg.Sender := machineID;
715        out_msg.Destination.add(persistentTable.findSmallest(address));
716        out_msg.Tokens := cache_entry.Tokens;
717        out_msg.DataBlk := cache_entry.DataBlk;
718        out_msg.Dirty := cache_entry.Dirty;
719        out_msg.MessageSize := MessageSizeType:Response_Data;
720    }
721    cache_entry.Tokens := 0;
722  }
723
724
725
726  action(gg_bounceResponseToStarver, "\g", desc="Redirect response to starving processor") {
727    // assert(persistentTable.isLocked(address));
728    peek(responseNetwork_in, ResponseMsg) {
729      // FIXME, should use a 3rd vnet in some cases
730      enqueue(responseNetwork_out, ResponseMsg, 1) {
731        out_msg.addr := address;
732        out_msg.Type := in_msg.Type;
733        out_msg.Sender := machineID;
734        out_msg.Destination.add(persistentTable.findSmallest(address));
735        out_msg.Tokens := in_msg.Tokens;
736        out_msg.DataBlk := in_msg.DataBlk;
737        out_msg.Dirty := in_msg.Dirty;
738        out_msg.MessageSize := in_msg.MessageSize;
739      }
740    }
741  }
742
743  action(gg_bounceWBSharedToStarver, "\gg", desc="Redirect response to starving processor") {
744    //assert(persistentTable.isLocked(address));
745    peek(responseNetwork_in, ResponseMsg) {
746      // FIXME, should use a 3rd vnet in some cases
747      enqueue(responseNetwork_out, ResponseMsg, 1) {
748        out_msg.addr := address;
749        if (in_msg.Type == CoherenceResponseType:WB_SHARED_DATA) {
750          out_msg.Type := CoherenceResponseType:DATA_SHARED;
751        } else {
752          assert(in_msg.Tokens < (max_tokens() / 2));
753          out_msg.Type := CoherenceResponseType:ACK;
754        }
755        out_msg.Sender := machineID;
756        out_msg.Destination.add(persistentTable.findSmallest(address));
757        out_msg.Tokens := in_msg.Tokens;
758        out_msg.DataBlk := in_msg.DataBlk;
759        out_msg.Dirty := in_msg.Dirty;
760        out_msg.MessageSize := in_msg.MessageSize;
761      }
762    }
763  }
764
765  action(gg_bounceWBOwnedToStarver, "\ggg", desc="Redirect response to starving processor") {
766    // assert(persistentTable.isLocked(address));
767    peek(responseNetwork_in, ResponseMsg) {
768      // FIXME, should use a 3rd vnet in some cases
769      enqueue(responseNetwork_out, ResponseMsg, 1) {
770        out_msg.addr := address;
771        out_msg.Type := CoherenceResponseType:DATA_OWNER;
772        out_msg.Sender := machineID;
773        out_msg.Destination.add(persistentTable.findSmallest(address));
774        out_msg.Tokens := in_msg.Tokens;
775        out_msg.DataBlk := in_msg.DataBlk;
776        out_msg.Dirty := in_msg.Dirty;
777        out_msg.MessageSize := in_msg.MessageSize;
778      }
779    }
780  }
781
782
783  action(h_updateFilterFromL1HintOrWB, "h", desc="update filter from received writeback") {
784    peek(responseNetwork_in, ResponseMsg) {
785      removeSharer(in_msg.addr, machineIDToNodeID(in_msg.Sender));
786    }
787  }
788
789  action(j_forwardTransientRequestToLocalSharers, "j", desc="Forward external transient request to local sharers") {
790    peek(requestNetwork_in, RequestMsg) {
791      if (filtering_enabled && in_msg.RetryNum == 0 && sharersExist(in_msg.addr) == false) {
792        //profile_filter_action(1);
793        DPRINTF(RubySlicc, "filtered message, Retry Num: %d\n",
794                in_msg.RetryNum);
795      }
796      else {
797        enqueue(localRequestNetwork_out, RequestMsg, l2_response_latency ) {
798           out_msg.addr := in_msg.addr;
799           out_msg.Requestor := in_msg.Requestor;
800
801           //
802           // Currently assuming only one chip so all L1s are local
803           //
804           //out_msg.Destination := getLocalL1IDs(machineID);
805           out_msg.Destination.broadcast(MachineType:L1Cache);
806           out_msg.Destination.remove(in_msg.Requestor);
807
808           out_msg.Type := in_msg.Type;
809           out_msg.isLocal := false;
810           out_msg.MessageSize := MessageSizeType:Broadcast_Control;
811           out_msg.AccessMode := in_msg.AccessMode;
812           out_msg.Prefetch := in_msg.Prefetch;
813        }
814        //profile_filter_action(0);
815      }
816    }
817  }
818
819  action(k_dataFromL2CacheToL1Requestor, "k", desc="Send data and a token from cache to L1 requestor") {
820    peek(L1requestNetwork_in, RequestMsg) {
821      assert(is_valid(cache_entry));
822      assert(cache_entry.Tokens > 0);
823      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
824        out_msg.addr := address;
825        out_msg.Type := CoherenceResponseType:DATA_SHARED;
826        out_msg.Sender := machineID;
827        out_msg.Destination.add(in_msg.Requestor);
828        out_msg.DataBlk := cache_entry.DataBlk;
829        out_msg.Dirty := false;
830        out_msg.MessageSize := MessageSizeType:ResponseL2hit_Data;
831        out_msg.Tokens := 1;
832      }
833      cache_entry.Tokens := cache_entry.Tokens - 1;
834    }
835  }
836
837  action(k_dataOwnerFromL2CacheToL1Requestor, "\k", desc="Send data and a token from cache to L1 requestor") {
838    peek(L1requestNetwork_in, RequestMsg) {
839      assert(is_valid(cache_entry));
840      assert(cache_entry.Tokens == (max_tokens() / 2) + 1);
841      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
842        out_msg.addr := address;
843        out_msg.Type := CoherenceResponseType:DATA_OWNER;
844        out_msg.Sender := machineID;
845        out_msg.Destination.add(in_msg.Requestor);
846        out_msg.DataBlk := cache_entry.DataBlk;
847        out_msg.Dirty := cache_entry.Dirty;
848        out_msg.MessageSize := MessageSizeType:ResponseL2hit_Data;
849        out_msg.Tokens := cache_entry.Tokens;
850      }
851      cache_entry.Tokens := 0;
852    }
853  }
854
855  action(k_dataAndAllTokensFromL2CacheToL1Requestor, "\kk", desc="Send data and a token from cache to L1 requestor") {
856    peek(L1requestNetwork_in, RequestMsg) {
857      assert(is_valid(cache_entry));
858//      assert(cache_entry.Tokens == max_tokens());
859      enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
860        out_msg.addr := address;
861        out_msg.Type := CoherenceResponseType:DATA_OWNER;
862        out_msg.Sender := machineID;
863        out_msg.Destination.add(in_msg.Requestor);
864        out_msg.DataBlk := cache_entry.DataBlk;
865        out_msg.Dirty := cache_entry.Dirty;
866        out_msg.MessageSize := MessageSizeType:ResponseL2hit_Data;
867        //out_msg.Tokens := max_tokens();
868        out_msg.Tokens := cache_entry.Tokens;
869      }
870      cache_entry.Tokens := 0;
871    }
872  }
873
874  action(l_popPersistentQueue, "l", desc="Pop persistent queue.") {
875    persistentNetwork_in.dequeue(clockEdge());
876  }
877
878  action(m_popRequestQueue, "m", desc="Pop request queue.") {
879    requestNetwork_in.dequeue(clockEdge());
880  }
881
882  action(n_popResponseQueue, "n", desc="Pop response queue") {
883    responseNetwork_in.dequeue(clockEdge());
884  }
885
886  action(o_popL1RequestQueue, "o", desc="Pop L1 request queue.") {
887    L1requestNetwork_in.dequeue(clockEdge());
888  }
889
890
891  action(q_updateTokensFromResponse, "q", desc="Update the token count based on the incoming response message") {
892    peek(responseNetwork_in, ResponseMsg) {
893      assert(is_valid(cache_entry));
894      assert(in_msg.Tokens != 0);
895      cache_entry.Tokens := cache_entry.Tokens + in_msg.Tokens;
896
897      // this should ideally be in u_writeDataToCache, but Writeback_All_Tokens
898      //  may not trigger this action.
899      if ( (in_msg.Type == CoherenceResponseType:DATA_OWNER || in_msg.Type == CoherenceResponseType:WB_OWNED) && in_msg.Dirty) {
900        cache_entry.Dirty := true;
901      }
902    }
903  }
904
905  action(r_markNewSharer, "r", desc="Mark the new local sharer from local request message") {
906    peek(L1requestNetwork_in, RequestMsg) {
907      if (machineIDToMachineType(in_msg.Requestor) == MachineType:L1Cache) {
908        if (in_msg.Type == CoherenceRequestType:GETX) {
909          setNewWriter(in_msg.addr, machineIDToNodeID(in_msg.Requestor));
910        } else if (in_msg.Type == CoherenceRequestType:GETS) {
911          addNewSharer(in_msg.addr, machineIDToNodeID(in_msg.Requestor));
912        }
913      }
914    }
915  }
916
917  action(r_clearExclusive, "\rrr", desc="clear exclusive bit") {
918    clearExclusiveBitIfExists(address);
919  }
920
921  action(r_setMRU, "\rr", desc="manually set the MRU bit for cache line" ) {
922    peek(L1requestNetwork_in, RequestMsg) {
923      if ((machineIDToMachineType(in_msg.Requestor) == MachineType:L1Cache) &&
924          (is_valid(cache_entry))) {
925        L2cache.setMRU(address);
926      }
927    }
928  }
929
930  action(t_sendAckWithCollectedTokens, "t", desc="Send ack with the tokens we've collected thus far.") {
931    assert(is_valid(cache_entry));
932    if (cache_entry.Tokens > 0) {
933      peek(requestNetwork_in, RequestMsg) {
934        enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
935          out_msg.addr := address;
936          out_msg.Type := CoherenceResponseType:ACK;
937          out_msg.Sender := machineID;
938          out_msg.Destination.add(in_msg.Requestor);
939          assert(cache_entry.Tokens >= 1);
940          out_msg.Tokens := cache_entry.Tokens;
941          out_msg.MessageSize := MessageSizeType:Response_Control;
942        }
943      }
944    }
945    cache_entry.Tokens := 0;
946  }
947
948  action(tt_sendLocalAckWithCollectedTokens, "tt", desc="Send ack with the tokens we've collected thus far.") {
949    assert(is_valid(cache_entry));
950    if (cache_entry.Tokens > 0) {
951      peek(L1requestNetwork_in, RequestMsg) {
952        enqueue(responseNetwork_out, ResponseMsg, l2_response_latency) {
953          out_msg.addr := address;
954          out_msg.Type := CoherenceResponseType:ACK;
955          out_msg.Sender := machineID;
956          out_msg.Destination.add(in_msg.Requestor);
957          assert(cache_entry.Tokens >= 1);
958          out_msg.Tokens := cache_entry.Tokens;
959          out_msg.MessageSize := MessageSizeType:Response_Control;
960        }
961      }
962    }
963    cache_entry.Tokens := 0;
964  }
965
966  action(u_writeDataToCache, "u", desc="Write data to cache") {
967    peek(responseNetwork_in, ResponseMsg) {
968      assert(is_valid(cache_entry));
969      cache_entry.DataBlk := in_msg.DataBlk;
970      if ((cache_entry.Dirty == false) && in_msg.Dirty) {
971        cache_entry.Dirty := in_msg.Dirty;
972      }
973    }
974  }
975
976  action(vv_allocateL2CacheBlock, "\v", desc="Set L2 cache tag equal to tag of block B.") {
977    set_cache_entry(L2cache.allocate(address, new Entry));
978  }
979
980  action(rr_deallocateL2CacheBlock, "\r", desc="Deallocate L2 cache block.  Sets the cache to not present, allowing a replacement in parallel with a fetch.") {
981    L2cache.deallocate(address);
982    unset_cache_entry();
983  }
984
985  action(uu_profileMiss, "\um", desc="Profile the demand miss") {
986      ++L2cache.demand_misses;
987  }
988
989  action(uu_profileHit, "\uh", desc="Profile the demand hit") {
990      ++L2cache.demand_hits;
991  }
992
993  action(w_assertIncomingDataAndCacheDataMatch, "w", desc="Assert that the incoming data and the data in the cache match") {
994    peek(responseNetwork_in, ResponseMsg) {
995      if (in_msg.Type != CoherenceResponseType:ACK &&
996          in_msg.Type != CoherenceResponseType:WB_TOKENS) {
997        assert(is_valid(cache_entry));
998        assert(cache_entry.DataBlk == in_msg.DataBlk);
999      }
1000    }
1001  }
1002
1003
1004  //*****************************************************
1005  // TRANSITIONS
1006  //*****************************************************
1007
1008  transition({NP, I, S, O, M, I_L, S_L}, L1_INV) {
1009
1010    h_updateFilterFromL1HintOrWB;
1011    n_popResponseQueue;
1012  }
1013
1014  transition({NP, I, S, O, M}, Own_Lock_or_Unlock) {
1015    l_popPersistentQueue;
1016  }
1017
1018
1019  // Transitions from NP
1020
1021  transition(NP, {Transient_GETX, Transient_GETS}) {
1022    // forward message to local sharers
1023    r_clearExclusive;
1024    j_forwardTransientRequestToLocalSharers;
1025    m_popRequestQueue;
1026  }
1027
1028
1029  transition(NP,  {L1_GETS, L1_GETX}) {
1030    a_broadcastLocalRequest;
1031    r_markNewSharer;
1032    uu_profileMiss;
1033    o_popL1RequestQueue;
1034  }
1035
1036  transition(NP, {Ack, Data_Shared, Data_Owner, Data_All_Tokens}) {
1037    bb_bounceResponse;
1038    n_popResponseQueue;
1039  }
1040
1041  transition(NP, Writeback_Shared_Data, S) {
1042    vv_allocateL2CacheBlock;
1043    u_writeDataToCache;
1044    q_updateTokensFromResponse;
1045    h_updateFilterFromL1HintOrWB;
1046    n_popResponseQueue;
1047  }
1048
1049  transition(NP, Writeback_Tokens, I) {
1050    vv_allocateL2CacheBlock;
1051    q_updateTokensFromResponse;
1052    h_updateFilterFromL1HintOrWB;
1053    n_popResponseQueue;
1054  }
1055
1056  transition(NP, Writeback_All_Tokens, M) {
1057    vv_allocateL2CacheBlock;
1058    u_writeDataToCache;
1059    q_updateTokensFromResponse;
1060    h_updateFilterFromL1HintOrWB;
1061    n_popResponseQueue;
1062  }
1063
1064  transition(NP, Writeback_Owned, O) {
1065    vv_allocateL2CacheBlock;
1066    u_writeDataToCache;
1067    q_updateTokensFromResponse;
1068    h_updateFilterFromL1HintOrWB;
1069    n_popResponseQueue;
1070  }
1071
1072
1073  transition(NP,
1074             {Persistent_GETX, Persistent_GETS, Persistent_GETS_Last_Token},
1075             I_L) {
1076    l_popPersistentQueue;
1077  }
1078
1079  // Transitions from Idle
1080
1081  transition(I, {L1_GETS, L1_GETS_Last_Token}) {
1082    a_broadcastLocalRequest;
1083    tt_sendLocalAckWithCollectedTokens;  // send any tokens we have collected
1084    r_markNewSharer;
1085    uu_profileMiss;
1086    o_popL1RequestQueue;
1087  }
1088
1089  transition(I, L1_GETX) {
1090    a_broadcastLocalRequest;
1091    tt_sendLocalAckWithCollectedTokens; // send any tokens we have collected
1092    r_markNewSharer;
1093    uu_profileMiss;
1094    o_popL1RequestQueue;
1095  }
1096
1097  transition(I, L2_Replacement) {
1098    c_cleanReplacement; // Only needed in some cases
1099    rr_deallocateL2CacheBlock;
1100  }
1101
1102  transition(I, {Transient_GETX, Transient_GETS, Transient_GETS_Last_Token}) {
1103    r_clearExclusive;
1104    t_sendAckWithCollectedTokens;
1105    j_forwardTransientRequestToLocalSharers;
1106    m_popRequestQueue;
1107  }
1108
1109  transition(I,
1110             {Persistent_GETX, Persistent_GETS, Persistent_GETS_Last_Token},
1111             I_L) {
1112    e_sendAckWithCollectedTokens;
1113    l_popPersistentQueue;
1114  }
1115
1116
1117  transition(I, Ack) {
1118    q_updateTokensFromResponse;
1119    n_popResponseQueue;
1120  }
1121
1122  transition(I, Data_Shared, S) {
1123    u_writeDataToCache;
1124    q_updateTokensFromResponse;
1125    n_popResponseQueue;
1126  }
1127
1128  transition(I, Writeback_Shared_Data, S) {
1129    u_writeDataToCache;
1130    q_updateTokensFromResponse;
1131    h_updateFilterFromL1HintOrWB;
1132    n_popResponseQueue;
1133  }
1134
1135  transition(I, Writeback_Tokens) {
1136    q_updateTokensFromResponse;
1137    h_updateFilterFromL1HintOrWB;
1138    n_popResponseQueue;
1139  }
1140
1141  transition(I, Data_Owner, O) {
1142    u_writeDataToCache;
1143    q_updateTokensFromResponse;
1144    n_popResponseQueue;
1145  }
1146
1147  transition(I, Writeback_Owned, O) {
1148    u_writeDataToCache;
1149    q_updateTokensFromResponse;
1150    h_updateFilterFromL1HintOrWB;
1151    n_popResponseQueue;
1152  }
1153
1154  transition(I, Data_All_Tokens, M) {
1155    u_writeDataToCache;
1156    q_updateTokensFromResponse;
1157    n_popResponseQueue;
1158  }
1159
1160
1161  transition(I, Writeback_All_Tokens, M) {
1162    u_writeDataToCache;
1163    q_updateTokensFromResponse;
1164    h_updateFilterFromL1HintOrWB;
1165    n_popResponseQueue;
1166  }
1167
1168  // Transitions from Shared
1169
1170  transition(S, L2_Replacement, I) {
1171    c_cleanReplacement;
1172    rr_deallocateL2CacheBlock;
1173  }
1174
1175  transition(S, Transient_GETX, I) {
1176    r_clearExclusive;
1177    t_sendAckWithCollectedTokens;
1178    j_forwardTransientRequestToLocalSharers;
1179    m_popRequestQueue;
1180  }
1181
1182  transition(S, {Transient_GETS, Transient_GETS_Last_Token}) {
1183    j_forwardTransientRequestToLocalSharers;
1184    r_clearExclusive;
1185    m_popRequestQueue;
1186  }
1187
1188  transition(S, Persistent_GETX, I_L) {
1189    e_sendAckWithCollectedTokens;
1190    l_popPersistentQueue;
1191  }
1192
1193
1194  transition(S, {Persistent_GETS, Persistent_GETS_Last_Token}, S_L) {
1195    f_sendAckWithAllButOneTokens;
1196    l_popPersistentQueue;
1197  }
1198
1199
1200  transition(S, Ack) {
1201    q_updateTokensFromResponse;
1202    n_popResponseQueue;
1203  }
1204
1205  transition(S, Data_Shared) {
1206    w_assertIncomingDataAndCacheDataMatch;
1207    q_updateTokensFromResponse;
1208    n_popResponseQueue;
1209  }
1210
1211  transition(S, Writeback_Tokens) {
1212    q_updateTokensFromResponse;
1213    h_updateFilterFromL1HintOrWB;
1214    n_popResponseQueue;
1215  }
1216
1217  transition(S, Writeback_Shared_Data) {
1218    w_assertIncomingDataAndCacheDataMatch;
1219    q_updateTokensFromResponse;
1220    h_updateFilterFromL1HintOrWB;
1221    n_popResponseQueue;
1222  }
1223
1224
1225  transition(S, Data_Owner, O) {
1226    w_assertIncomingDataAndCacheDataMatch;
1227    q_updateTokensFromResponse;
1228    n_popResponseQueue;
1229  }
1230
1231  transition(S, Writeback_Owned, O) {
1232    w_assertIncomingDataAndCacheDataMatch;
1233    q_updateTokensFromResponse;
1234    h_updateFilterFromL1HintOrWB;
1235    n_popResponseQueue;
1236  }
1237
1238  transition(S, Data_All_Tokens, M) {
1239    w_assertIncomingDataAndCacheDataMatch;
1240    q_updateTokensFromResponse;
1241    n_popResponseQueue;
1242  }
1243
1244  transition(S, Writeback_All_Tokens,  M) {
1245    w_assertIncomingDataAndCacheDataMatch;
1246    q_updateTokensFromResponse;
1247    h_updateFilterFromL1HintOrWB;
1248    n_popResponseQueue;
1249  }
1250
1251  transition(S, L1_GETX, I) {
1252    a_broadcastLocalRequest;
1253    tt_sendLocalAckWithCollectedTokens;
1254    r_markNewSharer;
1255    r_setMRU;
1256    uu_profileMiss;
1257    o_popL1RequestQueue;
1258  }
1259
1260
1261  transition(S, L1_GETS) {
1262    k_dataFromL2CacheToL1Requestor;
1263    r_markNewSharer;
1264    r_setMRU;
1265    uu_profileHit;
1266    o_popL1RequestQueue;
1267  }
1268
1269  transition(S, L1_GETS_Last_Token, I) {
1270
1271    k_dataFromL2CacheToL1Requestor;
1272    r_markNewSharer;
1273    r_setMRU;
1274    uu_profileHit;
1275    o_popL1RequestQueue;
1276  }
1277
1278  // Transitions from Owned
1279
1280  transition(O, L2_Replacement, I) {
1281    cc_dirtyReplacement;
1282    rr_deallocateL2CacheBlock;
1283  }
1284
1285  transition(O, Transient_GETX, I) {
1286    r_clearExclusive;
1287    dd_sendDataWithAllTokens;
1288    j_forwardTransientRequestToLocalSharers;
1289    m_popRequestQueue;
1290  }
1291
1292  transition(O, Persistent_GETX, I_L) {
1293    ee_sendDataWithAllTokens;
1294    l_popPersistentQueue;
1295  }
1296
1297  transition(O, Persistent_GETS, S_L) {
1298    ff_sendDataWithAllButOneTokens;
1299    l_popPersistentQueue;
1300  }
1301
1302  transition(O, Persistent_GETS_Last_Token, I_L) {
1303    fa_sendDataWithAllTokens;
1304    l_popPersistentQueue;
1305  }
1306
1307  transition(O, Transient_GETS) {
1308    // send multiple tokens
1309    r_clearExclusive;
1310    d_sendDataWithTokens;
1311    m_popRequestQueue;
1312  }
1313
1314  transition(O, Transient_GETS_Last_Token) {
1315    // WAIT FOR IT TO GO PERSISTENT
1316    r_clearExclusive;
1317    m_popRequestQueue;
1318  }
1319
1320  transition(O, Ack) {
1321    q_updateTokensFromResponse;
1322    n_popResponseQueue;
1323  }
1324
1325  transition(O, Ack_All_Tokens, M) {
1326    q_updateTokensFromResponse;
1327    n_popResponseQueue;
1328  }
1329
1330  transition(O, Data_Shared) {
1331    w_assertIncomingDataAndCacheDataMatch;
1332    q_updateTokensFromResponse;
1333    n_popResponseQueue;
1334  }
1335
1336
1337  transition(O, {Writeback_Tokens, Writeback_Shared_Data}) {
1338    w_assertIncomingDataAndCacheDataMatch;
1339    q_updateTokensFromResponse;
1340    h_updateFilterFromL1HintOrWB;
1341    n_popResponseQueue;
1342  }
1343
1344  transition(O, Data_All_Tokens, M) {
1345    w_assertIncomingDataAndCacheDataMatch;
1346    q_updateTokensFromResponse;
1347    n_popResponseQueue;
1348  }
1349
1350  transition(O, Writeback_All_Tokens, M) {
1351    w_assertIncomingDataAndCacheDataMatch;
1352    q_updateTokensFromResponse;
1353    h_updateFilterFromL1HintOrWB;
1354    n_popResponseQueue;
1355  }
1356
1357  transition(O, L1_GETS) {
1358    k_dataFromL2CacheToL1Requestor;
1359    r_markNewSharer;
1360    r_setMRU;
1361    uu_profileHit;
1362    o_popL1RequestQueue;
1363  }
1364
1365  transition(O, L1_GETS_Last_Token, I) {
1366    k_dataOwnerFromL2CacheToL1Requestor;
1367    r_markNewSharer;
1368    r_setMRU;
1369    uu_profileHit;
1370    o_popL1RequestQueue;
1371  }
1372
1373  transition(O, L1_GETX, I) {
1374    a_broadcastLocalRequest;
1375    k_dataAndAllTokensFromL2CacheToL1Requestor;
1376    r_markNewSharer;
1377    r_setMRU;
1378    uu_profileMiss;
1379    o_popL1RequestQueue;
1380  }
1381
1382  // Transitions from M
1383
1384  transition(M, L2_Replacement, I) {
1385    cc_dirtyReplacement;
1386    rr_deallocateL2CacheBlock;
1387  }
1388
1389  // MRM_DEBUG:  Give up all tokens even for GETS? ???
1390  transition(M, {Transient_GETX, Transient_GETS}, I) {
1391    r_clearExclusive;
1392    dd_sendDataWithAllTokens;
1393    m_popRequestQueue;
1394  }
1395
1396  transition(M, {Persistent_GETS, Persistent_GETX}, I_L) {
1397    ee_sendDataWithAllTokens;
1398    l_popPersistentQueue;
1399  }
1400
1401
1402  transition(M, L1_GETS, O) {
1403    k_dataFromL2CacheToL1Requestor;
1404    r_markNewSharer;
1405    r_setMRU;
1406    uu_profileHit;
1407    o_popL1RequestQueue;
1408  }
1409
1410  transition(M, L1_GETX, I) {
1411    k_dataAndAllTokensFromL2CacheToL1Requestor;
1412    r_markNewSharer;
1413    r_setMRU;
1414    uu_profileHit;
1415    o_popL1RequestQueue;
1416  }
1417
1418
1419  //Transitions from locked states
1420
1421  transition({I_L, S_L}, Ack) {
1422    gg_bounceResponseToStarver;
1423    n_popResponseQueue;
1424  }
1425
1426  transition({I_L, S_L}, {Data_Shared, Data_Owner, Data_All_Tokens}) {
1427    gg_bounceResponseToStarver;
1428    n_popResponseQueue;
1429  }
1430
1431  transition({I_L, S_L}, {Writeback_Tokens, Writeback_Shared_Data}) {
1432    gg_bounceWBSharedToStarver;
1433    h_updateFilterFromL1HintOrWB;
1434    n_popResponseQueue;
1435  }
1436
1437  transition({I_L, S_L}, {Writeback_Owned, Writeback_All_Tokens}) {
1438    gg_bounceWBOwnedToStarver;
1439    h_updateFilterFromL1HintOrWB;
1440    n_popResponseQueue;
1441  }
1442
1443  transition(S_L, L2_Replacement, I) {
1444    c_cleanReplacement;
1445    rr_deallocateL2CacheBlock;
1446  }
1447
1448  transition(I_L, L2_Replacement, I) {
1449    rr_deallocateL2CacheBlock;
1450  }
1451
1452  transition(I_L, Own_Lock_or_Unlock, I) {
1453    l_popPersistentQueue;
1454  }
1455
1456  transition(S_L, Own_Lock_or_Unlock, S) {
1457    l_popPersistentQueue;
1458  }
1459
1460  transition({I_L, S_L}, {Transient_GETS_Last_Token, Transient_GETS, Transient_GETX}) {
1461    r_clearExclusive;
1462    m_popRequestQueue;
1463  }
1464
1465  transition(I_L, {L1_GETX, L1_GETS}) {
1466    a_broadcastLocalRequest;
1467    r_markNewSharer;
1468    uu_profileMiss;
1469    o_popL1RequestQueue;
1470  }
1471
1472  transition(S_L, L1_GETX, I_L) {
1473    a_broadcastLocalRequest;
1474    tt_sendLocalAckWithCollectedTokens;
1475    r_markNewSharer;
1476    r_setMRU;
1477    uu_profileMiss;
1478    o_popL1RequestQueue;
1479  }
1480
1481  transition(S_L, L1_GETS) {
1482    k_dataFromL2CacheToL1Requestor;
1483    r_markNewSharer;
1484    r_setMRU;
1485    uu_profileHit;
1486    o_popL1RequestQueue;
1487  }
1488
1489  transition(S_L, L1_GETS_Last_Token, I_L) {
1490    k_dataFromL2CacheToL1Requestor;
1491    r_markNewSharer;
1492    r_setMRU;
1493    uu_profileHit;
1494    o_popL1RequestQueue;
1495  }
1496
1497  transition(S_L, Persistent_GETX, I_L) {
1498    e_sendAckWithCollectedTokens;
1499    l_popPersistentQueue;
1500  }
1501
1502  transition(S_L, {Persistent_GETS, Persistent_GETS_Last_Token}) {
1503    l_popPersistentQueue;
1504  }
1505
1506  transition(I_L, {Persistent_GETX, Persistent_GETS}) {
1507    l_popPersistentQueue;
1508  }
1509}
1510