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

Last change on this file since 495 was 489, checked in by alain, 11 years ago

Implement both the SYNC and INVAL configuration commands.
Uses the TRT to transmit the cache line to XRAM in cPUT transactions.
Improve the debug.
File size: 41.3 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_ERROR,
83        TGT_CMD_READ,
84        TGT_CMD_WRITE,
85        TGT_CMD_CAS,
86        TGT_CMD_CONFIG
87      };
88
89      /* States of the TGT_RSP fsm */
90      enum tgt_rsp_fsm_state_e
91      {
92        TGT_RSP_CONFIG_IDLE,
93        TGT_RSP_TGT_CMD_IDLE,
94        TGT_RSP_READ_IDLE,
95        TGT_RSP_WRITE_IDLE,
96        TGT_RSP_CAS_IDLE,
97        TGT_RSP_XRAM_IDLE,
98        TGT_RSP_MULTI_ACK_IDLE,
99        TGT_RSP_CLEANUP_IDLE,
100        TGT_RSP_CONFIG,
101        TGT_RSP_TGT_CMD,
102        TGT_RSP_READ,
103        TGT_RSP_WRITE,
104        TGT_RSP_CAS,
105        TGT_RSP_XRAM,
106        TGT_RSP_MULTI_ACK,
107        TGT_RSP_CLEANUP
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_CONFIG_IDLE,
123        CC_SEND_XRAM_RSP_IDLE,
124        CC_SEND_WRITE_IDLE,
125        CC_SEND_CAS_IDLE,
126        CC_SEND_CONFIG_INVAL_HEADER,
127        CC_SEND_CONFIG_INVAL_NLINE,
128        CC_SEND_CONFIG_BRDCAST_HEADER,
129        CC_SEND_CONFIG_BRDCAST_NLINE,
130        CC_SEND_XRAM_RSP_BRDCAST_HEADER,
131        CC_SEND_XRAM_RSP_BRDCAST_NLINE,
132        CC_SEND_XRAM_RSP_INVAL_HEADER,
133        CC_SEND_XRAM_RSP_INVAL_NLINE,
134        CC_SEND_WRITE_BRDCAST_HEADER,
135        CC_SEND_WRITE_BRDCAST_NLINE,
136        CC_SEND_WRITE_UPDT_HEADER,
137        CC_SEND_WRITE_UPDT_NLINE,
138        CC_SEND_WRITE_UPDT_DATA,
139        CC_SEND_CAS_BRDCAST_HEADER,
140        CC_SEND_CAS_BRDCAST_NLINE,
141        CC_SEND_CAS_UPDT_HEADER,
142        CC_SEND_CAS_UPDT_NLINE,
143        CC_SEND_CAS_UPDT_DATA,
144        CC_SEND_CAS_UPDT_DATA_HIGH
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_CONFIG,
320        ALLOC_DIR_READ,
321        ALLOC_DIR_WRITE,
322        ALLOC_DIR_CAS,
323        ALLOC_DIR_CLEANUP,
324        ALLOC_DIR_XRAM_RSP
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_CONFIG,
336        ALLOC_TRT_IXR_CMD
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      uint32_t     m_cpt_read;          // Number of READ transactions
409      uint32_t     m_cpt_read_remote;   // number of remote READ transactions
410      uint32_t     m_cpt_read_flits;    // number of flits for READs
411      uint32_t     m_cpt_read_cost;     // Number of (flits * distance) for READs
412
413      uint32_t     m_cpt_read_miss;     // Number of MISS READ
414
415      uint32_t     m_cpt_write;         // Number of WRITE transactions
416      uint32_t     m_cpt_write_remote;  // number of remote WRITE transactions
417      uint32_t     m_cpt_write_flits;   // number of flits for WRITEs
418      uint32_t     m_cpt_write_cost;    // Number of (flits * distance) for WRITEs
419
420      uint32_t     m_cpt_write_miss;    // Number of MISS WRITE
421      uint32_t     m_cpt_write_cells;   // Cumulated length for WRITE transactions
422      uint32_t     m_cpt_write_dirty;   // Cumulated length for WRITE transactions
423      uint32_t     m_cpt_update;        // Number of UPDATE transactions
424      uint32_t     m_cpt_trt_rb;        // Read blocked by a hit in trt
425      uint32_t     m_cpt_trt_full;      // Transaction blocked due to a full trt
426      uint32_t     m_cpt_update_mult;   // Number of targets for UPDATE
427      uint32_t     m_cpt_inval;         // Number of INVAL  transactions
428      uint32_t     m_cpt_inval_mult;    // Number of targets for INVAL
429      uint32_t     m_cpt_inval_brdcast; // Number of BROADCAST INVAL
430      uint32_t     m_cpt_cleanup;       // Number of CLEANUP transactions
431      uint32_t     m_cpt_ll;            // Number of LL transactions
432      uint32_t     m_cpt_sc;            // Number of SC transactions
433      uint32_t     m_cpt_cas;           // Number of CAS transactions
434
435      uint32_t     m_cpt_cleanup_cost;  // Number of (flits * distance) for CLEANUPs
436
437      uint32_t     m_cpt_update_flits;  // Number of flits for UPDATEs
438      uint32_t     m_cpt_update_cost;   // Number of (flits * distance) for UPDATEs
439
440      uint32_t     m_cpt_inval_cost;    // Number of (flits * distance) for INVALs
441
442      uint32_t     m_cpt_get;
443
444      uint32_t     m_cpt_put;
445
446      size_t       m_prev_count;
447
448      protected:
449
450      SC_HAS_PROCESS(VciMemCache);
451
452      public:
453      sc_in<bool>                                 p_clk;
454      sc_in<bool>                                 p_resetn;
455      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
456      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
457      soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
458      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
459      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
460
461      VciMemCache(
462          sc_module_name name,                                // Instance Name
463          const soclib::common::MappingTable &mtp,            // Mapping table INT network
464          const soclib::common::MappingTable &mtx,            // Mapping table RAM network
465          const soclib::common::IntTab       &srcid_x,        // global index RAM network
466          const soclib::common::IntTab       &tgtid_d,        // global index INT network
467          const size_t                       cc_global_id,    // global index CC network
468          const size_t                       nways,           // Number of ways per set
469          const size_t                       nsets,           // Number of sets
470          const size_t                       nwords,          // Number of words per line
471          const size_t                       max_copies,      // max number of copies
472          const size_t                       heap_size=HEAP_ENTRIES,
473          const size_t                       trt_lines=TRT_ENTRIES, 
474          const size_t                       upt_lines=UPT_ENTRIES,     
475          const size_t                       ivt_lines=IVT_ENTRIES,     
476          const size_t                       debug_start_cycle=0,
477          const bool                         debug_ok=false );
478
479      ~VciMemCache();
480
481      void print_stats();
482      void print_trace();
483      void cache_monitor(addr_t addr);
484      void start_monitor(addr_t addr, addr_t length);
485      void stop_monitor();
486
487      private:
488
489      void transition();
490      void genMoore();
491      void check_monitor(addr_t addr, data_t data, bool read);
492
493      // Component attributes
494      std::list<soclib::common::Segment> m_seglist;          // segments allocated
495      size_t                             m_nseg;             // number of segments
496      soclib::common::Segment            **m_seg;            // array of segments pointers
497      size_t                             m_seg_config;       // config segment index
498      const size_t                       m_srcid_x;          // global index on RAM network
499      const size_t                       m_initiators;       // Number of initiators
500      const size_t                       m_heap_size;        // Size of the heap
501      const size_t                       m_ways;             // Number of ways in a set
502      const size_t                       m_sets;             // Number of cache sets
503      const size_t                       m_words;            // Number of words in a line
504      const size_t                       m_cc_global_id;     // global_index on cc network
505      size_t                             m_debug_start_cycle;
506      bool                               m_debug_ok;
507      uint32_t                           m_trt_lines;
508      TransactionTab                     m_trt;              // xram transaction table
509      uint32_t                           m_upt_lines;
510      UpdateTab                          m_upt;              // pending update
511      UpdateTab                          m_ivt;              // pending invalidate
512      CacheDirectory                     m_cache_directory;  // data cache directory
513      CacheData                          m_cache_data;       // data array[set][way][word]
514      HeapDirectory                      m_heap;             // heap for copies
515      size_t                             m_max_copies;       // max number of copies in heap
516      GenericLLSCGlobalTable
517      < 32  ,    // number of slots
518        4096,    // number of processors in the system
519        8000,    // registration life (# of LL operations)
520        addr_t >                         m_llsc_table;       // ll/sc registration table
521
522      // adress masks
523      const soclib::common::AddressMaskingTable<addr_t>   m_x;
524      const soclib::common::AddressMaskingTable<addr_t>   m_y;
525      const soclib::common::AddressMaskingTable<addr_t>   m_z;
526      const soclib::common::AddressMaskingTable<addr_t>   m_nline;
527
528      // broadcast address
529      uint32_t                           m_broadcast_boundaries;
530
531      // Fifo between TGT_CMD fsm and READ fsm
532      GenericFifo<addr_t>    m_cmd_read_addr_fifo;
533      GenericFifo<size_t>    m_cmd_read_length_fifo;
534      GenericFifo<size_t>    m_cmd_read_srcid_fifo;
535      GenericFifo<size_t>    m_cmd_read_trdid_fifo;
536      GenericFifo<size_t>    m_cmd_read_pktid_fifo;
537
538      // Fifo between TGT_CMD fsm and WRITE fsm
539      GenericFifo<addr_t>    m_cmd_write_addr_fifo;
540      GenericFifo<bool>      m_cmd_write_eop_fifo;
541      GenericFifo<size_t>    m_cmd_write_srcid_fifo;
542      GenericFifo<size_t>    m_cmd_write_trdid_fifo;
543      GenericFifo<size_t>    m_cmd_write_pktid_fifo;
544      GenericFifo<data_t>    m_cmd_write_data_fifo;
545      GenericFifo<be_t>      m_cmd_write_be_fifo;
546
547      // Fifo between TGT_CMD fsm and CAS fsm
548      GenericFifo<addr_t>    m_cmd_cas_addr_fifo;
549      GenericFifo<bool>      m_cmd_cas_eop_fifo;
550      GenericFifo<size_t>    m_cmd_cas_srcid_fifo;
551      GenericFifo<size_t>    m_cmd_cas_trdid_fifo;
552      GenericFifo<size_t>    m_cmd_cas_pktid_fifo;
553      GenericFifo<data_t>    m_cmd_cas_wdata_fifo;
554
555      // Fifo between CC_RECEIVE fsm and CLEANUP fsm
556      GenericFifo<uint64_t>  m_cc_receive_to_cleanup_fifo;
557     
558      // Fifo between CC_RECEIVE fsm and MULTI_ACK fsm
559      GenericFifo<uint64_t>  m_cc_receive_to_multi_ack_fifo;
560
561      // Buffer between TGT_CMD fsm and TGT_RSP fsm
562      // (segmentation violation response request)
563      sc_signal<bool>     r_tgt_cmd_to_tgt_rsp_req;
564
565      sc_signal<uint32_t> r_tgt_cmd_to_tgt_rsp_rdata;
566      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_error;
567      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_srcid;
568      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_trdid;
569      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_pktid;
570
571      sc_signal<addr_t>   r_tgt_cmd_config_addr;
572      sc_signal<size_t>   r_tgt_cmd_config_cmd;
573
574      //////////////////////////////////////////////////
575      // Registers controlled by the TGT_CMD fsm
576      //////////////////////////////////////////////////
577
578      sc_signal<int>         r_tgt_cmd_fsm;
579      sc_signal<size_t>      r_tgt_cmd_srcid;           // srcid for response to config
580      sc_signal<size_t>      r_tgt_cmd_trdid;           // trdid for response to config
581      sc_signal<size_t>      r_tgt_cmd_pktid;           // pktid for response to config
582
583      ///////////////////////////////////////////////////////
584      // Registers controlled by the CONFIG fsm
585      ///////////////////////////////////////////////////////
586
587      sc_signal<int>      r_config_fsm;               // FSM state
588      sc_signal<bool>     r_config_lock;              // lock protecting exclusive access
589      sc_signal<int>      r_config_cmd;               // config request type 
590      sc_signal<addr_t>   r_config_address;           // target buffer physical address
591      sc_signal<size_t>   r_config_srcid;             // config request srcid
592      sc_signal<size_t>   r_config_trdid;             // config request trdid
593      sc_signal<size_t>   r_config_pktid;             // config request pktid
594      sc_signal<size_t>   r_config_cmd_lines;         // number of lines to be handled
595      sc_signal<size_t>   r_config_rsp_lines;         // number of lines not completed
596      sc_signal<size_t>   r_config_dir_way;           // DIR: selected way
597      sc_signal<bool>     r_config_dir_lock;          // DIR: locked entry
598      sc_signal<size_t>   r_config_dir_count;         // DIR: number of copies
599      sc_signal<bool>     r_config_dir_is_cnt;        // DIR: counter mode (broadcast)
600      sc_signal<size_t>   r_config_dir_copy_srcid;    // DIR: first copy SRCID
601      sc_signal<bool>     r_config_dir_copy_inst;     // DIR: first copy L1 type
602      sc_signal<size_t>   r_config_dir_ptr;           // DIR: index of next copy in HEAP
603      sc_signal<size_t>   r_config_heap_next;         // current pointer to scan HEAP
604      sc_signal<size_t>   r_config_trt_index;         // selected entry in TRT
605      sc_signal<size_t>   r_config_ivt_index;         // selected entry in IVT
606
607      // Buffer between CONFIG fsm and IXR_CMD fsm
608      sc_signal<bool>     r_config_to_ixr_cmd_req;    // valid request
609      sc_signal<size_t>   r_config_to_ixr_cmd_index;  // TRT index
610
611
612      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
613      sc_signal<bool>     r_config_to_tgt_rsp_req;    // valid request
614      sc_signal<bool>     r_config_to_tgt_rsp_error;  // error response
615      sc_signal<size_t>   r_config_to_tgt_rsp_srcid;  // Transaction srcid
616      sc_signal<size_t>   r_config_to_tgt_rsp_trdid;  // Transaction trdid
617      sc_signal<size_t>   r_config_to_tgt_rsp_pktid;  // Transaction pktid
618
619      // Buffer between CONFIG fsm and CC_SEND fsm (multi-inval / broadcast-inval)
620      sc_signal<bool>     r_config_to_cc_send_multi_req;    // multi-inval request
621      sc_signal<bool>     r_config_to_cc_send_brdcast_req;  // broadcast-inval request
622      sc_signal<addr_t>   r_config_to_cc_send_nline;        // line index
623      sc_signal<size_t>   r_config_to_cc_send_trdid;        // UPT index
624      GenericFifo<bool>   m_config_to_cc_send_inst_fifo;    // fifo for the L1 type
625      GenericFifo<size_t> m_config_to_cc_send_srcid_fifo;   // fifo for owners srcid
626
627      ///////////////////////////////////////////////////////
628      // Registers controlled by the READ fsm
629      ///////////////////////////////////////////////////////
630
631      sc_signal<int>      r_read_fsm;                 // FSM state
632      sc_signal<size_t>   r_read_copy;                // Srcid of the first copy
633      sc_signal<size_t>   r_read_copy_cache;          // Srcid of the first copy
634      sc_signal<bool>     r_read_copy_inst;           // Type of the first copy
635      sc_signal<tag_t>    r_read_tag;                 // cache line tag (in directory)
636      sc_signal<bool>     r_read_is_cnt;              // is_cnt bit (in directory)
637      sc_signal<bool>     r_read_lock;                // lock bit (in directory)
638      sc_signal<bool>     r_read_dirty;               // dirty bit (in directory)
639      sc_signal<size_t>   r_read_count;               // number of copies
640      sc_signal<size_t>   r_read_ptr;                 // pointer to the heap
641      sc_signal<data_t> * r_read_data;                // data (one cache line)
642      sc_signal<size_t>   r_read_way;                 // associative way (in cache)
643      sc_signal<size_t>   r_read_trt_index;           // Transaction Table index
644      sc_signal<size_t>   r_read_next_ptr;            // Next entry to point to
645      sc_signal<bool>     r_read_last_free;           // Last free entry
646      sc_signal<addr_t>   r_read_ll_key;              // LL key from llsc_global_table
647
648      // Buffer between READ fsm and IXR_CMD fsm
649      sc_signal<bool>     r_read_to_ixr_cmd_req;      // valid request
650      sc_signal<size_t>   r_read_to_ixr_cmd_index;    // TRT index
651
652      // Buffer between READ fsm and TGT_RSP fsm (send a hit read response to L1 cache)
653      sc_signal<bool>     r_read_to_tgt_rsp_req;      // valid request
654      sc_signal<size_t>   r_read_to_tgt_rsp_srcid;    // Transaction srcid
655      sc_signal<size_t>   r_read_to_tgt_rsp_trdid;    // Transaction trdid
656      sc_signal<size_t>   r_read_to_tgt_rsp_pktid;    // Transaction pktid
657      sc_signal<data_t> * r_read_to_tgt_rsp_data;     // data (one cache line)
658      sc_signal<size_t>   r_read_to_tgt_rsp_word;     // first word of the response
659      sc_signal<size_t>   r_read_to_tgt_rsp_length;   // length of the response
660      sc_signal<addr_t>   r_read_to_tgt_rsp_ll_key;   // LL key from llsc_global_table
661
662      ///////////////////////////////////////////////////////////////
663      // Registers controlled by the WRITE fsm
664      ///////////////////////////////////////////////////////////////
665
666      sc_signal<int>      r_write_fsm;                // FSM state
667      sc_signal<addr_t>   r_write_address;            // first word address
668      sc_signal<size_t>   r_write_word_index;         // first word index in line
669      sc_signal<size_t>   r_write_word_count;         // number of words in line
670      sc_signal<size_t>   r_write_srcid;              // transaction srcid
671      sc_signal<size_t>   r_write_trdid;              // transaction trdid
672      sc_signal<size_t>   r_write_pktid;              // transaction pktid
673      sc_signal<data_t> * r_write_data;               // data (one cache line)
674      sc_signal<be_t>   * r_write_be;                 // one byte enable per word
675      sc_signal<bool>     r_write_byte;               // (BE != 0X0) and (BE != 0xF)
676      sc_signal<bool>     r_write_is_cnt;             // is_cnt bit (in directory)
677      sc_signal<bool>     r_write_lock;               // lock bit (in directory)
678      sc_signal<tag_t>    r_write_tag;                // cache line tag (in directory)
679      sc_signal<size_t>   r_write_copy;               // first owner of the line
680      sc_signal<size_t>   r_write_copy_cache;         // first owner of the line
681      sc_signal<bool>     r_write_copy_inst;          // is this owner a ICache ?
682      sc_signal<size_t>   r_write_count;              // number of copies
683      sc_signal<size_t>   r_write_ptr;                // pointer to the heap
684      sc_signal<size_t>   r_write_next_ptr;           // next pointer to the heap
685      sc_signal<bool>     r_write_to_dec;             // need to decrement update counter
686      sc_signal<size_t>   r_write_way;                // way of the line
687      sc_signal<size_t>   r_write_trt_index;          // index in Transaction Table
688      sc_signal<size_t>   r_write_upt_index;          // index in Update Table
689      sc_signal<bool>     r_write_sc_fail;            // sc command failed
690      sc_signal<bool>     r_write_pending_sc;         // sc command pending
691
692      // Buffer between WRITE fsm and TGT_RSP fsm (acknowledge a write command from L1)
693      sc_signal<bool>     r_write_to_tgt_rsp_req;     // valid request
694      sc_signal<size_t>   r_write_to_tgt_rsp_srcid;   // transaction srcid
695      sc_signal<size_t>   r_write_to_tgt_rsp_trdid;   // transaction trdid
696      sc_signal<size_t>   r_write_to_tgt_rsp_pktid;   // transaction pktid
697      sc_signal<bool>     r_write_to_tgt_rsp_sc_fail; // sc command failed
698
699      // Buffer between WRITE fsm and IXR_CMD fsm
700      sc_signal<bool>     r_write_to_ixr_cmd_req;     // valid request
701      sc_signal<bool>     r_write_to_ixr_cmd_put;     // request type (GET/PUT)
702      sc_signal<size_t>   r_write_to_ixr_cmd_index;   // TRT index
703
704      // Buffer between WRITE fsm and CC_SEND fsm (Update/Invalidate L1 caches)
705      sc_signal<bool>     r_write_to_cc_send_multi_req;     // valid multicast request
706      sc_signal<bool>     r_write_to_cc_send_brdcast_req;   // valid brdcast request
707      sc_signal<addr_t>   r_write_to_cc_send_nline;         // cache line index
708      sc_signal<size_t>   r_write_to_cc_send_trdid;         // index in Update Table
709      sc_signal<data_t> * r_write_to_cc_send_data;          // data (one cache line)
710      sc_signal<be_t>   * r_write_to_cc_send_be;            // word enable
711      sc_signal<size_t>   r_write_to_cc_send_count;         // number of words in line
712      sc_signal<size_t>   r_write_to_cc_send_index;         // index of first word in line
713      GenericFifo<bool>   m_write_to_cc_send_inst_fifo;     // fifo for the L1 type
714      GenericFifo<size_t> m_write_to_cc_send_srcid_fifo;    // fifo for srcids
715
716      // Buffer between WRITE fsm and MULTI_ACK fsm (Decrement UPT entry)
717      sc_signal<bool>     r_write_to_multi_ack_req;       // valid request
718      sc_signal<size_t>   r_write_to_multi_ack_upt_index; // index in update table
719
720      /////////////////////////////////////////////////////////
721      // Registers controlled by MULTI_ACK fsm
722      //////////////////////////////////////////////////////////
723
724      sc_signal<int>      r_multi_ack_fsm;       // FSM state
725      sc_signal<size_t>   r_multi_ack_upt_index; // index in the Update Table
726      sc_signal<size_t>   r_multi_ack_srcid;     // pending write srcid
727      sc_signal<size_t>   r_multi_ack_trdid;     // pending write trdid
728      sc_signal<size_t>   r_multi_ack_pktid;     // pending write pktid
729      sc_signal<addr_t>   r_multi_ack_nline;     // pending write nline
730
731      // Buffer between MULTI_ACK fsm and TGT_RSP fsm (complete write/update transaction)
732      sc_signal<bool>     r_multi_ack_to_tgt_rsp_req;   // valid request
733      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_srcid; // Transaction srcid
734      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_trdid; // Transaction trdid
735      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_pktid; // Transaction pktid
736
737      ///////////////////////////////////////////////////////
738      // Registers controlled by CLEANUP fsm
739      ///////////////////////////////////////////////////////
740
741      sc_signal<int>      r_cleanup_fsm;           // FSM state
742      sc_signal<size_t>   r_cleanup_srcid;         // transaction srcid
743      sc_signal<bool>     r_cleanup_inst;          // Instruction or Data ?
744      sc_signal<size_t>   r_cleanup_way_index;     // L1 Cache Way index
745      sc_signal<addr_t>   r_cleanup_nline;         // cache line index
746
747
748      sc_signal<copy_t>   r_cleanup_copy;          // first copy
749      sc_signal<copy_t>   r_cleanup_copy_cache;    // first copy
750      sc_signal<size_t>   r_cleanup_copy_inst;     // type of the first copy
751      sc_signal<copy_t>   r_cleanup_count;         // number of copies
752      sc_signal<size_t>   r_cleanup_ptr;           // pointer to the heap
753      sc_signal<size_t>   r_cleanup_prev_ptr;      // previous pointer to the heap
754      sc_signal<size_t>   r_cleanup_prev_srcid;    // srcid of previous heap entry
755      sc_signal<size_t>   r_cleanup_prev_cache_id; // srcid of previous heap entry
756      sc_signal<bool>     r_cleanup_prev_inst;     // inst bit of previous heap entry
757      sc_signal<size_t>   r_cleanup_next_ptr;      // next pointer to the heap
758      sc_signal<tag_t>    r_cleanup_tag;           // cache line tag (in directory)
759      sc_signal<bool>     r_cleanup_is_cnt;        // inst bit (in directory)
760      sc_signal<bool>     r_cleanup_lock;          // lock bit (in directory)
761      sc_signal<bool>     r_cleanup_dirty;         // dirty bit (in directory)
762      sc_signal<size_t>   r_cleanup_way;           // associative way (in cache)
763
764      sc_signal<size_t>   r_cleanup_write_srcid;   // srcid of write rsp
765      sc_signal<size_t>   r_cleanup_write_trdid;   // trdid of write rsp
766      sc_signal<size_t>   r_cleanup_write_pktid;   // pktid of write rsp
767
768      sc_signal<bool>     r_cleanup_need_rsp;      // write response required
769      sc_signal<bool>     r_cleanup_need_ack;      // config acknowledge required
770
771      sc_signal<size_t>   r_cleanup_index;         // index of the INVAL line (in the UPT)
772
773      // Buffer between CLEANUP fsm and TGT_RSP fsm (acknowledge a write command from L1)
774      sc_signal<bool>     r_cleanup_to_tgt_rsp_req;   // valid request
775      sc_signal<size_t>   r_cleanup_to_tgt_rsp_srcid; // transaction srcid
776      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
777      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
778
779      ///////////////////////////////////////////////////////
780      // Registers controlled by CAS fsm
781      ///////////////////////////////////////////////////////
782
783      sc_signal<int>      r_cas_fsm;              // FSM state
784      sc_signal<data_t>   r_cas_wdata;            // write data word
785      sc_signal<data_t> * r_cas_rdata;            // read data word
786      sc_signal<uint32_t> r_cas_lfsr;             // lfsr for random introducing
787      sc_signal<size_t>   r_cas_cpt;              // size of command
788      sc_signal<copy_t>   r_cas_copy;             // Srcid of the first copy
789      sc_signal<copy_t>   r_cas_copy_cache;       // Srcid of the first copy
790      sc_signal<bool>     r_cas_copy_inst;        // Type of the first copy
791      sc_signal<size_t>   r_cas_count;            // number of copies
792      sc_signal<size_t>   r_cas_ptr;              // pointer to the heap
793      sc_signal<size_t>   r_cas_next_ptr;         // next pointer to the heap
794      sc_signal<bool>     r_cas_is_cnt;           // is_cnt bit (in directory)
795      sc_signal<bool>     r_cas_dirty;            // dirty bit (in directory)
796      sc_signal<size_t>   r_cas_way;              // way in directory
797      sc_signal<size_t>   r_cas_set;              // set in directory
798      sc_signal<data_t>   r_cas_tag;              // cache line tag (in directory)
799      sc_signal<size_t>   r_cas_trt_index;        // Transaction Table index
800      sc_signal<size_t>   r_cas_upt_index;        // Update Table index
801      sc_signal<data_t> * r_cas_data;             // cache line data
802
803      // Buffer between CAS fsm and IXR_CMD fsm
804      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
805      sc_signal<bool>     r_cas_to_ixr_cmd_put;   // request type (GET/PUT)
806      sc_signal<size_t>   r_cas_to_ixr_cmd_index; // TRT index
807
808      // Buffer between CAS fsm and TGT_RSP fsm
809      sc_signal<bool>     r_cas_to_tgt_rsp_req;   // valid request
810      sc_signal<data_t>   r_cas_to_tgt_rsp_data;  // read data word
811      sc_signal<size_t>   r_cas_to_tgt_rsp_srcid; // Transaction srcid
812      sc_signal<size_t>   r_cas_to_tgt_rsp_trdid; // Transaction trdid
813      sc_signal<size_t>   r_cas_to_tgt_rsp_pktid; // Transaction pktid
814
815      // Buffer between CAS fsm and CC_SEND fsm (Update/Invalidate L1 caches)
816      sc_signal<bool>     r_cas_to_cc_send_multi_req;     // valid request
817      sc_signal<bool>     r_cas_to_cc_send_brdcast_req;   // brdcast request
818      sc_signal<addr_t>   r_cas_to_cc_send_nline;         // cache line index
819      sc_signal<size_t>   r_cas_to_cc_send_trdid;         // index in Update Table
820      sc_signal<data_t>   r_cas_to_cc_send_wdata;         // data (one word)
821      sc_signal<bool>     r_cas_to_cc_send_is_long;       // it is a 64 bits CAS
822      sc_signal<data_t>   r_cas_to_cc_send_wdata_high;    // data high (one word)
823      sc_signal<size_t>   r_cas_to_cc_send_index;         // index of the word in line
824      GenericFifo<bool>   m_cas_to_cc_send_inst_fifo;     // fifo for the L1 type
825      GenericFifo<size_t> m_cas_to_cc_send_srcid_fifo;    // fifo for srcids
826
827      ////////////////////////////////////////////////////
828      // Registers controlled by the IXR_RSP fsm
829      ////////////////////////////////////////////////////
830
831      sc_signal<int>      r_ixr_rsp_fsm;                // FSM state
832      sc_signal<size_t>   r_ixr_rsp_trt_index;          // TRT entry index
833      sc_signal<size_t>   r_ixr_rsp_cpt;                // word counter
834
835      // Buffer between IXR_RSP fsm and CONFIG fsm  (response from the XRAM)
836      sc_signal<bool>     r_ixr_rsp_to_config_ack;      // one single bit   
837
838      // Buffer between IXR_RSP fsm and XRAM_RSP fsm  (response from the XRAM)
839      sc_signal<bool>   * r_ixr_rsp_to_xram_rsp_rok;    // one bit per TRT entry
840
841      ////////////////////////////////////////////////////
842      // Registers controlled by the XRAM_RSP fsm
843      ////////////////////////////////////////////////////
844
845      sc_signal<int>      r_xram_rsp_fsm;               // FSM state
846      sc_signal<size_t>   r_xram_rsp_trt_index;         // TRT entry index
847      TransactionTabEntry r_xram_rsp_trt_buf;           // TRT entry local buffer
848      sc_signal<bool>     r_xram_rsp_victim_inval;      // victim line invalidate
849      sc_signal<bool>     r_xram_rsp_victim_is_cnt;     // victim line inst bit
850      sc_signal<bool>     r_xram_rsp_victim_dirty;      // victim line dirty bit
851      sc_signal<size_t>   r_xram_rsp_victim_way;        // victim line way
852      sc_signal<size_t>   r_xram_rsp_victim_set;        // victim line set
853      sc_signal<addr_t>   r_xram_rsp_victim_nline;      // victim line index
854      sc_signal<copy_t>   r_xram_rsp_victim_copy;       // victim line first copy
855      sc_signal<copy_t>   r_xram_rsp_victim_copy_cache; // victim line first copy
856      sc_signal<bool>     r_xram_rsp_victim_copy_inst;  // victim line type of first copy
857      sc_signal<size_t>   r_xram_rsp_victim_count;      // victim line number of copies
858      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
859      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
860      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
861      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
862
863      // Buffer between XRAM_RSP fsm and TGT_RSP fsm  (response to L1 cache)
864      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_req;    // Valid request
865      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_srcid;  // Transaction srcid
866      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_trdid;  // Transaction trdid
867      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_pktid;  // Transaction pktid
868      sc_signal<data_t> * r_xram_rsp_to_tgt_rsp_data;   // data (one cache line)
869      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_word;   // first word index
870      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_length; // length of the response
871      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_rerror; // send error to requester
872      sc_signal<addr_t>   r_xram_rsp_to_tgt_rsp_ll_key; // LL key from llsc_global_table
873
874      // Buffer between XRAM_RSP fsm and CC_SEND fsm (Inval L1 Caches)
875      sc_signal<bool>     r_xram_rsp_to_cc_send_multi_req;     // Valid request
876      sc_signal<bool>     r_xram_rsp_to_cc_send_brdcast_req;   // Broadcast request
877      sc_signal<addr_t>   r_xram_rsp_to_cc_send_nline;         // cache line index;
878      sc_signal<size_t>   r_xram_rsp_to_cc_send_trdid;         // index of UPT entry
879      GenericFifo<bool>   m_xram_rsp_to_cc_send_inst_fifo;     // fifo for the L1 type
880      GenericFifo<size_t> m_xram_rsp_to_cc_send_srcid_fifo;    // fifo for srcids
881
882      // Buffer between XRAM_RSP fsm and IXR_CMD fsm
883      sc_signal<bool>     r_xram_rsp_to_ixr_cmd_req;   // Valid request
884      sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_index; // TRT index
885
886      ////////////////////////////////////////////////////
887      // Registers controlled by the IXR_CMD fsm
888      ////////////////////////////////////////////////////
889
890      sc_signal<int>      r_ixr_cmd_fsm;
891      sc_signal<size_t>   r_ixr_cmd_word;              // word index for a put
892      sc_signal<size_t>   r_ixr_cmd_trdid;             // TRT index value     
893      sc_signal<addr_t>   r_ixr_cmd_address;           // address to XRAM
894      sc_signal<data_t> * r_ixr_cmd_wdata;             // cache line buffer
895      sc_signal<bool>     r_ixr_cmd_get;               // transaction type (PUT/GET)
896
897      ////////////////////////////////////////////////////
898      // Registers controlled by TGT_RSP fsm
899      ////////////////////////////////////////////////////
900
901      sc_signal<int>      r_tgt_rsp_fsm;
902      sc_signal<size_t>   r_tgt_rsp_cpt;
903      sc_signal<bool>     r_tgt_rsp_key_sent;
904
905      ////////////////////////////////////////////////////
906      // Registers controlled by CC_SEND fsm
907      ////////////////////////////////////////////////////
908
909      sc_signal<int>      r_cc_send_fsm;
910      sc_signal<size_t>   r_cc_send_cpt;
911      sc_signal<bool>     r_cc_send_inst;
912
913      ////////////////////////////////////////////////////
914      // Registers controlled by CC_RECEIVE fsm
915      ////////////////////////////////////////////////////
916
917      sc_signal<int>      r_cc_receive_fsm;
918
919      ////////////////////////////////////////////////////
920      // Registers controlled by ALLOC_DIR fsm
921      ////////////////////////////////////////////////////
922
923      sc_signal<int>      r_alloc_dir_fsm;
924      sc_signal<unsigned> r_alloc_dir_reset_cpt;
925
926      ////////////////////////////////////////////////////
927      // Registers controlled by ALLOC_TRT fsm
928      ////////////////////////////////////////////////////
929
930      sc_signal<int>      r_alloc_trt_fsm;
931
932      ////////////////////////////////////////////////////
933      // Registers controlled by ALLOC_UPT fsm
934      ////////////////////////////////////////////////////
935
936      sc_signal<int>      r_alloc_upt_fsm;
937
938      ////////////////////////////////////////////////////
939      // Registers controlled by ALLOC_IVT fsm
940      ////////////////////////////////////////////////////
941
942      sc_signal<int>      r_alloc_ivt_fsm;
943
944      ////////////////////////////////////////////////////
945      // Registers controlled by ALLOC_HEAP fsm
946      ////////////////////////////////////////////////////
947
948      sc_signal<int>      r_alloc_heap_fsm;
949      sc_signal<unsigned> r_alloc_heap_reset_cpt;
950    }; // end class VciMemCache
951
952}}
953
954#endif
955
956// Local Variables:
957// tab-width: 2
958// c-basic-offset: 2
959// c-file-offsets:((innamespace . 0)(inline-open . 0))
960// indent-tabs-mode: nil
961// End:
962
963// vim: filetype=cpp:expandtab:shiftwidth=2:tabstop=2:softtabstop=2
964
Note: See TracBrowser for help on using the repository browser.