source: trunk/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h @ 542

Last change on this file since 542 was 535, checked in by cfuguet, 11 years ago

Modification in vci_mem_cache:

  • When a BROADCAST INVALIDATE is needed after a WRITE request, the the data from the cache is merged with the new data of the WRITE request.

Before this commit, the DATA from the cache was read in the
WRITE_DIR_LOCK state, but this creates a critical path RAM-to-RAM.
Therefore, this commit changes the state for read the data to
WRITE_BC_DIR_READ and because the synchronous behavior of the
RAMs, the data is available in the WRITE_BC_TRT_LOCK state.
File size: 42.9 KB
Line 
1/* -*- c++ -*-
2 * File         : vci_mem_cache.h
3 * Date         : 26/10/2008
4 * Copyright    : UPMC / LIP6
5 * Authors      : Alain Greiner / Eric Guthmuller
6 *
7 * SOCLIB_LGPL_HEADER_BEGIN
8 *
9 * This file is part of SoCLib, GNU LGPLv2.1.
10 *
11 * SoCLib is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License as published
13 * by the Free Software Foundation; version 2.1 of the License.
14 *
15 * SoCLib is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with SoCLib; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 * 02110-1301 USA
24 *
25 * SOCLIB_LGPL_HEADER_END
26 *
27 * Maintainers: alain.greiner@lip6.fr
28 *              eric.guthmuller@polytechnique.edu
29 *              cesar.fuguet-tortolero@lip6.fr
30 *              alexandre.joannou@lip6.fr
31 */
32
33#ifndef SOCLIB_CABA_MEM_CACHE_H
34#define SOCLIB_CABA_MEM_CACHE_H
35
36#include <inttypes.h>
37#include <systemc>
38#include <list>
39#include <cassert>
40#include "arithmetics.h"
41#include "alloc_elems.h"
42#include "caba_base_module.h"
43#include "vci_target.h"
44#include "vci_initiator.h"
45#include "generic_fifo.h"
46#include "mapping_table.h"
47#include "int_tab.h"
48#include "generic_llsc_global_table.h"
49#include "mem_cache_directory.h"
50#include "xram_transaction.h"
51#include "update_tab.h"
52#include "dspin_interface.h"
53#include "dspin_dhccp_param.h"
54
55#define TRT_ENTRIES      4      // Number of entries in TRT
56#define UPT_ENTRIES      4      // Number of entries in UPT
57#define IVT_ENTRIES      4      // Number of entries in IVT
58#define HEAP_ENTRIES     1024   // Number of entries in HEAP
59
60namespace soclib {  namespace caba {
61
62  using namespace sc_core;
63
64  template<typename vci_param_int, 
65           typename vci_param_ext,
66           size_t   dspin_in_width,
67           size_t   dspin_out_width>
68    class VciMemCache
69    : public soclib::caba::BaseModule
70    {
71      typedef typename vci_param_int::fast_addr_t  addr_t;
72      typedef typename sc_dt::sc_uint<64>          wide_data_t;
73      typedef uint32_t                             data_t;
74      typedef uint32_t                             tag_t;
75      typedef uint32_t                             be_t;
76      typedef uint32_t                             copy_t;
77
78      /* States of the TGT_CMD fsm */
79      enum tgt_cmd_fsm_state_e
80      {
81        TGT_CMD_IDLE,
82        TGT_CMD_READ,
83        TGT_CMD_WRITE,
84        TGT_CMD_CAS,
85        TGT_CMD_ERROR,
86        TGT_CMD_CONFIG
87      };
88
89      /* States of the TGT_RSP fsm */
90      enum tgt_rsp_fsm_state_e
91      {
92        TGT_RSP_READ_IDLE,
93        TGT_RSP_WRITE_IDLE,
94        TGT_RSP_CAS_IDLE,
95        TGT_RSP_XRAM_IDLE,
96        TGT_RSP_MULTI_ACK_IDLE,
97        TGT_RSP_CLEANUP_IDLE,
98        TGT_RSP_CONFIG_IDLE,
99        TGT_RSP_TGT_CMD_IDLE,
100        TGT_RSP_READ,
101        TGT_RSP_WRITE,
102        TGT_RSP_CAS,
103        TGT_RSP_XRAM,
104        TGT_RSP_MULTI_ACK,
105        TGT_RSP_CLEANUP,
106        TGT_RSP_CONFIG,
107        TGT_RSP_TGT_CMD
108      };
109
110      /* States of the DSPIN_TGT fsm */
111      enum cc_receive_fsm_state_e
112      {
113        CC_RECEIVE_IDLE,
114        CC_RECEIVE_CLEANUP,
115        CC_RECEIVE_CLEANUP_EOP,
116        CC_RECEIVE_MULTI_ACK
117      };
118
119      /* States of the CC_SEND fsm */
120      enum cc_send_fsm_state_e
121      {
122        CC_SEND_XRAM_RSP_IDLE,
123        CC_SEND_WRITE_IDLE,
124        CC_SEND_CAS_IDLE,
125        CC_SEND_CONFIG_IDLE,
126        CC_SEND_XRAM_RSP_BRDCAST_HEADER,
127        CC_SEND_XRAM_RSP_BRDCAST_NLINE,
128        CC_SEND_XRAM_RSP_INVAL_HEADER,
129        CC_SEND_XRAM_RSP_INVAL_NLINE,
130        CC_SEND_WRITE_BRDCAST_HEADER,
131        CC_SEND_WRITE_BRDCAST_NLINE,
132        CC_SEND_WRITE_UPDT_HEADER,
133        CC_SEND_WRITE_UPDT_NLINE,
134        CC_SEND_WRITE_UPDT_DATA,
135        CC_SEND_CAS_BRDCAST_HEADER,
136        CC_SEND_CAS_BRDCAST_NLINE,
137        CC_SEND_CAS_UPDT_HEADER,
138        CC_SEND_CAS_UPDT_NLINE,
139        CC_SEND_CAS_UPDT_DATA,
140        CC_SEND_CAS_UPDT_DATA_HIGH,
141        CC_SEND_CONFIG_INVAL_HEADER,
142        CC_SEND_CONFIG_INVAL_NLINE,
143        CC_SEND_CONFIG_BRDCAST_HEADER,
144        CC_SEND_CONFIG_BRDCAST_NLINE
145      };
146
147      /* States of the MULTI_ACK fsm */
148      enum multi_ack_fsm_state_e
149      {
150        MULTI_ACK_IDLE,
151        MULTI_ACK_UPT_LOCK,
152        MULTI_ACK_UPT_CLEAR,
153        MULTI_ACK_WRITE_RSP
154      };
155
156      /* States of the CONFIG fsm */
157      enum config_fsm_state_e
158      {
159        CONFIG_IDLE,
160        CONFIG_LOOP,
161        CONFIG_WAIT,
162        CONFIG_RSP,
163        CONFIG_DIR_REQ,
164        CONFIG_DIR_ACCESS,
165        CONFIG_IVT_LOCK,
166        CONFIG_BC_SEND,
167        CONFIG_INVAL_SEND,
168        CONFIG_HEAP_REQ,
169        CONFIG_HEAP_SCAN,
170        CONFIG_HEAP_LAST,
171        CONFIG_TRT_LOCK,
172        CONFIG_TRT_SET,
173        CONFIG_PUT_REQ
174      };
175
176      /* States of the READ fsm */
177      enum read_fsm_state_e
178      {
179        READ_IDLE,
180        READ_DIR_REQ,
181        READ_DIR_LOCK,
182        READ_DIR_HIT,
183        READ_HEAP_REQ,
184        READ_HEAP_LOCK,
185        READ_HEAP_WRITE,
186        READ_HEAP_ERASE,
187        READ_HEAP_LAST,
188        READ_RSP,
189        READ_TRT_LOCK,
190        READ_TRT_SET,
191        READ_TRT_REQ
192      };
193
194      /* States of the WRITE fsm */
195      enum write_fsm_state_e
196      {
197        WRITE_IDLE,
198        WRITE_NEXT,
199        WRITE_DIR_REQ,
200        WRITE_DIR_LOCK,
201        WRITE_DIR_HIT,
202        WRITE_UPT_LOCK,
203        WRITE_UPT_HEAP_LOCK,
204        WRITE_UPT_REQ,
205        WRITE_UPT_NEXT,
206        WRITE_UPT_DEC,
207        WRITE_RSP,
208        WRITE_MISS_TRT_LOCK,
209        WRITE_MISS_TRT_DATA,
210        WRITE_MISS_TRT_SET,
211        WRITE_MISS_XRAM_REQ,
212        WRITE_BC_DIR_READ,
213        WRITE_BC_TRT_LOCK,
214        WRITE_BC_IVT_LOCK,
215        WRITE_BC_DIR_INVAL,
216        WRITE_BC_CC_SEND,
217        WRITE_BC_XRAM_REQ,
218        WRITE_WAIT
219      };
220
221      /* States of the IXR_RSP fsm */
222      enum ixr_rsp_fsm_state_e
223      {
224        IXR_RSP_IDLE,
225        IXR_RSP_TRT_ERASE,
226        IXR_RSP_TRT_READ
227      };
228
229      /* States of the XRAM_RSP fsm */
230      enum xram_rsp_fsm_state_e
231      {
232        XRAM_RSP_IDLE,
233        XRAM_RSP_TRT_COPY,
234        XRAM_RSP_TRT_DIRTY,
235        XRAM_RSP_DIR_LOCK,
236        XRAM_RSP_DIR_UPDT,
237        XRAM_RSP_DIR_RSP,
238        XRAM_RSP_IVT_LOCK,
239        XRAM_RSP_INVAL_WAIT,
240        XRAM_RSP_INVAL,
241        XRAM_RSP_WRITE_DIRTY,
242        XRAM_RSP_HEAP_REQ,
243        XRAM_RSP_HEAP_ERASE,
244        XRAM_RSP_HEAP_LAST,
245        XRAM_RSP_ERROR_ERASE,
246        XRAM_RSP_ERROR_RSP
247      };
248
249      /* States of the IXR_CMD fsm */
250      enum ixr_cmd_fsm_state_e
251      {
252        IXR_CMD_READ_IDLE,
253        IXR_CMD_WRITE_IDLE,
254        IXR_CMD_CAS_IDLE,
255        IXR_CMD_XRAM_IDLE,
256        IXR_CMD_CONFIG_IDLE,
257        IXR_CMD_READ_TRT,
258        IXR_CMD_WRITE_TRT,
259        IXR_CMD_CAS_TRT,
260        IXR_CMD_XRAM_TRT,
261        IXR_CMD_CONFIG_TRT,
262        IXR_CMD_READ_SEND,
263        IXR_CMD_WRITE_SEND,
264        IXR_CMD_CAS_SEND,
265        IXR_CMD_XRAM_SEND,
266        IXR_CMD_CONFIG_SEND
267      };
268
269      /* States of the CAS fsm */
270      enum cas_fsm_state_e
271      {
272        CAS_IDLE,
273        CAS_DIR_REQ,
274        CAS_DIR_LOCK,
275        CAS_DIR_HIT_READ,
276        CAS_DIR_HIT_COMPARE,
277        CAS_DIR_HIT_WRITE,
278        CAS_UPT_LOCK,
279        CAS_UPT_HEAP_LOCK,
280        CAS_UPT_REQ,
281        CAS_UPT_NEXT,
282        CAS_BC_TRT_LOCK,
283        CAS_BC_IVT_LOCK,
284        CAS_BC_DIR_INVAL,
285        CAS_BC_CC_SEND,
286        CAS_BC_XRAM_REQ,
287        CAS_RSP_FAIL,
288        CAS_RSP_SUCCESS,
289        CAS_MISS_TRT_LOCK,
290        CAS_MISS_TRT_SET,
291        CAS_MISS_XRAM_REQ,
292        CAS_WAIT
293      };
294
295      /* States of the CLEANUP fsm */
296      enum cleanup_fsm_state_e
297      {
298        CLEANUP_IDLE,
299        CLEANUP_GET_NLINE,
300        CLEANUP_DIR_REQ,
301        CLEANUP_DIR_LOCK,
302        CLEANUP_DIR_WRITE,
303        CLEANUP_HEAP_REQ,
304        CLEANUP_HEAP_LOCK,
305        CLEANUP_HEAP_SEARCH,
306        CLEANUP_HEAP_CLEAN,
307        CLEANUP_HEAP_FREE,
308        CLEANUP_IVT_LOCK,
309        CLEANUP_IVT_DECREMENT,
310        CLEANUP_IVT_CLEAR,
311        CLEANUP_WRITE_RSP,
312        CLEANUP_SEND_CLACK
313      };
314
315      /* States of the ALLOC_DIR fsm */
316      enum alloc_dir_fsm_state_e
317      {
318        ALLOC_DIR_RESET,
319        ALLOC_DIR_READ,
320        ALLOC_DIR_WRITE,
321        ALLOC_DIR_CAS,
322        ALLOC_DIR_CLEANUP,
323        ALLOC_DIR_XRAM_RSP,
324        ALLOC_DIR_CONFIG
325      };
326
327      /* States of the ALLOC_TRT fsm */
328      enum alloc_trt_fsm_state_e
329      {
330        ALLOC_TRT_READ,
331        ALLOC_TRT_WRITE,
332        ALLOC_TRT_CAS,
333        ALLOC_TRT_XRAM_RSP,
334        ALLOC_TRT_IXR_RSP,
335        ALLOC_TRT_IXR_CMD,
336        ALLOC_TRT_CONFIG
337      };
338
339      /* States of the ALLOC_UPT fsm */
340      enum alloc_upt_fsm_state_e
341      {
342        ALLOC_UPT_WRITE,
343        ALLOC_UPT_CAS,
344        ALLOC_UPT_MULTI_ACK
345      };
346
347      /* States of the ALLOC_IVT fsm */
348      enum alloc_ivt_fsm_state_e
349      {
350        ALLOC_IVT_WRITE,
351        ALLOC_IVT_XRAM_RSP,
352        ALLOC_IVT_CLEANUP,
353        ALLOC_IVT_CAS,
354        ALLOC_IVT_CONFIG
355      };
356
357      /* States of the ALLOC_HEAP fsm */
358      enum alloc_heap_fsm_state_e
359      {
360        ALLOC_HEAP_RESET,
361        ALLOC_HEAP_READ,
362        ALLOC_HEAP_WRITE,
363        ALLOC_HEAP_CAS,
364        ALLOC_HEAP_CLEANUP,
365        ALLOC_HEAP_XRAM_RSP,
366        ALLOC_HEAP_CONFIG
367      };
368
369      /* transaction type, pktid field */
370      enum transaction_type_e
371      {
372          // b3 unused
373          // b2 READ / NOT READ
374          // Si READ
375          //  b1 DATA / INS
376          //  b0 UNC / MISS
377          // Si NOT READ
378          //  b1 accÚs table llsc type SW / other
379          //  b2 WRITE/CAS/LL/SC
380          TYPE_READ_DATA_UNC          = 0x0,
381          TYPE_READ_DATA_MISS         = 0x1,
382          TYPE_READ_INS_UNC           = 0x2,
383          TYPE_READ_INS_MISS          = 0x3,
384          TYPE_WRITE                  = 0x4,
385          TYPE_CAS                    = 0x5,
386          TYPE_LL                     = 0x6,
387          TYPE_SC                     = 0x7
388      };
389
390      /* SC return values */
391      enum sc_status_type_e
392      {
393          SC_SUCCESS  =   0x00000000,
394          SC_FAIL     =   0x00000001
395      };
396
397      // debug variables
398      bool                 m_debug;
399      bool                 m_debug_previous_valid;
400      size_t               m_debug_previous_count;
401      bool                 m_debug_previous_dirty;
402      data_t *             m_debug_previous_data;
403      data_t *             m_debug_data;
404
405      // instrumentation counters
406      uint32_t     m_cpt_cycles;         // Counter of cycles
407
408      // Counters accessible in software (not yet but eventually)
409      uint32_t     m_cpt_read_local;     // Number of local READ transactions
410      uint32_t     m_cpt_read_remote;    // number of remote READ transactions
411      uint32_t     m_cpt_read_cost;      // Number of (flits * distance) for READs
412
413      uint32_t     m_cpt_write_local;    // Number of local WRITE transactions
414      uint32_t     m_cpt_write_remote;   // number of remote WRITE transactions
415      uint32_t     m_cpt_write_flits_local;  // number of flits for local WRITEs
416      uint32_t     m_cpt_write_flits_remote; // number of flits for remote WRITEs
417      uint32_t     m_cpt_write_cost;     // Number of (flits * distance) for WRITEs
418
419      uint32_t     m_cpt_ll_local;       // Number of local LL transactions
420      uint32_t     m_cpt_ll_remote;      // number of remote LL transactions
421      uint32_t     m_cpt_ll_cost;        // Number of (flits * distance) for LLs
422
423      uint32_t     m_cpt_sc_local;       // Number of local SC transactions
424      uint32_t     m_cpt_sc_remote;      // number of remote SC transactions
425      uint32_t     m_cpt_sc_cost;        // Number of (flits * distance) for SCs
426
427      uint32_t     m_cpt_cas_local;      // Number of local SC transactions
428      uint32_t     m_cpt_cas_remote;     // number of remote SC transactions
429      uint32_t     m_cpt_cas_cost;       // Number of (flits * distance) for SCs
430
431      uint32_t     m_cpt_update;         // Number of requests causing an UPDATE
432      uint32_t     m_cpt_update_local;   // Number of local UPDATE transactions
433      uint32_t     m_cpt_update_remote;  // Number of remote UPDATE transactions
434      uint32_t     m_cpt_update_cost;    // Number of (flits * distance) for UPDT
435
436      uint32_t     m_cpt_m_inval;        // Number of requests causing M_INV
437      uint32_t     m_cpt_m_inval_local;  // Number of local M_INV transactions
438      uint32_t     m_cpt_m_inval_remote; // Number of remote M_INV transactions
439      uint32_t     m_cpt_m_inval_cost;   // Number of (flits * distance) for M_INV
440
441      uint32_t     m_cpt_br_inval;       // Number of BROADCAST INVAL
442
443      uint32_t     m_cpt_cleanup_local;  // Number of local CLEANUP transactions
444      uint32_t     m_cpt_cleanup_remote; // Number of remote CLEANUP transactions
445      uint32_t     m_cpt_cleanup_cost;   // Number of (flits * distance) for CLEANUPs
446
447      // Counters not accessible by software
448      uint32_t     m_cpt_read_miss;      // Number of MISS READ
449      uint32_t     m_cpt_write_miss;     // Number of MISS WRITE
450      uint32_t     m_cpt_write_dirty;    // Cumulated length for WRITE transactions
451      uint32_t     m_cpt_write_broadcast;// Number of BROADCAST INVAL because write
452
453      uint32_t     m_cpt_trt_rb;         // Read blocked by a hit in trt
454      uint32_t     m_cpt_trt_full;       // Transaction blocked due to a full trt
455
456      uint32_t     m_cpt_get;
457      uint32_t     m_cpt_put;
458
459      size_t       m_prev_count;
460
461      protected:
462
463      SC_HAS_PROCESS(VciMemCache);
464
465      public:
466      sc_in<bool>                                 p_clk;
467      sc_in<bool>                                 p_resetn;
468      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
469      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
470      soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
471      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
472      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
473
474#if MONITOR_MEMCACHE_FSM == 1
475      sc_out<int> p_read_fsm; 
476      sc_out<int> p_write_fsm; 
477      sc_out<int> p_xram_rsp_fsm; 
478      sc_out<int> p_cas_fsm; 
479      sc_out<int> p_cleanup_fsm; 
480      sc_out<int> p_config_fsm; 
481      sc_out<int> p_alloc_heap_fsm; 
482      sc_out<int> p_alloc_dir_fsm; 
483      sc_out<int> p_alloc_trt_fsm; 
484      sc_out<int> p_alloc_upt_fsm; 
485      sc_out<int> p_alloc_ivt_fsm; 
486      sc_out<int> p_tgt_cmd_fsm; 
487      sc_out<int> p_tgt_rsp_fsm; 
488      sc_out<int> p_ixr_cmd_fsm; 
489      sc_out<int> p_ixr_rsp_fsm; 
490      sc_out<int> p_cc_send_fsm; 
491      sc_out<int> p_cc_receive_fsm; 
492      sc_out<int> p_multi_ack_fsm; 
493#endif
494
495      VciMemCache(
496          sc_module_name name,                                // Instance Name
497          const soclib::common::MappingTable &mtp,            // Mapping table INT network
498          const soclib::common::MappingTable &mtx,            // Mapping table RAM network
499          const soclib::common::IntTab       &srcid_x,        // global index RAM network
500          const soclib::common::IntTab       &tgtid_d,        // global index INT network
501          const size_t                       cc_global_id,    // global index CC network
502          const size_t                       x_width,         // X width in platform
503          const size_t                       y_width,         // Y width in platform
504          const size_t                       nways,           // Number of ways per set
505          const size_t                       nsets,           // Number of sets
506          const size_t                       nwords,          // Number of words per line
507          const size_t                       max_copies,      // max number of copies
508          const size_t                       heap_size=HEAP_ENTRIES,
509          const size_t                       trt_lines=TRT_ENTRIES, 
510          const size_t                       upt_lines=UPT_ENTRIES,     
511          const size_t                       ivt_lines=IVT_ENTRIES,     
512          const size_t                       debug_start_cycle=0,
513          const bool                         debug_ok=false );
514
515      ~VciMemCache();
516
517      void print_stats(bool activity_counters, bool stats);
518      void print_trace();
519      void cache_monitor(addr_t addr);
520      void start_monitor(addr_t addr, addr_t length);
521      void stop_monitor();
522
523      private:
524
525      void transition();
526      void genMoore();
527      void check_monitor(addr_t addr, data_t data, bool read);
528      uint32_t req_distance(uint32_t req_srcid);
529      bool is_local_req(uint32_t req_srcid);
530
531      // Component attributes
532      std::list<soclib::common::Segment> m_seglist;          // segments allocated
533      size_t                             m_nseg;             // number of segments
534      soclib::common::Segment            **m_seg;            // array of segments pointers
535      size_t                             m_seg_config;       // config segment index
536      const size_t                       m_srcid_x;          // global index on RAM network
537      const size_t                       m_initiators;       // Number of initiators
538      const size_t                       m_heap_size;        // Size of the heap
539      const size_t                       m_ways;             // Number of ways in a set
540      const size_t                       m_sets;             // Number of cache sets
541      const size_t                       m_words;            // Number of words in a line
542      const size_t                       m_cc_global_id;     // global_index on cc network
543      const size_t                       m_xwidth;           // number of x bits in platform
544      const size_t                       m_ywidth;           // number of y bits in platform
545      size_t                             m_debug_start_cycle;
546      bool                               m_debug_ok;
547      uint32_t                           m_trt_lines;
548      TransactionTab                     m_trt;              // xram transaction table
549      uint32_t                           m_upt_lines;
550      UpdateTab                          m_upt;              // pending update
551      UpdateTab                          m_ivt;              // pending invalidate
552      CacheDirectory                     m_cache_directory;  // data cache directory
553      CacheData                          m_cache_data;       // data array[set][way][word]
554      HeapDirectory                      m_heap;             // heap for copies
555      size_t                             m_max_copies;       // max number of copies in heap
556      GenericLLSCGlobalTable
557      < 32  ,    // number of slots
558        4096,    // number of processors in the system
559        8000,    // registration life (# of LL operations)
560        addr_t >                         m_llsc_table;       // ll/sc registration table
561
562      // adress masks
563      const soclib::common::AddressMaskingTable<addr_t>   m_x;
564      const soclib::common::AddressMaskingTable<addr_t>   m_y;
565      const soclib::common::AddressMaskingTable<addr_t>   m_z;
566      const soclib::common::AddressMaskingTable<addr_t>   m_nline;
567
568      // broadcast address
569      uint32_t                           m_broadcast_boundaries;
570
571      // Fifo between TGT_CMD fsm and READ fsm
572      GenericFifo<addr_t>    m_cmd_read_addr_fifo;
573      GenericFifo<size_t>    m_cmd_read_length_fifo;
574      GenericFifo<size_t>    m_cmd_read_srcid_fifo;
575      GenericFifo<size_t>    m_cmd_read_trdid_fifo;
576      GenericFifo<size_t>    m_cmd_read_pktid_fifo;
577
578      // Fifo between TGT_CMD fsm and WRITE fsm
579      GenericFifo<addr_t>    m_cmd_write_addr_fifo;
580      GenericFifo<bool>      m_cmd_write_eop_fifo;
581      GenericFifo<size_t>    m_cmd_write_srcid_fifo;
582      GenericFifo<size_t>    m_cmd_write_trdid_fifo;
583      GenericFifo<size_t>    m_cmd_write_pktid_fifo;
584      GenericFifo<data_t>    m_cmd_write_data_fifo;
585      GenericFifo<be_t>      m_cmd_write_be_fifo;
586
587      // Fifo between TGT_CMD fsm and CAS fsm
588      GenericFifo<addr_t>    m_cmd_cas_addr_fifo;
589      GenericFifo<bool>      m_cmd_cas_eop_fifo;
590      GenericFifo<size_t>    m_cmd_cas_srcid_fifo;
591      GenericFifo<size_t>    m_cmd_cas_trdid_fifo;
592      GenericFifo<size_t>    m_cmd_cas_pktid_fifo;
593      GenericFifo<data_t>    m_cmd_cas_wdata_fifo;
594
595      // Fifo between CC_RECEIVE fsm and CLEANUP fsm
596      GenericFifo<uint64_t>  m_cc_receive_to_cleanup_fifo;
597     
598      // Fifo between CC_RECEIVE fsm and MULTI_ACK fsm
599      GenericFifo<uint64_t>  m_cc_receive_to_multi_ack_fifo;
600
601      // Buffer between TGT_CMD fsm and TGT_RSP fsm
602      // (segmentation violation response request)
603      sc_signal<bool>     r_tgt_cmd_to_tgt_rsp_req;
604
605      sc_signal<uint32_t> r_tgt_cmd_to_tgt_rsp_rdata;
606      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_error;
607      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_srcid;
608      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_trdid;
609      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_pktid;
610
611      sc_signal<addr_t>   r_tgt_cmd_config_addr;
612      sc_signal<size_t>   r_tgt_cmd_config_cmd;
613
614      //////////////////////////////////////////////////
615      // Registers controlled by the TGT_CMD fsm
616      //////////////////////////////////////////////////
617
618      sc_signal<int>         r_tgt_cmd_fsm;
619
620      ///////////////////////////////////////////////////////
621      // Registers controlled by the CONFIG fsm
622      ///////////////////////////////////////////////////////
623
624      sc_signal<int>      r_config_fsm;               // FSM state
625      sc_signal<bool>     r_config_lock;              // lock protecting exclusive access
626      sc_signal<int>      r_config_cmd;               // config request type 
627      sc_signal<addr_t>   r_config_address;           // target buffer physical address
628      sc_signal<size_t>   r_config_srcid;             // config request srcid
629      sc_signal<size_t>   r_config_trdid;             // config request trdid
630      sc_signal<size_t>   r_config_pktid;             // config request pktid
631      sc_signal<size_t>   r_config_cmd_lines;         // number of lines to be handled
632      sc_signal<size_t>   r_config_rsp_lines;         // number of lines not completed
633      sc_signal<size_t>   r_config_dir_way;           // DIR: selected way
634      sc_signal<bool>     r_config_dir_lock;          // DIR: locked entry
635      sc_signal<size_t>   r_config_dir_count;         // DIR: number of copies
636      sc_signal<bool>     r_config_dir_is_cnt;        // DIR: counter mode (broadcast)
637      sc_signal<size_t>   r_config_dir_copy_srcid;    // DIR: first copy SRCID
638      sc_signal<bool>     r_config_dir_copy_inst;     // DIR: first copy L1 type
639      sc_signal<size_t>   r_config_dir_ptr;           // DIR: index of next copy in HEAP
640      sc_signal<size_t>   r_config_heap_next;         // current pointer to scan HEAP
641      sc_signal<size_t>   r_config_trt_index;         // selected entry in TRT
642      sc_signal<size_t>   r_config_ivt_index;         // selected entry in IVT
643
644      // Buffer between CONFIG fsm and IXR_CMD fsm
645      sc_signal<bool>     r_config_to_ixr_cmd_req;    // valid request
646      sc_signal<size_t>   r_config_to_ixr_cmd_index;  // TRT index
647
648      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
649      sc_signal<bool>     r_config_to_tgt_rsp_req;    // valid request
650      sc_signal<bool>     r_config_to_tgt_rsp_error;  // error response
651      sc_signal<size_t>   r_config_to_tgt_rsp_srcid;  // Transaction srcid
652      sc_signal<size_t>   r_config_to_tgt_rsp_trdid;  // Transaction trdid
653      sc_signal<size_t>   r_config_to_tgt_rsp_pktid;  // Transaction pktid
654
655      // Buffer between CONFIG fsm and CC_SEND fsm (multi-inval / broadcast-inval)
656      sc_signal<bool>     r_config_to_cc_send_multi_req;    // multi-inval request
657      sc_signal<bool>     r_config_to_cc_send_brdcast_req;  // broadcast-inval request
658      sc_signal<addr_t>   r_config_to_cc_send_nline;        // line index
659      sc_signal<size_t>   r_config_to_cc_send_trdid;        // UPT index
660      GenericFifo<bool>   m_config_to_cc_send_inst_fifo;    // fifo for the L1 type
661      GenericFifo<size_t> m_config_to_cc_send_srcid_fifo;   // fifo for owners srcid
662
663      ///////////////////////////////////////////////////////
664      // Registers controlled by the READ fsm
665      ///////////////////////////////////////////////////////
666
667      sc_signal<int>      r_read_fsm;                 // FSM state
668      sc_signal<size_t>   r_read_copy;                // Srcid of the first copy
669      sc_signal<size_t>   r_read_copy_cache;          // Srcid of the first copy
670      sc_signal<bool>     r_read_copy_inst;           // Type of the first copy
671      sc_signal<tag_t>    r_read_tag;                 // cache line tag (in directory)
672      sc_signal<bool>     r_read_is_cnt;              // is_cnt bit (in directory)
673      sc_signal<bool>     r_read_lock;                // lock bit (in directory)
674      sc_signal<bool>     r_read_dirty;               // dirty bit (in directory)
675      sc_signal<size_t>   r_read_count;               // number of copies
676      sc_signal<size_t>   r_read_ptr;                 // pointer to the heap
677      sc_signal<data_t> * r_read_data;                // data (one cache line)
678      sc_signal<size_t>   r_read_way;                 // associative way (in cache)
679      sc_signal<size_t>   r_read_trt_index;           // Transaction Table index
680      sc_signal<size_t>   r_read_next_ptr;            // Next entry to point to
681      sc_signal<bool>     r_read_last_free;           // Last free entry
682      sc_signal<addr_t>   r_read_ll_key;              // LL key from llsc_global_table
683
684      // Buffer between READ fsm and IXR_CMD fsm
685      sc_signal<bool>     r_read_to_ixr_cmd_req;      // valid request
686      sc_signal<size_t>   r_read_to_ixr_cmd_index;    // TRT index
687
688      // Buffer between READ fsm and TGT_RSP fsm (send a hit read response to L1 cache)
689      sc_signal<bool>     r_read_to_tgt_rsp_req;      // valid request
690      sc_signal<size_t>   r_read_to_tgt_rsp_srcid;    // Transaction srcid
691      sc_signal<size_t>   r_read_to_tgt_rsp_trdid;    // Transaction trdid
692      sc_signal<size_t>   r_read_to_tgt_rsp_pktid;    // Transaction pktid
693      sc_signal<data_t> * r_read_to_tgt_rsp_data;     // data (one cache line)
694      sc_signal<size_t>   r_read_to_tgt_rsp_word;     // first word of the response
695      sc_signal<size_t>   r_read_to_tgt_rsp_length;   // length of the response
696      sc_signal<addr_t>   r_read_to_tgt_rsp_ll_key;   // LL key from llsc_global_table
697
698      ///////////////////////////////////////////////////////////////
699      // Registers controlled by the WRITE fsm
700      ///////////////////////////////////////////////////////////////
701
702      sc_signal<int>      r_write_fsm;                // FSM state
703      sc_signal<addr_t>   r_write_address;            // first word address
704      sc_signal<size_t>   r_write_word_index;         // first word index in line
705      sc_signal<size_t>   r_write_word_count;         // number of words in line
706      sc_signal<size_t>   r_write_srcid;              // transaction srcid
707      sc_signal<size_t>   r_write_trdid;              // transaction trdid
708      sc_signal<size_t>   r_write_pktid;              // transaction pktid
709      sc_signal<data_t> * r_write_data;               // data (one cache line)
710      sc_signal<be_t>   * r_write_be;                 // one byte enable per word
711      sc_signal<bool>     r_write_byte;               // (BE != 0X0) and (BE != 0xF)
712      sc_signal<bool>     r_write_is_cnt;             // is_cnt bit (in directory)
713      sc_signal<bool>     r_write_lock;               // lock bit (in directory)
714      sc_signal<tag_t>    r_write_tag;                // cache line tag (in directory)
715      sc_signal<size_t>   r_write_copy;               // first owner of the line
716      sc_signal<size_t>   r_write_copy_cache;         // first owner of the line
717      sc_signal<bool>     r_write_copy_inst;          // is this owner a ICache ?
718      sc_signal<size_t>   r_write_count;              // number of copies
719      sc_signal<size_t>   r_write_ptr;                // pointer to the heap
720      sc_signal<size_t>   r_write_next_ptr;           // next pointer to the heap
721      sc_signal<bool>     r_write_to_dec;             // need to decrement update counter
722      sc_signal<size_t>   r_write_way;                // way of the line
723      sc_signal<size_t>   r_write_trt_index;          // index in Transaction Table
724      sc_signal<size_t>   r_write_upt_index;          // index in Update Table
725      sc_signal<bool>     r_write_sc_fail;            // sc command failed
726      sc_signal<data_t>   r_write_sc_key;             // sc command key
727      sc_signal<bool>     r_write_bc_data_we;         // Write enable for data buffer
728
729      // Buffer between WRITE fsm and TGT_RSP fsm (acknowledge a write command from L1)
730      sc_signal<bool>     r_write_to_tgt_rsp_req;     // valid request
731      sc_signal<size_t>   r_write_to_tgt_rsp_srcid;   // transaction srcid
732      sc_signal<size_t>   r_write_to_tgt_rsp_trdid;   // transaction trdid
733      sc_signal<size_t>   r_write_to_tgt_rsp_pktid;   // transaction pktid
734      sc_signal<bool>     r_write_to_tgt_rsp_sc_fail; // sc command failed
735
736      // Buffer between WRITE fsm and IXR_CMD fsm
737      sc_signal<bool>     r_write_to_ixr_cmd_req;     // valid request
738      sc_signal<size_t>   r_write_to_ixr_cmd_index;   // TRT index
739
740      // Buffer between WRITE fsm and CC_SEND fsm (Update/Invalidate L1 caches)
741      sc_signal<bool>     r_write_to_cc_send_multi_req;     // valid multicast request
742      sc_signal<bool>     r_write_to_cc_send_brdcast_req;   // valid brdcast request
743      sc_signal<addr_t>   r_write_to_cc_send_nline;         // cache line index
744      sc_signal<size_t>   r_write_to_cc_send_trdid;         // index in Update Table
745      sc_signal<data_t> * r_write_to_cc_send_data;          // data (one cache line)
746      sc_signal<be_t>   * r_write_to_cc_send_be;            // word enable
747      sc_signal<size_t>   r_write_to_cc_send_count;         // number of words in line
748      sc_signal<size_t>   r_write_to_cc_send_index;         // index of first word in line
749      GenericFifo<bool>   m_write_to_cc_send_inst_fifo;     // fifo for the L1 type
750      GenericFifo<size_t> m_write_to_cc_send_srcid_fifo;    // fifo for srcids
751
752      // Buffer between WRITE fsm and MULTI_ACK fsm (Decrement UPT entry)
753      sc_signal<bool>     r_write_to_multi_ack_req;       // valid request
754      sc_signal<size_t>   r_write_to_multi_ack_upt_index; // index in update table
755
756      /////////////////////////////////////////////////////////
757      // Registers controlled by MULTI_ACK fsm
758      //////////////////////////////////////////////////////////
759
760      sc_signal<int>      r_multi_ack_fsm;       // FSM state
761      sc_signal<size_t>   r_multi_ack_upt_index; // index in the Update Table
762      sc_signal<size_t>   r_multi_ack_srcid;     // pending write srcid
763      sc_signal<size_t>   r_multi_ack_trdid;     // pending write trdid
764      sc_signal<size_t>   r_multi_ack_pktid;     // pending write pktid
765      sc_signal<addr_t>   r_multi_ack_nline;     // pending write nline
766
767      // Buffer between MULTI_ACK fsm and TGT_RSP fsm (complete write/update transaction)
768      sc_signal<bool>     r_multi_ack_to_tgt_rsp_req;   // valid request
769      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_srcid; // Transaction srcid
770      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_trdid; // Transaction trdid
771      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_pktid; // Transaction pktid
772
773      ///////////////////////////////////////////////////////
774      // Registers controlled by CLEANUP fsm
775      ///////////////////////////////////////////////////////
776
777      sc_signal<int>      r_cleanup_fsm;           // FSM state
778      sc_signal<size_t>   r_cleanup_srcid;         // transaction srcid
779      sc_signal<bool>     r_cleanup_inst;          // Instruction or Data ?
780      sc_signal<size_t>   r_cleanup_way_index;     // L1 Cache Way index
781      sc_signal<addr_t>   r_cleanup_nline;         // cache line index
782
783
784      sc_signal<copy_t>   r_cleanup_copy;          // first copy
785      sc_signal<copy_t>   r_cleanup_copy_cache;    // first copy
786      sc_signal<size_t>   r_cleanup_copy_inst;     // type of the first copy
787      sc_signal<copy_t>   r_cleanup_count;         // number of copies
788      sc_signal<size_t>   r_cleanup_ptr;           // pointer to the heap
789      sc_signal<size_t>   r_cleanup_prev_ptr;      // previous pointer to the heap
790      sc_signal<size_t>   r_cleanup_prev_srcid;    // srcid of previous heap entry
791      sc_signal<size_t>   r_cleanup_prev_cache_id; // srcid of previous heap entry
792      sc_signal<bool>     r_cleanup_prev_inst;     // inst bit of previous heap entry
793      sc_signal<size_t>   r_cleanup_next_ptr;      // next pointer to the heap
794      sc_signal<tag_t>    r_cleanup_tag;           // cache line tag (in directory)
795      sc_signal<bool>     r_cleanup_is_cnt;        // inst bit (in directory)
796      sc_signal<bool>     r_cleanup_lock;          // lock bit (in directory)
797      sc_signal<bool>     r_cleanup_dirty;         // dirty bit (in directory)
798      sc_signal<size_t>   r_cleanup_way;           // associative way (in cache)
799
800      sc_signal<size_t>   r_cleanup_write_srcid;   // srcid of write rsp
801      sc_signal<size_t>   r_cleanup_write_trdid;   // trdid of write rsp
802      sc_signal<size_t>   r_cleanup_write_pktid;   // pktid of write rsp
803
804      sc_signal<bool>     r_cleanup_need_rsp;      // write response required
805      sc_signal<bool>     r_cleanup_need_ack;      // config acknowledge required
806
807      sc_signal<size_t>   r_cleanup_index;         // index of the INVAL line (in the UPT)
808
809      // Buffer between CLEANUP fsm and TGT_RSP fsm (acknowledge a write command from L1)
810      sc_signal<bool>     r_cleanup_to_tgt_rsp_req;   // valid request
811      sc_signal<size_t>   r_cleanup_to_tgt_rsp_srcid; // transaction srcid
812      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
813      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
814
815      ///////////////////////////////////////////////////////
816      // Registers controlled by CAS fsm
817      ///////////////////////////////////////////////////////
818
819      sc_signal<int>      r_cas_fsm;              // FSM state
820      sc_signal<data_t>   r_cas_wdata;            // write data word
821      sc_signal<data_t> * r_cas_rdata;            // read data word
822      sc_signal<uint32_t> r_cas_lfsr;             // lfsr for random introducing
823      sc_signal<size_t>   r_cas_cpt;              // size of command
824      sc_signal<copy_t>   r_cas_copy;             // Srcid of the first copy
825      sc_signal<copy_t>   r_cas_copy_cache;       // Srcid of the first copy
826      sc_signal<bool>     r_cas_copy_inst;        // Type of the first copy
827      sc_signal<size_t>   r_cas_count;            // number of copies
828      sc_signal<size_t>   r_cas_ptr;              // pointer to the heap
829      sc_signal<size_t>   r_cas_next_ptr;         // next pointer to the heap
830      sc_signal<bool>     r_cas_is_cnt;           // is_cnt bit (in directory)
831      sc_signal<bool>     r_cas_dirty;            // dirty bit (in directory)
832      sc_signal<size_t>   r_cas_way;              // way in directory
833      sc_signal<size_t>   r_cas_set;              // set in directory
834      sc_signal<data_t>   r_cas_tag;              // cache line tag (in directory)
835      sc_signal<size_t>   r_cas_trt_index;        // Transaction Table index
836      sc_signal<size_t>   r_cas_upt_index;        // Update Table index
837      sc_signal<data_t> * r_cas_data;             // cache line data
838
839      // Buffer between CAS fsm and IXR_CMD fsm
840      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
841      sc_signal<size_t>   r_cas_to_ixr_cmd_index; // TRT index
842
843      // Buffer between CAS fsm and TGT_RSP fsm
844      sc_signal<bool>     r_cas_to_tgt_rsp_req;   // valid request
845      sc_signal<data_t>   r_cas_to_tgt_rsp_data;  // read data word
846      sc_signal<size_t>   r_cas_to_tgt_rsp_srcid; // Transaction srcid
847      sc_signal<size_t>   r_cas_to_tgt_rsp_trdid; // Transaction trdid
848      sc_signal<size_t>   r_cas_to_tgt_rsp_pktid; // Transaction pktid
849
850      // Buffer between CAS fsm and CC_SEND fsm (Update/Invalidate L1 caches)
851      sc_signal<bool>     r_cas_to_cc_send_multi_req;     // valid request
852      sc_signal<bool>     r_cas_to_cc_send_brdcast_req;   // brdcast request
853      sc_signal<addr_t>   r_cas_to_cc_send_nline;         // cache line index
854      sc_signal<size_t>   r_cas_to_cc_send_trdid;         // index in Update Table
855      sc_signal<data_t>   r_cas_to_cc_send_wdata;         // data (one word)
856      sc_signal<bool>     r_cas_to_cc_send_is_long;       // it is a 64 bits CAS
857      sc_signal<data_t>   r_cas_to_cc_send_wdata_high;    // data high (one word)
858      sc_signal<size_t>   r_cas_to_cc_send_index;         // index of the word in line
859      GenericFifo<bool>   m_cas_to_cc_send_inst_fifo;     // fifo for the L1 type
860      GenericFifo<size_t> m_cas_to_cc_send_srcid_fifo;    // fifo for srcids
861
862      ////////////////////////////////////////////////////
863      // Registers controlled by the IXR_RSP fsm
864      ////////////////////////////////////////////////////
865
866      sc_signal<int>      r_ixr_rsp_fsm;                // FSM state
867      sc_signal<size_t>   r_ixr_rsp_trt_index;          // TRT entry index
868      sc_signal<size_t>   r_ixr_rsp_cpt;                // word counter
869
870      // Buffer between IXR_RSP fsm and CONFIG fsm  (response from the XRAM)
871      sc_signal<bool>     r_ixr_rsp_to_config_ack;      // one single bit   
872
873      // Buffer between IXR_RSP fsm and XRAM_RSP fsm  (response from the XRAM)
874      sc_signal<bool>   * r_ixr_rsp_to_xram_rsp_rok;    // one bit per TRT entry
875
876      ////////////////////////////////////////////////////
877      // Registers controlled by the XRAM_RSP fsm
878      ////////////////////////////////////////////////////
879
880      sc_signal<int>      r_xram_rsp_fsm;               // FSM state
881      sc_signal<size_t>   r_xram_rsp_trt_index;         // TRT entry index
882      TransactionTabEntry r_xram_rsp_trt_buf;           // TRT entry local buffer
883      sc_signal<bool>     r_xram_rsp_victim_inval;      // victim line invalidate
884      sc_signal<bool>     r_xram_rsp_victim_is_cnt;     // victim line inst bit
885      sc_signal<bool>     r_xram_rsp_victim_dirty;      // victim line dirty bit
886      sc_signal<size_t>   r_xram_rsp_victim_way;        // victim line way
887      sc_signal<size_t>   r_xram_rsp_victim_set;        // victim line set
888      sc_signal<addr_t>   r_xram_rsp_victim_nline;      // victim line index
889      sc_signal<copy_t>   r_xram_rsp_victim_copy;       // victim line first copy
890      sc_signal<copy_t>   r_xram_rsp_victim_copy_cache; // victim line first copy
891      sc_signal<bool>     r_xram_rsp_victim_copy_inst;  // victim line type of first copy
892      sc_signal<size_t>   r_xram_rsp_victim_count;      // victim line number of copies
893      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
894      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
895      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
896      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
897
898      // Buffer between XRAM_RSP fsm and TGT_RSP fsm  (response to L1 cache)
899      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_req;    // Valid request
900      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_srcid;  // Transaction srcid
901      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_trdid;  // Transaction trdid
902      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_pktid;  // Transaction pktid
903      sc_signal<data_t> * r_xram_rsp_to_tgt_rsp_data;   // data (one cache line)
904      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_word;   // first word index
905      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_length; // length of the response
906      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_rerror; // send error to requester
907      sc_signal<addr_t>   r_xram_rsp_to_tgt_rsp_ll_key; // LL key from llsc_global_table
908
909      // Buffer between XRAM_RSP fsm and CC_SEND fsm (Inval L1 Caches)
910      sc_signal<bool>     r_xram_rsp_to_cc_send_multi_req;     // Valid request
911      sc_signal<bool>     r_xram_rsp_to_cc_send_brdcast_req;   // Broadcast request
912      sc_signal<addr_t>   r_xram_rsp_to_cc_send_nline;         // cache line index;
913      sc_signal<size_t>   r_xram_rsp_to_cc_send_trdid;         // index of UPT entry
914      GenericFifo<bool>   m_xram_rsp_to_cc_send_inst_fifo;     // fifo for the L1 type
915      GenericFifo<size_t> m_xram_rsp_to_cc_send_srcid_fifo;    // fifo for srcids
916
917      // Buffer between XRAM_RSP fsm and IXR_CMD fsm
918      sc_signal<bool>     r_xram_rsp_to_ixr_cmd_req;   // Valid request
919      sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_index; // TRT index
920
921      ////////////////////////////////////////////////////
922      // Registers controlled by the IXR_CMD fsm
923      ////////////////////////////////////////////////////
924
925      sc_signal<int>      r_ixr_cmd_fsm;
926      sc_signal<size_t>   r_ixr_cmd_word;              // word index for a put
927      sc_signal<size_t>   r_ixr_cmd_trdid;             // TRT index value     
928      sc_signal<addr_t>   r_ixr_cmd_address;           // address to XRAM
929      sc_signal<data_t> * r_ixr_cmd_wdata;             // cache line buffer
930      sc_signal<bool>     r_ixr_cmd_get;               // transaction type (PUT/GET)
931
932      ////////////////////////////////////////////////////
933      // Registers controlled by TGT_RSP fsm
934      ////////////////////////////////////////////////////
935
936      sc_signal<int>      r_tgt_rsp_fsm;
937      sc_signal<size_t>   r_tgt_rsp_cpt;
938      sc_signal<bool>     r_tgt_rsp_key_sent;
939
940      ////////////////////////////////////////////////////
941      // Registers controlled by CC_SEND fsm
942      ////////////////////////////////////////////////////
943
944      sc_signal<int>      r_cc_send_fsm;
945      sc_signal<size_t>   r_cc_send_cpt;
946      sc_signal<bool>     r_cc_send_inst;
947
948      ////////////////////////////////////////////////////
949      // Registers controlled by CC_RECEIVE fsm
950      ////////////////////////////////////////////////////
951
952      sc_signal<int>      r_cc_receive_fsm;
953
954      ////////////////////////////////////////////////////
955      // Registers controlled by ALLOC_DIR fsm
956      ////////////////////////////////////////////////////
957
958      sc_signal<int>      r_alloc_dir_fsm;
959      sc_signal<unsigned> r_alloc_dir_reset_cpt;
960
961      ////////////////////////////////////////////////////
962      // Registers controlled by ALLOC_TRT fsm
963      ////////////////////////////////////////////////////
964
965      sc_signal<int>      r_alloc_trt_fsm;
966
967      ////////////////////////////////////////////////////
968      // Registers controlled by ALLOC_UPT fsm
969      ////////////////////////////////////////////////////
970
971      sc_signal<int>      r_alloc_upt_fsm;
972
973      ////////////////////////////////////////////////////
974      // Registers controlled by ALLOC_IVT fsm
975      ////////////////////////////////////////////////////
976
977      sc_signal<int>      r_alloc_ivt_fsm;
978
979      ////////////////////////////////////////////////////
980      // Registers controlled by ALLOC_HEAP fsm
981      ////////////////////////////////////////////////////
982
983      sc_signal<int>      r_alloc_heap_fsm;
984      sc_signal<unsigned> r_alloc_heap_reset_cpt;
985    }; // end class VciMemCache
986
987}}
988
989#endif
990
991// Local Variables:
992// tab-width: 2
993// c-basic-offset: 2
994// c-file-offsets:((innamespace . 0)(inline-open . 0))
995// indent-tabs-mode: nil
996// End:
997
998// vim: filetype=cpp:expandtab:shiftwidth=2:tabstop=2:softtabstop=2
999
Note: See TracBrowser for help on using the repository browser.