source: branches/RWT/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h @ 495

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

This version for RWT has merged with the lastest version of classic tsar.
It pass the test with giet_vm.
File size: 50.2 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_READ_NCC_INVAL_HEADER,
135        CC_SEND_READ_NCC_INVAL_NLINE,
136        CC_SEND_WRITE_NCC_INVAL_HEADER,
137        CC_SEND_WRITE_NCC_INVAL_NLINE,
138        CC_SEND_WRITE_BRDCAST_HEADER,
139        CC_SEND_WRITE_BRDCAST_NLINE,
140        CC_SEND_WRITE_UPDT_HEADER,
141        CC_SEND_WRITE_UPDT_NLINE,
142        CC_SEND_WRITE_UPDT_DATA,
143        CC_SEND_CAS_BRDCAST_HEADER,
144        CC_SEND_CAS_BRDCAST_NLINE,
145        CC_SEND_CAS_UPDT_HEADER,
146        CC_SEND_CAS_UPDT_NLINE,
147        CC_SEND_CAS_UPDT_DATA,
148        CC_SEND_CAS_UPDT_DATA_HIGH
149      };
150
151      /* States of the MULTI_ACK fsm */
152      enum multi_ack_fsm_state_e
153      {
154        MULTI_ACK_IDLE,
155        MULTI_ACK_UPT_LOCK,
156        MULTI_ACK_UPT_CLEAR,
157        MULTI_ACK_WRITE_RSP
158      };
159
160      /* States of the CONFIG fsm */
161      enum config_fsm_state_e
162      {
163        CONFIG_IDLE,
164        CONFIG_LOOP,
165        CONFIG_WAIT,
166        CONFIG_RSP,
167        CONFIG_DIR_REQ,
168        CONFIG_DIR_ACCESS,
169        CONFIG_IVT_LOCK,
170        CONFIG_BC_SEND,
171        CONFIG_INVAL_SEND,
172        CONFIG_HEAP_REQ,
173        CONFIG_HEAP_SCAN,
174        CONFIG_HEAP_LAST,
175        CONFIG_TRT_LOCK,
176        CONFIG_TRT_SET,
177        CONFIG_PUT_REQ
178      };
179
180      /* States of the READ fsm */
181      enum read_fsm_state_e
182      {
183        READ_IDLE,
184        READ_DIR_REQ,
185        READ_DIR_LOCK,
186        READ_IVT_LOCK,
187        READ_WAIT,
188        READ_DIR_HIT,
189        READ_HEAP_REQ,
190        READ_HEAP_LOCK,
191        READ_HEAP_WRITE,
192        READ_HEAP_ERASE,
193        READ_HEAP_LAST,
194        READ_RSP,
195        READ_TRT_LOCK,
196        READ_TRT_SET,
197        READ_TRT_REQ
198      };
199
200      /* States of the WRITE fsm */
201      enum write_fsm_state_e
202      {
203        WRITE_IDLE,
204        WRITE_NEXT,
205        WRITE_DIR_REQ,
206        WRITE_DIR_LOCK,
207        WRITE_IVT_LOCK_HIT_WB,
208        WRITE_DIR_HIT,
209        WRITE_UPT_LOCK,
210        WRITE_UPT_HEAP_LOCK,
211        WRITE_UPT_REQ,
212        WRITE_UPT_NEXT,
213        WRITE_UPT_DEC,
214        WRITE_RSP,
215        WRITE_MISS_IVT_LOCK,
216        WRITE_MISS_TRT_LOCK,
217        WRITE_MISS_TRT_DATA,
218        WRITE_MISS_TRT_SET,
219        WRITE_MISS_XRAM_REQ,
220        WRITE_BC_DIR_READ,
221        WRITE_BC_TRT_LOCK,
222        WRITE_BC_IVT_LOCK,
223        WRITE_BC_DIR_INVAL,
224        WRITE_BC_CC_SEND,
225        WRITE_BC_XRAM_REQ,
226        WRITE_WAIT
227      };
228
229      /* States of the IXR_RSP fsm */
230      enum ixr_rsp_fsm_state_e
231      {
232        IXR_RSP_IDLE,
233        IXR_RSP_ACK,
234        IXR_RSP_TRT_ERASE,
235        IXR_RSP_TRT_READ
236      };
237
238      /* States of the XRAM_RSP fsm */
239      enum xram_rsp_fsm_state_e
240      {
241        XRAM_RSP_IDLE,
242        XRAM_RSP_TRT_COPY,
243        XRAM_RSP_TRT_DIRTY,
244        XRAM_RSP_DIR_LOCK,
245        XRAM_RSP_DIR_UPDT,
246        XRAM_RSP_DIR_RSP,
247        XRAM_RSP_IVT_LOCK,
248        XRAM_RSP_INVAL_WAIT,
249        XRAM_RSP_INVAL,
250        XRAM_RSP_WRITE_DIRTY,
251        XRAM_RSP_HEAP_REQ,
252        XRAM_RSP_HEAP_ERASE,
253        XRAM_RSP_HEAP_LAST,
254        XRAM_RSP_ERROR_ERASE,
255        XRAM_RSP_ERROR_RSP
256      };
257
258      /* States of the IXR_CMD fsm */
259      enum ixr_cmd_fsm_state_e
260      {
261        IXR_CMD_READ_IDLE,
262        IXR_CMD_WRITE_IDLE,
263        IXR_CMD_CAS_IDLE,
264        IXR_CMD_XRAM_IDLE,
265        IXR_CMD_CLEANUP_IDLE,
266        IXR_CMD_CONFIG_IDLE,
267        IXR_CMD_READ_TRT,
268        IXR_CMD_WRITE_TRT,
269        IXR_CMD_CAS_TRT,
270        IXR_CMD_XRAM_TRT,
271        IXR_CMD_CLEANUP_TRT,
272        IXR_CMD_CONFIG_TRT,
273        IXR_CMD_READ_SEND,
274        IXR_CMD_WRITE_SEND,
275        IXR_CMD_CAS_SEND,
276        IXR_CMD_XRAM_SEND,
277        IXR_CMD_CLEANUP_DATA_SEND,
278        IXR_CMD_CONFIG_SEND
279      };
280
281      /* States of the CAS fsm */
282      enum cas_fsm_state_e
283      {
284        CAS_IDLE,
285        CAS_DIR_REQ,
286        CAS_DIR_LOCK,
287        CAS_DIR_HIT_READ,
288        CAS_DIR_HIT_COMPARE,
289        CAS_DIR_HIT_WRITE,
290        CAS_UPT_LOCK,
291        CAS_UPT_HEAP_LOCK,
292        CAS_UPT_REQ,
293        CAS_UPT_NEXT,
294        CAS_BC_TRT_LOCK,
295        CAS_BC_IVT_LOCK,
296        CAS_BC_DIR_INVAL,
297        CAS_BC_CC_SEND,
298        CAS_BC_XRAM_REQ,
299        CAS_RSP_FAIL,
300        CAS_RSP_SUCCESS,
301        CAS_MISS_TRT_LOCK,
302        CAS_MISS_TRT_SET,
303        CAS_MISS_XRAM_REQ,
304        CAS_WAIT
305      };
306
307      /* States of the CLEANUP fsm */
308      enum cleanup_fsm_state_e
309      {
310        CLEANUP_IDLE,
311        CLEANUP_GET_NLINE,
312        CLEANUP_GET_DATA,
313        CLEANUP_DIR_REQ,
314        CLEANUP_DIR_LOCK,
315        CLEANUP_DIR_WRITE,
316        CLEANUP_IVT_LOCK_DATA,
317        CLEANUP_IVT_CLEAR_DATA,
318        CLEANUP_READ_RSP,
319        CLEANUP_HEAP_REQ,
320        CLEANUP_HEAP_LOCK,
321        CLEANUP_HEAP_SEARCH,
322        CLEANUP_HEAP_CLEAN,
323        CLEANUP_HEAP_FREE,
324        CLEANUP_IVT_LOCK,
325        CLEANUP_IVT_DECREMENT,
326        CLEANUP_IVT_CLEAR,
327        CLEANUP_WRITE_RSP,
328        CLEANUP_IXR_REQ,
329        CLEANUP_WAIT,
330        CLEANUP_SEND_CLACK
331      };
332
333      /* States of the ALLOC_DIR fsm */
334      enum alloc_dir_fsm_state_e
335      {
336        ALLOC_DIR_RESET,
337        ALLOC_DIR_CONFIG,
338        ALLOC_DIR_READ,
339        ALLOC_DIR_WRITE,
340        ALLOC_DIR_CAS,
341        ALLOC_DIR_CLEANUP,
342        ALLOC_DIR_XRAM_RSP
343      };
344
345      /* States of the ALLOC_TRT fsm */
346      enum alloc_trt_fsm_state_e
347      {
348        ALLOC_TRT_READ,
349        ALLOC_TRT_WRITE,
350        ALLOC_TRT_CAS,
351        ALLOC_TRT_XRAM_RSP,
352        ALLOC_TRT_IXR_RSP,
353        ALLOC_TRT_CLEANUP,
354        ALLOC_TRT_IXR_CMD,
355        ALLOC_TRT_CONFIG
356      };
357
358      /* States of the ALLOC_UPT fsm */
359      enum alloc_upt_fsm_state_e
360      {
361        ALLOC_UPT_WRITE,
362        ALLOC_UPT_CAS,
363        ALLOC_UPT_MULTI_ACK
364      };
365
366      /* States of the ALLOC_IVT fsm */
367      enum alloc_ivt_fsm_state_e
368      {
369        ALLOC_IVT_WRITE,
370        ALLOC_IVT_READ,
371        ALLOC_IVT_XRAM_RSP,
372        ALLOC_IVT_CLEANUP,
373        ALLOC_IVT_CAS,
374        ALLOC_IVT_CONFIG
375      };
376
377      /* States of the ALLOC_HEAP fsm */
378      enum alloc_heap_fsm_state_e
379      {
380        ALLOC_HEAP_RESET,
381        ALLOC_HEAP_READ,
382        ALLOC_HEAP_WRITE,
383        ALLOC_HEAP_CAS,
384        ALLOC_HEAP_CLEANUP,
385        ALLOC_HEAP_XRAM_RSP,
386        ALLOC_HEAP_CONFIG
387      };
388
389      /* transaction type, pktid field */
390      enum transaction_type_e
391      {
392          // b3 unused
393          // b2 READ / NOT READ
394          // Si READ
395          //  b1 DATA / INS
396          //  b0 UNC / MISS
397          // Si NOT READ
398          //  b1 accÚs table llsc type SW / other
399          //  b2 WRITE/CAS/LL/SC
400          TYPE_READ_DATA_UNC          = 0x0,
401          TYPE_READ_DATA_MISS         = 0x1,
402          TYPE_READ_INS_UNC           = 0x2,
403          TYPE_READ_INS_MISS          = 0x3,
404          TYPE_WRITE                  = 0x4,
405          TYPE_CAS                    = 0x5,
406          TYPE_LL                     = 0x6,
407          TYPE_SC                     = 0x7
408      };
409
410      /* SC return values */
411      enum sc_status_type_e
412      {
413          SC_SUCCESS  =   0x00000000,
414          SC_FAIL     =   0x00000001
415      };
416
417      // debug variables
418      bool                 m_debug;
419      bool                 m_debug_previous_valid;
420      size_t               m_debug_previous_count;
421      bool                 m_debug_previous_dirty;
422      data_t *             m_debug_previous_data;
423      data_t *             m_debug_data;
424
425      // instrumentation counters
426      uint32_t     m_cpt_cycles;        // Counter of cycles
427
428      uint32_t     m_cpt_read;          // Number of READ transactions
429      uint32_t     m_cpt_read_remote;   // number of remote READ transactions
430      uint32_t     m_cpt_read_flits;    // number of flits for READs
431      uint32_t     m_cpt_read_cost;     // Number of (flits * distance) for READs
432
433      uint32_t     m_cpt_read_miss;     // Number of MISS READ
434
435      uint32_t     m_cpt_write;         // Number of WRITE transactions
436      uint32_t     m_cpt_write_remote;  // number of remote WRITE transactions
437      uint32_t     m_cpt_write_flits;   // number of flits for WRITEs
438      uint32_t     m_cpt_write_cost;    // Number of (flits * distance) for WRITEs
439
440      uint32_t     m_cpt_write_miss;    // Number of MISS WRITE
441      uint32_t     m_cpt_write_cells;   // Cumulated length for WRITE transactions
442      uint32_t     m_cpt_write_dirty;   // Cumulated length for WRITE transactions
443      uint32_t     m_cpt_update;        // Number of UPDATE transactions
444      uint32_t     m_cpt_trt_rb;        // Read blocked by a hit in trt
445      uint32_t     m_cpt_trt_full;      // Transaction blocked due to a full trt
446      uint32_t     m_cpt_update_mult;   // Number of targets for UPDATE
447      uint32_t     m_cpt_inval;         // Number of INVAL  transactions
448      uint32_t     m_cpt_inval_mult;    // Number of targets for INVAL
449      uint32_t     m_cpt_inval_brdcast; // Number of BROADCAST INVAL
450      uint32_t     m_cpt_cleanup;       // Number of CLEANUP transactions
451      uint32_t     m_cpt_ll;            // Number of LL transactions
452      uint32_t     m_cpt_sc;            // Number of SC transactions
453      uint32_t     m_cpt_cas;           // Number of CAS transactions
454     
455      uint32_t     m_cpt_read_fsm_dir_lock;        // wait DIR LOCK
456      uint32_t     m_cpt_read_fsm_n_dir_lock;      // NB DIR LOCK
457      uint32_t     m_cpt_write_fsm_dir_lock;       // wait DIR LOCK
458      uint32_t     m_cpt_write_fsm_n_dir_lock;     // NB DIR LOCK
459      uint32_t     m_cpt_xram_rsp_fsm_dir_lock;    // wait DIR LOCK
460      uint32_t     m_cpt_xram_rsp_fsm_n_dir_lock;  // NB DIR LOCK
461      uint32_t     m_cpt_cas_fsm_dir_lock;         // wait DIR LOCK
462      uint32_t     m_cpt_cas_fsm_n_dir_lock;       // NB DIR LOCK
463      uint32_t     m_cpt_cleanup_fsm_dir_lock;     // wait DIR LOCK
464      uint32_t     m_cpt_cleanup_fsm_n_dir_lock;   // NB DIR LOCK
465     
466      uint32_t     m_cpt_dir_unused;            // NB cycles DIR LOCK unused
467      uint32_t     m_cpt_read_fsm_dir_used;     // NB cycles DIR LOCK used
468      uint32_t     m_cpt_write_fsm_dir_used;    // NB cycles DIR LOCK used
469      uint32_t     m_cpt_cas_fsm_dir_used;      // NB cycles DIR LOCK used
470      uint32_t     m_cpt_xram_rsp_fsm_dir_used; // NB cycles DIR LOCK used
471      uint32_t     m_cpt_cleanup_fsm_dir_used;  // NB cycles DIR LOCK used
472
473      uint32_t     m_cpt_read_fsm_trt_lock;      // wait TRT LOCK
474      uint32_t     m_cpt_write_fsm_trt_lock;     // wait TRT LOCK
475      uint32_t     m_cpt_cas_fsm_trt_lock;       // wait TRT LOCK
476      uint32_t     m_cpt_xram_rsp_fsm_trt_lock;  // wait TRT LOCK
477      uint32_t     m_cpt_ixr_fsm_trt_lock;       // wait TRT LOCK
478     
479      uint32_t     m_cpt_read_fsm_n_trt_lock;      // NB TRT LOCK
480      uint32_t     m_cpt_write_fsm_n_trt_lock;     // NB TRT LOCK
481      uint32_t     m_cpt_cas_fsm_n_trt_lock;       // NB TRT LOCK
482      uint32_t     m_cpt_xram_rsp_fsm_n_trt_lock;  // NB TRT LOCK
483      uint32_t     m_cpt_ixr_fsm_n_trt_lock;       // NB TRT LOCK
484
485      uint32_t     m_cpt_read_fsm_trt_used;      // NB cycles TRT LOCK used
486      uint32_t     m_cpt_write_fsm_trt_used;     // NB cycles TRT LOCK used
487      uint32_t     m_cpt_cas_fsm_trt_used;       // NB cycles TRT LOCK used
488      uint32_t     m_cpt_xram_rsp_fsm_trt_used;  // NB cycles TRT LOCK used
489      uint32_t     m_cpt_ixr_fsm_trt_used;       // NB cycles TRT LOCK used
490     
491      uint32_t     m_cpt_trt_unused;            // NB cycles TRT LOCK unused
492
493      uint32_t     m_cpt_write_fsm_upt_lock;     // wait UPT LOCK
494      uint32_t     m_cpt_xram_rsp_fsm_upt_lock;  // wait UPT LOCK
495      uint32_t     m_cpt_multi_ack_fsm_upt_lock; // wait UPT LOCK
496      uint32_t     m_cpt_cleanup_fsm_ivt_lock;   // wait UPT LOCK
497      uint32_t     m_cpt_cas_fsm_upt_lock;       // wait UPT LOCK
498     
499      uint32_t     m_cpt_write_fsm_n_upt_lock;     // NB UPT LOCK
500      uint32_t     m_cpt_xram_rsp_fsm_n_upt_lock;  // NB UPT LOCK
501      uint32_t     m_cpt_multi_ack_fsm_n_upt_lock; // NB UPT LOCK
502      uint32_t     m_cpt_cleanup_fsm_n_upt_lock;   // NB UPT LOCK
503      uint32_t     m_cpt_cas_fsm_n_upt_lock;       // NB UPT LOCK
504     
505      uint32_t     m_cpt_write_fsm_upt_used;     // NB cycles UPT LOCK used
506      uint32_t     m_cpt_xram_rsp_fsm_upt_used;  // NB cycles UPT LOCK used
507      uint32_t     m_cpt_multi_ack_fsm_upt_used; // NB cycles UPT LOCK used
508      uint32_t     m_cpt_cleanup_fsm_ivt_used;   // NB cycles UPT LOCK used
509      uint32_t     m_cpt_cas_fsm_upt_used;       // NB cycles UPT LOCK used
510     
511      uint32_t     m_cpt_ivt_unused;            // NB cycles UPT LOCK unused
512      uint32_t     m_cpt_upt_unused;            // NB cycles UPT LOCK unused
513
514      uint32_t     m_cpt_read_fsm_heap_lock;     // wait HEAP LOCK
515      uint32_t     m_cpt_write_fsm_heap_lock;    // wait HEAP LOCK
516      uint32_t     m_cpt_cas_fsm_heap_lock;      // wait HEAP LOCK
517      uint32_t     m_cpt_cleanup_fsm_heap_lock;  // wait HEAP LOCK
518      uint32_t     m_cpt_xram_rsp_fsm_heap_lock; // wait HEAP LOCK
519     
520      uint32_t     m_cpt_read_fsm_n_heap_lock;     // NB HEAP LOCK
521      uint32_t     m_cpt_write_fsm_n_heap_lock;    // NB HEAP LOCK
522      uint32_t     m_cpt_cas_fsm_n_heap_lock;      // NB HEAP LOCK
523      uint32_t     m_cpt_cleanup_fsm_n_heap_lock;  // NB HEAP LOCK
524      uint32_t     m_cpt_xram_rsp_fsm_n_heap_lock; // NB HEAP LOCK
525     
526      uint32_t     m_cpt_read_fsm_heap_used;     // NB cycles HEAP LOCK used
527      uint32_t     m_cpt_write_fsm_heap_used;    // NB cycles HEAP LOCK used
528      uint32_t     m_cpt_cas_fsm_heap_used;      // NB cycles HEAP LOCK used
529      uint32_t     m_cpt_cleanup_fsm_heap_used;  // NB cycles HEAP LOCK used
530      uint32_t     m_cpt_xram_rsp_fsm_heap_used; // NB cycles HEAP LOCK used
531     
532      uint32_t     m_cpt_heap_unused;            // NB cycles HEAP LOCK unused
533
534      //RWT
535      uint32_t     m_cpt_cleanup_data;   
536      uint32_t     m_cpt_ncc_to_cc_read;         // NB change from NCC to CC caused by a READ
537      uint32_t     m_cpt_ncc_to_cc_write;        // NB change from NCC to CC caused by a WRITE
538      uint32_t     m_cpt_ncc_to_cc;              // NB change from NCC to CC
539
540      uint32_t     m_cpt_read_data_unc;
541      uint32_t     m_cpt_read_data_miss_CC;
542      uint32_t     m_cpt_read_ins_unc;
543      uint32_t     m_cpt_read_ins_miss;
544      uint32_t     m_cpt_read_ll_CC;
545      uint32_t     m_cpt_read_data_miss_NCC;
546      uint32_t     m_cpt_read_ll_NCC;
547      uint32_t     m_cpt_read_WTF;
548
549      uint32_t     m_cpt_cleanup_cost;  // Number of (flits * distance) for CLEANUPs
550
551      uint32_t     m_cpt_update_flits;  // Number of flits for UPDATEs
552      uint32_t     m_cpt_update_cost;   // Number of (flits * distance) for UPDATEs
553
554      uint32_t     m_cpt_inval_cost;    // Number of (flits * distance) for INVALs
555
556      uint32_t     m_cpt_get;
557
558      uint32_t     m_cpt_put;
559
560      size_t       m_prev_count;
561
562      protected:
563
564      SC_HAS_PROCESS(VciMemCache);
565
566      public:
567      sc_in<bool>                                 p_clk;
568      sc_in<bool>                                 p_resetn;
569      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
570      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
571      soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
572      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
573      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
574
575      VciMemCache(
576          sc_module_name name,                                // Instance Name
577          const soclib::common::MappingTable &mtp,            // Mapping table INT network
578          const soclib::common::MappingTable &mtx,            // Mapping table RAM network
579          const soclib::common::IntTab       &srcid_x,        // global index RAM network
580          const soclib::common::IntTab       &tgtid_d,        // global index INT network
581          const size_t                       cc_global_id,    // global index CC network
582          const size_t                       nways,           // Number of ways per set
583          const size_t                       nsets,           // Number of sets
584          const size_t                       nwords,          // Number of words per line
585          const size_t                       max_copies,      // max number of copies
586          const size_t                       heap_size=HEAP_ENTRIES,
587          const size_t                       trt_lines=TRT_ENTRIES, 
588          const size_t                       upt_lines=UPT_ENTRIES,     
589          const size_t                       ivt_lines=IVT_ENTRIES,     
590          const size_t                       debug_start_cycle=0,
591          const bool                         debug_ok=false );
592
593      ~VciMemCache();
594
595      void clear_stats();
596      void print_stats();
597      void print_trace();
598      void cache_monitor(addr_t addr);
599      void start_monitor(addr_t addr, addr_t length);
600      void stop_monitor();
601
602      private:
603
604      void transition();
605      void genMoore();
606      void check_monitor(addr_t addr, data_t data, bool read);
607
608      // Component attributes
609      std::list<soclib::common::Segment> m_seglist;          // segments allocated
610      size_t                             m_nseg;             // number of segments
611      soclib::common::Segment            **m_seg;            // array of segments pointers
612      size_t                             m_seg_config;       // config segment index
613      const size_t                       m_srcid_x;          // global index on RAM network
614      const size_t                       m_initiators;       // Number of initiators
615      const size_t                       m_heap_size;        // Size of the heap
616      const size_t                       m_ways;             // Number of ways in a set
617      const size_t                       m_sets;             // Number of cache sets
618      const size_t                       m_words;            // Number of words in a line
619      const size_t                       m_cc_global_id;     // global_index on cc network
620      size_t                             m_debug_start_cycle;
621      bool                               m_debug_ok;
622      uint32_t                           m_trt_lines;
623      TransactionTab                     m_trt;              // xram transaction table
624      uint32_t                           m_upt_lines;
625      UpdateTab                          m_upt;              // pending update
626      UpdateTab                          m_ivt;              // pending invalidate
627      CacheDirectory                     m_cache_directory;  // data cache directory
628      CacheData                          m_cache_data;       // data array[set][way][word]
629      HeapDirectory                      m_heap;             // heap for copies
630      size_t                             m_max_copies;       // max number of copies in heap
631      GenericLLSCGlobalTable
632      < 32  ,    // number of slots
633        4096,    // number of processors in the system
634        8000,    // registration life (# of LL operations)
635        addr_t >                         m_llsc_table;       // ll/sc registration table
636
637      // adress masks
638      const soclib::common::AddressMaskingTable<addr_t>   m_x;
639      const soclib::common::AddressMaskingTable<addr_t>   m_y;
640      const soclib::common::AddressMaskingTable<addr_t>   m_z;
641      const soclib::common::AddressMaskingTable<addr_t>   m_nline;
642
643      // broadcast address
644      uint32_t                           m_broadcast_boundaries;
645
646      // Fifo between TGT_CMD fsm and READ fsm
647      GenericFifo<addr_t>    m_cmd_read_addr_fifo;
648      GenericFifo<size_t>    m_cmd_read_length_fifo;
649      GenericFifo<size_t>    m_cmd_read_srcid_fifo;
650      GenericFifo<size_t>    m_cmd_read_trdid_fifo;
651      GenericFifo<size_t>    m_cmd_read_pktid_fifo;
652
653      // Fifo between TGT_CMD fsm and WRITE fsm
654      GenericFifo<addr_t>    m_cmd_write_addr_fifo;
655      GenericFifo<bool>      m_cmd_write_eop_fifo;
656      GenericFifo<size_t>    m_cmd_write_srcid_fifo;
657      GenericFifo<size_t>    m_cmd_write_trdid_fifo;
658      GenericFifo<size_t>    m_cmd_write_pktid_fifo;
659      GenericFifo<data_t>    m_cmd_write_data_fifo;
660      GenericFifo<be_t>      m_cmd_write_be_fifo;
661
662      // Fifo between TGT_CMD fsm and CAS fsm
663      GenericFifo<addr_t>    m_cmd_cas_addr_fifo;
664      GenericFifo<bool>      m_cmd_cas_eop_fifo;
665      GenericFifo<size_t>    m_cmd_cas_srcid_fifo;
666      GenericFifo<size_t>    m_cmd_cas_trdid_fifo;
667      GenericFifo<size_t>    m_cmd_cas_pktid_fifo;
668      GenericFifo<data_t>    m_cmd_cas_wdata_fifo;
669
670      // Fifo between CC_RECEIVE fsm and CLEANUP fsm
671      GenericFifo<uint64_t>  m_cc_receive_to_cleanup_fifo;
672     
673      // Fifo between CC_RECEIVE fsm and MULTI_ACK fsm
674      GenericFifo<uint64_t>  m_cc_receive_to_multi_ack_fifo;
675
676      // Buffer between TGT_CMD fsm and TGT_RSP fsm
677      // (segmentation violation response request)
678      sc_signal<bool>     r_tgt_cmd_to_tgt_rsp_req;
679
680      sc_signal<uint32_t> r_tgt_cmd_to_tgt_rsp_rdata;
681      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_error;
682      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_srcid;
683      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_trdid;
684      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_pktid;
685
686      sc_signal<addr_t>   r_tgt_cmd_config_addr;
687      sc_signal<size_t>   r_tgt_cmd_config_cmd;
688
689      //////////////////////////////////////////////////
690      // Registers controlled by the TGT_CMD fsm
691      //////////////////////////////////////////////////
692
693      sc_signal<int>         r_tgt_cmd_fsm;
694      sc_signal<size_t>      r_tgt_cmd_srcid;           // srcid for response to config
695      sc_signal<size_t>      r_tgt_cmd_trdid;           // trdid for response to config
696      sc_signal<size_t>      r_tgt_cmd_pktid;           // pktid for response to config
697
698      ///////////////////////////////////////////////////////
699      // Registers controlled by the CONFIG fsm
700      ///////////////////////////////////////////////////////
701
702      sc_signal<int>      r_config_fsm;               // FSM state
703      sc_signal<bool>     r_config_lock;              // lock protecting exclusive access
704      sc_signal<int>      r_config_cmd;               // config request type 
705      sc_signal<addr_t>   r_config_address;           // target buffer physical address
706      sc_signal<size_t>   r_config_srcid;             // config request srcid
707      sc_signal<size_t>   r_config_trdid;             // config request trdid
708      sc_signal<size_t>   r_config_pktid;             // config request pktid
709      sc_signal<size_t>   r_config_cmd_lines;         // number of lines to be handled
710      sc_signal<size_t>   r_config_rsp_lines;         // number of lines not completed
711      sc_signal<size_t>   r_config_dir_way;           // DIR: selected way
712      sc_signal<bool>     r_config_dir_lock;          // DIR: locked entry
713      sc_signal<size_t>   r_config_dir_count;         // DIR: number of copies
714      sc_signal<bool>     r_config_dir_is_cnt;        // DIR: counter mode (broadcast)
715      sc_signal<size_t>   r_config_dir_copy_srcid;    // DIR: first copy SRCID
716      sc_signal<bool>     r_config_dir_copy_inst;     // DIR: first copy L1 type
717      sc_signal<size_t>   r_config_dir_ptr;           // DIR: index of next copy in HEAP
718      sc_signal<size_t>   r_config_heap_next;         // current pointer to scan HEAP
719      sc_signal<size_t>   r_config_trt_index;         // selected entry in TRT
720      sc_signal<size_t>   r_config_ivt_index;         // selected entry in IVT
721
722      // Buffer between CONFIG fsm and IXR_CMD fsm
723      sc_signal<bool>     r_config_to_ixr_cmd_req;    // valid request
724      sc_signal<size_t>   r_config_to_ixr_cmd_index;  // TRT index
725
726
727      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
728      sc_signal<bool>     r_config_to_tgt_rsp_req;    // valid request
729      sc_signal<bool>     r_config_to_tgt_rsp_error;  // error response
730      sc_signal<size_t>   r_config_to_tgt_rsp_srcid;  // Transaction srcid
731      sc_signal<size_t>   r_config_to_tgt_rsp_trdid;  // Transaction trdid
732      sc_signal<size_t>   r_config_to_tgt_rsp_pktid;  // Transaction pktid
733
734      // Buffer between CONFIG fsm and CC_SEND fsm (multi-inval / broadcast-inval)
735      sc_signal<bool>     r_config_to_cc_send_multi_req;    // multi-inval request
736      sc_signal<bool>     r_config_to_cc_send_brdcast_req;  // broadcast-inval request
737      sc_signal<addr_t>   r_config_to_cc_send_nline;        // line index
738      sc_signal<size_t>   r_config_to_cc_send_trdid;        // UPT index
739      GenericFifo<bool>   m_config_to_cc_send_inst_fifo;    // fifo for the L1 type
740      GenericFifo<size_t> m_config_to_cc_send_srcid_fifo;   // fifo for owners srcid
741
742      ///////////////////////////////////////////////////////
743      // Registers controlled by the READ fsm
744      ///////////////////////////////////////////////////////
745
746      sc_signal<int>      r_read_fsm;                 // FSM state
747      sc_signal<size_t>   r_read_copy;                // Srcid of the first copy
748      sc_signal<size_t>   r_read_copy_cache;          // Srcid of the first copy
749      sc_signal<bool>     r_read_copy_inst;           // Type of the first copy
750      sc_signal<tag_t>    r_read_tag;                 // cache line tag (in directory)
751      sc_signal<bool>     r_read_is_cnt;              // is_cnt bit (in directory)
752      sc_signal<bool>     r_read_lock;                // lock bit (in directory)
753      sc_signal<bool>     r_read_dirty;               // dirty bit (in directory)
754      sc_signal<size_t>   r_read_count;               // number of copies
755      sc_signal<size_t>   r_read_ptr;                 // pointer to the heap
756      sc_signal<data_t> * r_read_data;                // data (one cache line)
757      sc_signal<size_t>   r_read_way;                 // associative way (in cache)
758      sc_signal<size_t>   r_read_trt_index;           // Transaction Table index
759      sc_signal<size_t>   r_read_next_ptr;            // Next entry to point to
760      sc_signal<bool>     r_read_last_free;           // Last free entry
761      sc_signal<addr_t>   r_read_ll_key;              // LL key from llsc_global_table
762
763      // Buffer between READ fsm and IXR_CMD fsm
764      sc_signal<bool>     r_read_to_ixr_cmd_req;      // valid request
765      sc_signal<size_t>   r_read_to_ixr_cmd_index;    // TRT index
766
767      // Buffer between READ fsm and TGT_RSP fsm (send a hit read response to L1 cache)
768      sc_signal<bool>     r_read_to_tgt_rsp_req;      // valid request
769      sc_signal<size_t>   r_read_to_tgt_rsp_srcid;    // Transaction srcid
770      sc_signal<size_t>   r_read_to_tgt_rsp_trdid;    // Transaction trdid
771      sc_signal<size_t>   r_read_to_tgt_rsp_pktid;    // Transaction pktid
772      sc_signal<data_t> * r_read_to_tgt_rsp_data;     // data (one cache line)
773      sc_signal<size_t>   r_read_to_tgt_rsp_word;     // first word of the response
774      sc_signal<size_t>   r_read_to_tgt_rsp_length;   // length of the response
775      sc_signal<addr_t>   r_read_to_tgt_rsp_ll_key;   // LL key from llsc_global_table
776
777      //RWT: Buffer between READ fsm and CC_SEND fsm (send inval)
778      sc_signal<bool>     r_read_to_cc_send_req;
779      sc_signal<size_t>   r_read_to_cc_send_dest;
780      sc_signal<addr_t>   r_read_to_cc_send_nline;
781      sc_signal<bool>     r_read_to_cc_send_inst;
782
783      //RWT: Buffer between READ fsm and CLEANUP fsm (wait for the data coming from L1 cache)
784      sc_signal<bool>     r_read_to_cleanup_req;    // valid request
785      sc_signal<addr_t>   r_read_to_cleanup_nline;  // cache line index
786      sc_signal<size_t>   r_read_to_cleanup_srcid;
787      sc_signal<size_t>   r_read_to_cleanup_length;
788      sc_signal<size_t>   r_read_to_cleanup_first_word;
789      sc_signal<bool>     r_read_to_cleanup_cached_read;   
790      sc_signal<bool>     r_read_to_cleanup_is_ll;
791      sc_signal<addr_t>   r_read_to_cleanup_addr;
792      sc_signal<addr_t>   r_read_to_cleanup_ll_key;
793
794      //RWT:
795      sc_signal<bool>     r_read_coherent;          // State of the cache slot after transaction
796      sc_signal<bool>     r_read_ll_done;
797
798      ///////////////////////////////////////////////////////////////
799      // Registers controlled by the WRITE fsm
800      ///////////////////////////////////////////////////////////////
801
802      sc_signal<int>      r_write_fsm;                // FSM state
803      sc_signal<addr_t>   r_write_address;            // first word address
804      sc_signal<size_t>   r_write_word_index;         // first word index in line
805      sc_signal<size_t>   r_write_word_count;         // number of words in line
806      sc_signal<size_t>   r_write_srcid;              // transaction srcid
807      sc_signal<size_t>   r_write_trdid;              // transaction trdid
808      sc_signal<size_t>   r_write_pktid;              // transaction pktid
809      sc_signal<data_t> * r_write_data;               // data (one cache line)
810      sc_signal<be_t>   * r_write_be;                 // one byte enable per word
811      sc_signal<bool>     r_write_byte;               // (BE != 0X0) and (BE != 0xF)
812      sc_signal<bool>     r_write_is_cnt;             // is_cnt bit (in directory)
813      sc_signal<bool>     r_write_lock;               // lock bit (in directory)
814      sc_signal<tag_t>    r_write_tag;                // cache line tag (in directory)
815      sc_signal<size_t>   r_write_copy;               // first owner of the line
816      sc_signal<size_t>   r_write_copy_cache;         // first owner of the line
817      sc_signal<bool>     r_write_copy_inst;          // is this owner a ICache ?
818      sc_signal<size_t>   r_write_count;              // number of copies
819      sc_signal<size_t>   r_write_ptr;                // pointer to the heap
820      sc_signal<size_t>   r_write_next_ptr;           // next pointer to the heap
821      sc_signal<bool>     r_write_to_dec;             // need to decrement update counter
822      sc_signal<size_t>   r_write_way;                // way of the line
823      sc_signal<size_t>   r_write_trt_index;          // index in Transaction Table
824      sc_signal<size_t>   r_write_upt_index;          // index in Update Table
825      sc_signal<bool>     r_write_sc_fail;            // sc command failed
826      sc_signal<bool>     r_write_pending_sc;         // sc command pending
827
828      // Buffer between WRITE fsm and TGT_RSP fsm (acknowledge a write command from L1)
829      sc_signal<bool>     r_write_to_tgt_rsp_req;     // valid request
830      sc_signal<size_t>   r_write_to_tgt_rsp_srcid;   // transaction srcid
831      sc_signal<size_t>   r_write_to_tgt_rsp_trdid;   // transaction trdid
832      sc_signal<size_t>   r_write_to_tgt_rsp_pktid;   // transaction pktid
833      sc_signal<bool>     r_write_to_tgt_rsp_sc_fail; // sc command failed
834
835      // Buffer between WRITE fsm and IXR_CMD fsm
836      sc_signal<bool>     r_write_to_ixr_cmd_req;     // valid request
837      sc_signal<bool>     r_write_to_ixr_cmd_put;     // request type (GET/PUT)
838      sc_signal<size_t>   r_write_to_ixr_cmd_index;   // TRT index
839
840      // Buffer between WRITE fsm and CC_SEND fsm (Update/Invalidate L1 caches)
841      sc_signal<bool>     r_write_to_cc_send_multi_req;     // valid multicast request
842      sc_signal<bool>     r_write_to_cc_send_brdcast_req;   // valid brdcast request
843      sc_signal<addr_t>   r_write_to_cc_send_nline;         // cache line index
844      sc_signal<size_t>   r_write_to_cc_send_trdid;         // index in Update Table
845      sc_signal<data_t> * r_write_to_cc_send_data;          // data (one cache line)
846      sc_signal<be_t>   * r_write_to_cc_send_be;            // word enable
847      sc_signal<size_t>   r_write_to_cc_send_count;         // number of words in line
848      sc_signal<size_t>   r_write_to_cc_send_index;         // index of first word in line
849      GenericFifo<bool>   m_write_to_cc_send_inst_fifo;     // fifo for the L1 type
850      GenericFifo<size_t> m_write_to_cc_send_srcid_fifo;    // fifo for srcids
851
852      // Buffer between WRITE fsm and MULTI_ACK fsm (Decrement UPT entry)
853      sc_signal<bool>     r_write_to_multi_ack_req;       // valid request
854      sc_signal<size_t>   r_write_to_multi_ack_upt_index; // index in update table
855
856      // RWT: Buffer between WRITE fsm and CLEANUP fsm (change slot state)
857      sc_signal<bool>     r_write_to_cleanup_req;         // valid request
858      sc_signal<addr_t>   r_write_to_cleanup_nline;       // cache line index
859
860      // RWT
861      sc_signal<bool>     r_write_coherent;               // cache slot state after transaction
862
863      //Buffer between WRITE fsm and CC_SEND fsm (INVAL for RWT)
864      sc_signal<bool>     r_write_to_cc_send_req;
865      sc_signal<size_t>   r_write_to_cc_send_dest;
866
867
868      /////////////////////////////////////////////////////////
869      // Registers controlled by MULTI_ACK fsm
870      //////////////////////////////////////////////////////////
871
872      sc_signal<int>      r_multi_ack_fsm;       // FSM state
873      sc_signal<size_t>   r_multi_ack_upt_index; // index in the Update Table
874      sc_signal<size_t>   r_multi_ack_srcid;     // pending write srcid
875      sc_signal<size_t>   r_multi_ack_trdid;     // pending write trdid
876      sc_signal<size_t>   r_multi_ack_pktid;     // pending write pktid
877      sc_signal<addr_t>   r_multi_ack_nline;     // pending write nline
878
879      // Buffer between MULTI_ACK fsm and TGT_RSP fsm (complete write/update transaction)
880      sc_signal<bool>     r_multi_ack_to_tgt_rsp_req;   // valid request
881      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_srcid; // Transaction srcid
882      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_trdid; // Transaction trdid
883      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_pktid; // Transaction pktid
884
885      ///////////////////////////////////////////////////////
886      // Registers controlled by CLEANUP fsm
887      ///////////////////////////////////////////////////////
888
889      sc_signal<int>      r_cleanup_fsm;           // FSM state
890      sc_signal<size_t>   r_cleanup_srcid;         // transaction srcid
891      sc_signal<bool>     r_cleanup_inst;          // Instruction or Data ?
892      sc_signal<size_t>   r_cleanup_way_index;     // L1 Cache Way index
893      sc_signal<addr_t>   r_cleanup_nline;         // cache line index
894
895
896      sc_signal<copy_t>   r_cleanup_copy;          // first copy
897      sc_signal<copy_t>   r_cleanup_copy_cache;    // first copy
898      sc_signal<size_t>   r_cleanup_copy_inst;     // type of the first copy
899      sc_signal<copy_t>   r_cleanup_count;         // number of copies
900      sc_signal<size_t>   r_cleanup_ptr;           // pointer to the heap
901      sc_signal<size_t>   r_cleanup_prev_ptr;      // previous pointer to the heap
902      sc_signal<size_t>   r_cleanup_prev_srcid;    // srcid of previous heap entry
903      sc_signal<size_t>   r_cleanup_prev_cache_id; // srcid of previous heap entry
904      sc_signal<bool>     r_cleanup_prev_inst;     // inst bit of previous heap entry
905      sc_signal<size_t>   r_cleanup_next_ptr;      // next pointer to the heap
906      sc_signal<tag_t>    r_cleanup_tag;           // cache line tag (in directory)
907      sc_signal<bool>     r_cleanup_is_cnt;        // inst bit (in directory)
908      sc_signal<bool>     r_cleanup_lock;          // lock bit (in directory)
909      sc_signal<bool>     r_cleanup_dirty;         // dirty bit (in directory)
910      sc_signal<size_t>   r_cleanup_way;           // associative way (in cache)
911
912      sc_signal<size_t>   r_cleanup_write_srcid;   // srcid of write rsp
913      sc_signal<size_t>   r_cleanup_write_trdid;   // trdid of write rsp
914      sc_signal<size_t>   r_cleanup_write_pktid;   // pktid of write rsp
915
916      sc_signal<bool>     r_cleanup_need_rsp;      // write response required
917      sc_signal<bool>     r_cleanup_need_ack;      // config acknowledge required
918
919      sc_signal<size_t>   r_cleanup_index;         // index of the INVAL line (in the UPT)
920
921      // Buffer between CLEANUP fsm and TGT_RSP fsm (acknowledge a write command from L1)
922      sc_signal<bool>     r_cleanup_to_tgt_rsp_req;   // valid request
923      sc_signal<size_t>   r_cleanup_to_tgt_rsp_srcid; // transaction srcid
924      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
925      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
926      sc_signal<addr_t>     r_cleanup_to_tgt_rsp_ll_key;
927
928      //RWT
929      sc_signal<size_t>   r_cleanup_read_srcid;
930      sc_signal<size_t>   r_cleanup_read_trdid;
931      sc_signal<size_t>   r_cleanup_read_pktid;
932      sc_signal<bool>     r_cleanup_read_need_rsp;
933      sc_signal<bool>     r_cleanup_to_tgt_rsp_type;
934      sc_signal<data_t> * r_cleanup_to_tgt_rsp_data;
935      sc_signal<size_t>   r_cleanup_to_tgt_rsp_length;
936      sc_signal<size_t>   r_cleanup_to_tgt_rsp_first_word;
937
938      ///////////////////////////////////////////////////////
939      // Registers controlled by CAS fsm
940      ///////////////////////////////////////////////////////
941
942      sc_signal<int>      r_cas_fsm;              // FSM state
943      sc_signal<data_t>   r_cas_wdata;            // write data word
944      sc_signal<data_t> * r_cas_rdata;            // read data word
945      sc_signal<uint32_t> r_cas_lfsr;             // lfsr for random introducing
946      sc_signal<size_t>   r_cas_cpt;              // size of command
947      sc_signal<copy_t>   r_cas_copy;             // Srcid of the first copy
948      sc_signal<copy_t>   r_cas_copy_cache;       // Srcid of the first copy
949      sc_signal<bool>     r_cas_copy_inst;        // Type of the first copy
950      sc_signal<size_t>   r_cas_count;            // number of copies
951      sc_signal<size_t>   r_cas_ptr;              // pointer to the heap
952      sc_signal<size_t>   r_cas_next_ptr;         // next pointer to the heap
953      sc_signal<bool>     r_cas_is_cnt;           // is_cnt bit (in directory)
954      sc_signal<bool>     r_cas_dirty;            // dirty bit (in directory)
955      sc_signal<size_t>   r_cas_way;              // way in directory
956      sc_signal<size_t>   r_cas_set;              // set in directory
957      sc_signal<data_t>   r_cas_tag;              // cache line tag (in directory)
958      sc_signal<size_t>   r_cas_trt_index;        // Transaction Table index
959      sc_signal<size_t>   r_cas_upt_index;        // Update Table index
960      sc_signal<data_t> * r_cas_data;             // cache line data
961
962      sc_signal<bool>     r_cas_coherent;
963
964      // Buffer between CAS fsm and IXR_CMD fsm (XRAM write)
965      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
966      sc_signal<bool>     r_cas_to_ixr_cmd_put;   // request type (GET/PUT)
967      sc_signal<size_t>   r_cas_to_ixr_cmd_index; // TRT index
968
969      // Buffer between CAS fsm and TGT_RSP fsm
970      sc_signal<bool>     r_cas_to_tgt_rsp_req;   // valid request
971      sc_signal<data_t>   r_cas_to_tgt_rsp_data;  // read data word
972      sc_signal<size_t>   r_cas_to_tgt_rsp_srcid; // Transaction srcid
973      sc_signal<size_t>   r_cas_to_tgt_rsp_trdid; // Transaction trdid
974      sc_signal<size_t>   r_cas_to_tgt_rsp_pktid; // Transaction pktid
975
976      // Buffer between CAS fsm and CC_SEND fsm (Update/Invalidate L1 caches)
977      sc_signal<bool>     r_cas_to_cc_send_multi_req;     // valid request
978      sc_signal<bool>     r_cas_to_cc_send_brdcast_req;   // brdcast request
979      sc_signal<addr_t>   r_cas_to_cc_send_nline;         // cache line index
980      sc_signal<size_t>   r_cas_to_cc_send_trdid;         // index in Update Table
981      sc_signal<data_t>   r_cas_to_cc_send_wdata;         // data (one word)
982      sc_signal<bool>     r_cas_to_cc_send_is_long;       // it is a 64 bits CAS
983      sc_signal<data_t>   r_cas_to_cc_send_wdata_high;    // data high (one word)
984      sc_signal<size_t>   r_cas_to_cc_send_index;         // index of the word in line
985      GenericFifo<bool>   m_cas_to_cc_send_inst_fifo;     // fifo for the L1 type
986      GenericFifo<size_t> m_cas_to_cc_send_srcid_fifo;    // fifo for srcids
987
988      ////////////////////////////////////////////////////
989      // Registers controlled by the IXR_RSP fsm
990      ////////////////////////////////////////////////////
991
992      sc_signal<int>      r_ixr_rsp_fsm;                // FSM state
993      sc_signal<size_t>   r_ixr_rsp_trt_index;          // TRT entry index
994      sc_signal<size_t>   r_ixr_rsp_cpt;                // word counter
995
996      // Buffer between IXR_RSP fsm and CONFIG fsm  (response from the XRAM)
997      sc_signal<bool>     r_ixr_rsp_to_config_ack;      // one single bit   
998
999      // Buffer between IXR_RSP fsm and XRAM_RSP fsm  (response from the XRAM)
1000      sc_signal<bool>   * r_ixr_rsp_to_xram_rsp_rok;    // one bit per TRT entry
1001
1002      ////////////////////////////////////////////////////
1003      // Registers controlled by the XRAM_RSP fsm
1004      ////////////////////////////////////////////////////
1005
1006      sc_signal<int>      r_xram_rsp_fsm;               // FSM state
1007      sc_signal<size_t>   r_xram_rsp_trt_index;         // TRT entry index
1008      TransactionTabEntry r_xram_rsp_trt_buf;           // TRT entry local buffer
1009      sc_signal<bool>     r_xram_rsp_victim_inval;      // victim line invalidate
1010      sc_signal<bool>     r_xram_rsp_victim_is_cnt;     // victim line inst bit
1011      sc_signal<bool>     r_xram_rsp_victim_dirty;      // victim line dirty bit
1012      sc_signal<size_t>   r_xram_rsp_victim_way;        // victim line way
1013      sc_signal<size_t>   r_xram_rsp_victim_set;        // victim line set
1014      sc_signal<addr_t>   r_xram_rsp_victim_nline;      // victim line index
1015      sc_signal<copy_t>   r_xram_rsp_victim_copy;       // victim line first copy
1016      sc_signal<copy_t>   r_xram_rsp_victim_copy_cache; // victim line first copy
1017      sc_signal<bool>     r_xram_rsp_victim_copy_inst;  // victim line type of first copy
1018      sc_signal<size_t>   r_xram_rsp_victim_count;      // victim line number of copies
1019      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
1020      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
1021      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
1022      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
1023
1024      // Buffer between XRAM_RSP fsm and TGT_RSP fsm  (response to L1 cache)
1025      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_req;    // Valid request
1026      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_srcid;  // Transaction srcid
1027      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_trdid;  // Transaction trdid
1028      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_pktid;  // Transaction pktid
1029      sc_signal<data_t> * r_xram_rsp_to_tgt_rsp_data;   // data (one cache line)
1030      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_word;   // first word index
1031      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_length; // length of the response
1032      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_rerror; // send error to requester
1033      sc_signal<addr_t>   r_xram_rsp_to_tgt_rsp_ll_key; // LL key from llsc_global_table
1034
1035      // Buffer between XRAM_RSP fsm and CC_SEND fsm (Inval L1 Caches)
1036      sc_signal<bool>     r_xram_rsp_to_cc_send_multi_req;     // Valid request
1037      sc_signal<bool>     r_xram_rsp_to_cc_send_brdcast_req;   // Broadcast request
1038      sc_signal<addr_t>   r_xram_rsp_to_cc_send_nline;         // cache line index;
1039      sc_signal<size_t>   r_xram_rsp_to_cc_send_trdid;         // index of UPT entry
1040      GenericFifo<bool>   m_xram_rsp_to_cc_send_inst_fifo;     // fifo for the L1 type
1041      GenericFifo<size_t> m_xram_rsp_to_cc_send_srcid_fifo;    // fifo for srcids
1042
1043      // Buffer between XRAM_RSP fsm and IXR_CMD fsm
1044      sc_signal<bool>     r_xram_rsp_to_ixr_cmd_req;   // Valid request
1045      sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_index; // TRT index
1046
1047      //RWT
1048      sc_signal<bool>     r_xram_rsp_victim_coherent;      // victim's cache slot state
1049      sc_signal<bool>     r_xram_rsp_coherent;             // coherence of the read
1050      ////////////////////////////////////////////////////
1051      // Registers controlled by the IXR_CMD fsm
1052      ////////////////////////////////////////////////////
1053
1054      sc_signal<int>      r_ixr_cmd_fsm;
1055      sc_signal<size_t>   r_ixr_cmd_word;              // word index for a put
1056      sc_signal<size_t>   r_ixr_cmd_trdid;             // TRT index value     
1057      sc_signal<addr_t>   r_ixr_cmd_address;           // address to XRAM
1058      sc_signal<data_t> * r_ixr_cmd_wdata;             // cache line buffer
1059      sc_signal<bool>     r_ixr_cmd_get;               // transaction type (PUT/GET)
1060
1061      ////////////////////////////////////////////////////
1062      // Registers controlled by TGT_RSP fsm
1063      ////////////////////////////////////////////////////
1064
1065      sc_signal<int>      r_tgt_rsp_fsm;
1066      sc_signal<size_t>   r_tgt_rsp_cpt;
1067      sc_signal<bool>     r_tgt_rsp_key_sent;
1068
1069      ////////////////////////////////////////////////////
1070      // Registers controlled by CC_SEND fsm
1071      ////////////////////////////////////////////////////
1072
1073      sc_signal<int>      r_cc_send_fsm;
1074      sc_signal<size_t>   r_cc_send_cpt;
1075      sc_signal<bool>     r_cc_send_inst;
1076
1077      ////////////////////////////////////////////////////
1078      // Registers controlled by CC_RECEIVE fsm
1079      ////////////////////////////////////////////////////
1080
1081      sc_signal<int>      r_cc_receive_fsm;
1082
1083      ////////////////////////////////////////////////////
1084      // Registers controlled by ALLOC_DIR fsm
1085      ////////////////////////////////////////////////////
1086
1087      sc_signal<int>      r_alloc_dir_fsm;
1088      sc_signal<unsigned> r_alloc_dir_reset_cpt;
1089
1090      ////////////////////////////////////////////////////
1091      // Registers controlled by ALLOC_TRT fsm
1092      ////////////////////////////////////////////////////
1093
1094      sc_signal<int>      r_alloc_trt_fsm;
1095
1096      ////////////////////////////////////////////////////
1097      // Registers controlled by ALLOC_UPT fsm
1098      ////////////////////////////////////////////////////
1099
1100      sc_signal<int>      r_alloc_upt_fsm;
1101
1102      ////////////////////////////////////////////////////
1103      // Registers controlled by ALLOC_IVT fsm
1104      ////////////////////////////////////////////////////
1105
1106      sc_signal<int>      r_alloc_ivt_fsm;
1107
1108      ////////////////////////////////////////////////////
1109      // Registers controlled by ALLOC_HEAP fsm
1110      ////////////////////////////////////////////////////
1111
1112      sc_signal<int>      r_alloc_heap_fsm;
1113      sc_signal<unsigned> r_alloc_heap_reset_cpt;
1114
1115
1116      ////////////////////////////////////////////////////
1117      // REGISTERS FOR ODCCP
1118      ////////////////////////////////////////////////////
1119
1120      sc_signal<uint32_t>  r_cleanup_data_index;
1121      sc_signal<uint32_t>  r_cleanup_trdid;
1122      sc_signal<uint32_t>  r_cleanup_pktid;
1123      sc_signal<bool>      r_cleanup_coherent;
1124      sc_signal<data_t>    *r_cleanup_data;
1125      sc_signal<data_t>    *r_cleanup_old_data;
1126      sc_signal<bool>      r_cleanup_contains_data;
1127     
1128      sc_signal<bool>      r_cleanup_ncc;
1129      sc_signal<bool>      r_cleanup_to_ixr_cmd_ncc_l1_dirty;
1130      sc_signal<bool>      r_xram_rsp_to_ixr_cmd_inval_ncc_pending;
1131     
1132      sc_signal<bool>      r_cleanup_to_ixr_cmd_req;
1133      sc_signal<data_t>    *r_cleanup_to_ixr_cmd_data;
1134      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_srcid;
1135      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_index;
1136      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_pktid;
1137      sc_signal<addr_t>    r_cleanup_to_ixr_cmd_nline;
1138    }; // end class VciMemCache
1139
1140}}
1141
1142#endif
1143
1144// Local Variables:
1145// tab-width: 2
1146// c-basic-offset: 2
1147// c-file-offsets:((innamespace . 0)(inline-open . 0))
1148// indent-tabs-mode: nil
1149// End:
1150
1151// vim: filetype=cpp:expandtab:shiftwidth=2:tabstop=2:softtabstop=2
1152
Note: See TracBrowser for help on using the repository browser.