source: branches/ODCCP/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h @ 460

Last change on this file since 460 was 460, checked in by devigne, 11 years ago

Introducing merged components between the last trunk TSAR version
and the ODCCP modifications

File size: 46.8 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 eric.guthmuller@polytechnique.edu
28 *              cesar.fuguet-tortolero@lip6.fr
29 *              alexandre.joannou@lip6.fr
30 */
31
32#ifndef SOCLIB_CABA_MEM_CACHE_H
33#define SOCLIB_CABA_MEM_CACHE_H
34
35#include <inttypes.h>
36#include <systemc>
37#include <list>
38#include <cassert>
39#include "arithmetics.h"
40#include "alloc_elems.h"
41#include "caba_base_module.h"
42#include "vci_target.h"
43#include "vci_initiator.h"
44#include "generic_fifo.h"
45#include "mapping_table.h"
46#include "int_tab.h"
47#include "generic_llsc_global_table.h"
48#include "mem_cache_directory.h"
49#include "xram_transaction.h"
50#include "update_tab.h"
51#include "dspin_interface.h"
52#include "dspin_dhccp_param.h"
53
54#define TRT_ENTRIES      4      // Number of entries in TRT
55#define UPT_ENTRIES      4      // Number of entries in UPT
56#define HEAP_ENTRIES     1024   // Number of entries in HEAP
57
58namespace soclib {  namespace caba {
59
60  using namespace sc_core;
61
62  template<typename vci_param_int, 
63           typename vci_param_ext,
64           size_t   dspin_in_width,
65           size_t   dspin_out_width>
66    class VciMemCache
67    : public soclib::caba::BaseModule
68    {
69      typedef typename vci_param_int::fast_addr_t  addr_t;
70      typedef typename sc_dt::sc_uint<64>          wide_data_t;
71      typedef uint32_t                             data_t;
72      typedef uint32_t                             tag_t;
73      typedef uint32_t                             be_t;
74      typedef uint32_t                             copy_t;
75
76      /* States of the TGT_CMD fsm */
77      enum tgt_cmd_fsm_state_e
78      {
79        TGT_CMD_IDLE,
80        TGT_CMD_ERROR,
81        TGT_CMD_READ,
82        TGT_CMD_WRITE,
83        TGT_CMD_CAS,
84        TGT_CMD_CONFIG
85      };
86
87      /* States of the TGT_RSP fsm */
88      enum tgt_rsp_fsm_state_e
89      {
90        TGT_RSP_CONFIG_IDLE,
91        TGT_RSP_TGT_CMD_IDLE,
92        TGT_RSP_READ_IDLE,
93        TGT_RSP_WRITE_IDLE,
94        TGT_RSP_CAS_IDLE,
95        TGT_RSP_XRAM_IDLE,
96        TGT_RSP_MULTI_ACK_IDLE,
97        TGT_RSP_CLEANUP_IDLE,
98        TGT_RSP_CONFIG,
99        TGT_RSP_TGT_CMD,
100        TGT_RSP_READ,
101        TGT_RSP_WRITE,
102        TGT_RSP_CAS,
103        TGT_RSP_XRAM,
104        TGT_RSP_MULTI_ACK,
105        TGT_RSP_CLEANUP
106      };
107
108      /* States of the DSPIN_TGT fsm */
109      enum cc_receive_fsm_state_e
110      {
111        CC_RECEIVE_IDLE,
112        CC_RECEIVE_CLEANUP,
113        CC_RECEIVE_CLEANUP_EOP,
114        CC_RECEIVE_MULTI_ACK
115      };
116
117      /* States of the CC_SEND fsm */
118      enum cc_send_fsm_state_e
119      {
120        CC_SEND_CONFIG_IDLE,
121        CC_SEND_XRAM_RSP_IDLE,
122        CC_SEND_WRITE_IDLE,
123        CC_SEND_CAS_IDLE,
124        CC_SEND_CLEANUP_IDLE,
125        CC_SEND_CONFIG_INVAL_HEADER,
126        CC_SEND_CONFIG_INVAL_NLINE,
127        CC_SEND_CONFIG_BRDCAST_HEADER,
128        CC_SEND_CONFIG_BRDCAST_NLINE,
129        CC_SEND_CLEANUP_ACK,
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        MULTI_ACK_CONFIG_ACK
155      };
156
157      /* States of the CONFIG fsm */
158      enum config_fsm_state_e
159      {
160        CONFIG_IDLE,
161        CONFIG_LOOP,
162        CONFIG_RSP,
163        CONFIG_DIR_REQ,
164        CONFIG_DIR_ACCESS,
165        CONFIG_DIR_UPT_LOCK,
166        CONFIG_BC_SEND,
167        CONFIG_BC_WAIT,
168        CONFIG_INV_SEND,
169        CONFIG_HEAP_REQ,
170        CONFIG_HEAP_SCAN,
171        CONFIG_HEAP_LAST,
172        CONFIG_INV_WAIT
173      };
174
175      /* States of the READ fsm */
176      enum read_fsm_state_e
177      {
178        READ_IDLE,
179        READ_DIR_REQ,
180        READ_DIR_LOCK,
181        READ_DIR_HIT,
182        READ_HEAP_REQ,
183        READ_HEAP_LOCK,
184        READ_HEAP_WRITE,
185        READ_HEAP_ERASE,
186        READ_HEAP_LAST,
187        READ_RSP,
188        READ_TRT_LOCK,
189        READ_TRT_SET,
190        READ_TRT_REQ
191      };
192
193      /* States of the WRITE fsm */
194      enum write_fsm_state_e
195      {
196        WRITE_IDLE,
197        WRITE_NEXT,
198        WRITE_DIR_REQ,
199        WRITE_DIR_LOCK,
200        WRITE_DIR_READ,
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_TRT_LOCK,
213        WRITE_BC_UPT_LOCK,
214        WRITE_BC_DIR_INVAL,
215        WRITE_BC_CC_SEND,
216        WRITE_BC_XRAM_REQ,
217        WRITE_WAIT
218      };
219
220      /* States of the IXR_RSP fsm */
221      enum ixr_rsp_fsm_state_e
222      {
223        IXR_RSP_IDLE,
224        IXR_RSP_ACK,
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_INVAL_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_CLEANUP_IDLE,
257        IXR_CMD_READ,
258        IXR_CMD_WRITE,
259        IXR_CMD_CAS,
260        IXR_CMD_XRAM,
261        IXR_CMD_CLEANUP_DATA
262      };
263
264      /* States of the CAS fsm */
265      enum cas_fsm_state_e
266      {
267        CAS_IDLE,
268        CAS_DIR_REQ,
269        CAS_DIR_LOCK,
270        CAS_DIR_HIT_READ,
271        CAS_DIR_HIT_COMPARE,
272        CAS_DIR_HIT_WRITE,
273        CAS_UPT_LOCK,
274        CAS_UPT_HEAP_LOCK,
275        CAS_UPT_REQ,
276        CAS_UPT_NEXT,
277        CAS_BC_TRT_LOCK,
278        CAS_BC_UPT_LOCK,
279        CAS_BC_DIR_INVAL,
280        CAS_BC_CC_SEND,
281        CAS_BC_XRAM_REQ,
282        CAS_RSP_FAIL,
283        CAS_RSP_SUCCESS,
284        CAS_MISS_TRT_LOCK,
285        CAS_MISS_TRT_SET,
286        CAS_MISS_XRAM_REQ,
287        CAS_WAIT
288      };
289
290      /* States of the CLEANUP fsm */
291      enum cleanup_fsm_state_e
292      {
293        CLEANUP_IDLE,
294        CLEANUP_GET_NLINE,
295        CLEANUP_GET_DATA,
296        CLEANUP_DIR_REQ,
297        CLEANUP_DIR_LOCK,
298        CLEANUP_DIR_WRITE,
299        CLEANUP_HEAP_REQ,
300        CLEANUP_HEAP_LOCK,
301        CLEANUP_HEAP_SEARCH,
302        CLEANUP_HEAP_CLEAN,
303        CLEANUP_HEAP_FREE,
304        CLEANUP_UPT_LOCK,
305        CLEANUP_UPT_DECREMENT,
306        CLEANUP_UPT_CLEAR,
307        CLEANUP_WRITE_RSP,
308        CLEANUP_CONFIG_ACK,
309        CLEANUP_IXR_REQ,
310        CLEANUP_WAIT,
311        CLEANUP_SEND_CLACK
312      };
313
314      /* States of the ALLOC_DIR fsm */
315      enum alloc_dir_fsm_state_e
316      {
317        ALLOC_DIR_RESET,
318        ALLOC_DIR_CONFIG,
319        ALLOC_DIR_READ,
320        ALLOC_DIR_WRITE,
321        ALLOC_DIR_CAS,
322        ALLOC_DIR_CLEANUP,
323        ALLOC_DIR_XRAM_RSP
324      };
325
326      /* States of the ALLOC_TRT fsm */
327      enum alloc_trt_fsm_state_e
328      {
329        ALLOC_TRT_READ,
330        ALLOC_TRT_WRITE,
331        ALLOC_TRT_CAS,
332        ALLOC_TRT_XRAM_RSP,
333        ALLOC_TRT_IXR_RSP,
334        ALLOC_TRT_CLEANUP
335      };
336
337      /* States of the ALLOC_UPT fsm */
338      enum alloc_upt_fsm_state_e
339      {
340        ALLOC_UPT_CONFIG,
341        ALLOC_UPT_WRITE,
342        ALLOC_UPT_XRAM_RSP,
343        ALLOC_UPT_MULTI_ACK,
344        ALLOC_UPT_CLEANUP,
345        ALLOC_UPT_CAS
346      };
347
348      /* States of the ALLOC_HEAP fsm */
349      enum alloc_heap_fsm_state_e
350      {
351        ALLOC_HEAP_RESET,
352        ALLOC_HEAP_READ,
353        ALLOC_HEAP_WRITE,
354        ALLOC_HEAP_CAS,
355        ALLOC_HEAP_CLEANUP,
356        ALLOC_HEAP_XRAM_RSP,
357        ALLOC_HEAP_CONFIG
358      };
359
360      /* transaction type, pktid field */
361      enum transaction_type_e
362      {
363          // b3 unused
364          // b2 READ / NOT READ
365          // Si READ
366          //  b1 DATA / INS
367          //  b0 UNC / MISS
368          // Si NOT READ
369          //  b1 accÚs table llsc type SW / other
370          //  b2 WRITE/CAS/LL/SC
371          TYPE_READ_DATA_UNC          = 0x0,
372          TYPE_READ_DATA_MISS         = 0x1,
373          TYPE_READ_INS_UNC           = 0x2,
374          TYPE_READ_INS_MISS          = 0x3,
375          TYPE_WRITE                  = 0x4,
376          TYPE_CAS                    = 0x5,
377          TYPE_LL                     = 0x6,
378          TYPE_SC                     = 0x7
379      };
380
381      /* SC return values */
382      enum sc_status_type_e
383      {
384          SC_SUCCESS  =   0x00000000,
385          SC_FAIL     =   0x00000001
386      };
387
388      /* Configuration commands */
389      enum cmd_config_type_e
390      {
391          CMD_CONFIG_INVAL = 0,
392          CMD_CONFIG_SYNC  = 1
393      };
394
395      // debug variables (for each FSM)
396      bool                 m_debug;
397      bool                 m_debug_previous_valid;
398      size_t               m_debug_previous_count;
399      bool                 m_debug_previous_dirty;
400      sc_signal<data_t>*   m_debug_previous_data;
401      sc_signal<data_t>*   m_debug_data;
402
403      bool         m_monitor_ok;
404      addr_t       m_monitor_base;
405      addr_t       m_monitor_length;
406
407      // instrumentation counters
408      uint32_t     m_cpt_cycles;        // Counter of cycles
409
410      uint32_t     m_cpt_read;          // Number of READ transactions
411      uint32_t     m_cpt_read_remote;   // number of remote READ transactions
412      uint32_t     m_cpt_read_flits;    // number of flits for READs
413      uint32_t     m_cpt_read_cost;     // Number of (flits * distance) for READs
414
415      uint32_t     m_cpt_read_miss;     // Number of MISS READ
416
417      uint32_t     m_cpt_write;         // Number of WRITE transactions
418      uint32_t     m_cpt_write_remote;  // number of remote WRITE transactions
419      uint32_t     m_cpt_write_flits;   // number of flits for WRITEs
420      uint32_t     m_cpt_write_cost;    // Number of (flits * distance) for WRITEs
421
422      uint32_t     m_cpt_write_miss;    // Number of MISS WRITE
423      uint32_t     m_cpt_write_cells;   // Cumulated length for WRITE transactions
424      uint32_t     m_cpt_write_dirty;   // Cumulated length for WRITE transactions
425      uint32_t     m_cpt_update;        // Number of UPDATE transactions
426      uint32_t     m_cpt_trt_rb;        // Read blocked by a hit in trt
427      uint32_t     m_cpt_trt_full;      // Transaction blocked due to a full trt
428      uint32_t     m_cpt_update_mult;   // Number of targets for UPDATE
429      uint32_t     m_cpt_inval;         // Number of INVAL  transactions
430      uint32_t     m_cpt_inval_mult;    // Number of targets for INVAL
431      uint32_t     m_cpt_inval_brdcast; // Number of BROADCAST INVAL
432      uint32_t     m_cpt_cleanup;       // Number of CLEANUP transactions
433      uint32_t     m_cpt_cleanup_data;  // Number of CLEANUP WITH DATA transactions
434      uint32_t     m_cpt_ll;            // Number of LL transactions
435      uint32_t     m_cpt_sc;            // Number of SC transactions
436      uint32_t     m_cpt_cas;           // Number of CAS transactions
437     
438      uint32_t     m_cpt_read_fsm_dir_lock;        // wait DIR LOCK
439      uint32_t     m_cpt_read_fsm_n_dir_lock;      // NB DIR LOCK
440      uint32_t     m_cpt_write_fsm_dir_lock;       // wait DIR LOCK
441      uint32_t     m_cpt_write_fsm_n_dir_lock;     // NB DIR LOCK
442      uint32_t     m_cpt_xram_rsp_fsm_dir_lock;    // wait DIR LOCK
443      uint32_t     m_cpt_xram_rsp_fsm_n_dir_lock;  // NB DIR LOCK
444      uint32_t     m_cpt_cas_fsm_dir_lock;         // wait DIR LOCK
445      uint32_t     m_cpt_cas_fsm_n_dir_lock;       // NB DIR LOCK
446      uint32_t     m_cpt_cleanup_fsm_dir_lock;     // wait DIR LOCK
447      uint32_t     m_cpt_cleanup_fsm_n_dir_lock;   // NB DIR LOCK
448     
449      uint32_t     m_cpt_dir_unused;            // NB cycles DIR LOCK unused
450      uint32_t     m_cpt_read_fsm_dir_used;     // NB cycles DIR LOCK used
451      uint32_t     m_cpt_write_fsm_dir_used;    // NB cycles DIR LOCK used
452      uint32_t     m_cpt_cas_fsm_dir_used;      // NB cycles DIR LOCK used
453      uint32_t     m_cpt_xram_rsp_fsm_dir_used; // NB cycles DIR LOCK used
454      uint32_t     m_cpt_cleanup_fsm_dir_used;  // NB cycles DIR LOCK used
455
456      uint32_t     m_cpt_read_fsm_trt_lock;      // wait TRT LOCK
457      uint32_t     m_cpt_write_fsm_trt_lock;     // wait TRT LOCK
458      uint32_t     m_cpt_cas_fsm_trt_lock;       // wait TRT LOCK
459      uint32_t     m_cpt_xram_rsp_fsm_trt_lock;  // wait TRT LOCK
460      uint32_t     m_cpt_ixr_fsm_trt_lock;       // wait TRT LOCK
461     
462      uint32_t     m_cpt_read_fsm_n_trt_lock;      // NB TRT LOCK
463      uint32_t     m_cpt_write_fsm_n_trt_lock;     // NB TRT LOCK
464      uint32_t     m_cpt_cas_fsm_n_trt_lock;       // NB TRT LOCK
465      uint32_t     m_cpt_xram_rsp_fsm_n_trt_lock;  // NB TRT LOCK
466      uint32_t     m_cpt_ixr_fsm_n_trt_lock;       // NB TRT LOCK
467
468      uint32_t     m_cpt_read_fsm_trt_used;      // NB cycles TRT LOCK used
469      uint32_t     m_cpt_write_fsm_trt_used;     // NB cycles TRT LOCK used
470      uint32_t     m_cpt_cas_fsm_trt_used;       // NB cycles TRT LOCK used
471      uint32_t     m_cpt_xram_rsp_fsm_trt_used;  // NB cycles TRT LOCK used
472      uint32_t     m_cpt_ixr_fsm_trt_used;       // NB cycles TRT LOCK used
473     
474      uint32_t     m_cpt_trt_unused;            // NB cycles TRT LOCK unused
475
476      uint32_t     m_cpt_write_fsm_upt_lock;     // wait UPT LOCK
477      uint32_t     m_cpt_xram_rsp_fsm_upt_lock;  // wait UPT LOCK
478      uint32_t     m_cpt_multi_ack_fsm_upt_lock; // wait UPT LOCK
479      uint32_t     m_cpt_cleanup_fsm_upt_lock;   // wait UPT LOCK
480      uint32_t     m_cpt_cas_fsm_upt_lock;       // wait UPT LOCK
481     
482      uint32_t     m_cpt_write_fsm_n_upt_lock;     // NB UPT LOCK
483      uint32_t     m_cpt_xram_rsp_fsm_n_upt_lock;  // NB UPT LOCK
484      uint32_t     m_cpt_multi_ack_fsm_n_upt_lock; // NB UPT LOCK
485      uint32_t     m_cpt_cleanup_fsm_n_upt_lock;   // NB UPT LOCK
486      uint32_t     m_cpt_cas_fsm_n_upt_lock;       // NB UPT LOCK
487     
488      uint32_t     m_cpt_write_fsm_upt_used;     // NB cycles UPT LOCK used
489      uint32_t     m_cpt_xram_rsp_fsm_upt_used;  // NB cycles UPT LOCK used
490      uint32_t     m_cpt_multi_ack_fsm_upt_used; // NB cycles UPT LOCK used
491      uint32_t     m_cpt_cleanup_fsm_upt_used;   // NB cycles UPT LOCK used
492      uint32_t     m_cpt_cas_fsm_upt_used;       // NB cycles UPT LOCK used
493     
494      uint32_t     m_cpt_upt_unused;            // NB cycles UPT LOCK unused
495
496      uint32_t     m_cpt_read_fsm_heap_lock;     // wait HEAP LOCK
497      uint32_t     m_cpt_write_fsm_heap_lock;    // wait HEAP LOCK
498      uint32_t     m_cpt_cas_fsm_heap_lock;      // wait HEAP LOCK
499      uint32_t     m_cpt_cleanup_fsm_heap_lock;  // wait HEAP LOCK
500      uint32_t     m_cpt_xram_rsp_fsm_heap_lock; // wait HEAP LOCK
501     
502      uint32_t     m_cpt_read_fsm_n_heap_lock;     // NB HEAP LOCK
503      uint32_t     m_cpt_write_fsm_n_heap_lock;    // NB HEAP LOCK
504      uint32_t     m_cpt_cas_fsm_n_heap_lock;      // NB HEAP LOCK
505      uint32_t     m_cpt_cleanup_fsm_n_heap_lock;  // NB HEAP LOCK
506      uint32_t     m_cpt_xram_rsp_fsm_n_heap_lock; // NB HEAP LOCK
507     
508      uint32_t     m_cpt_read_fsm_heap_used;     // NB cycles HEAP LOCK used
509      uint32_t     m_cpt_write_fsm_heap_used;    // NB cycles HEAP LOCK used
510      uint32_t     m_cpt_cas_fsm_heap_used;      // NB cycles HEAP LOCK used
511      uint32_t     m_cpt_cleanup_fsm_heap_used;  // NB cycles HEAP LOCK used
512      uint32_t     m_cpt_xram_rsp_fsm_heap_used; // NB cycles HEAP LOCK used
513     
514      uint32_t     m_cpt_heap_unused;            // NB cycles HEAP LOCK unused
515
516      uint32_t     m_cpt_cleanup_cost;  // Number of (flits * distance) for CLEANUPs
517
518      uint32_t     m_cpt_update_flits;  // Number of flits for UPDATEs
519      uint32_t     m_cpt_update_cost;   // Number of (flits * distance) for UPDATEs
520
521      uint32_t     m_cpt_inval_cost;    // Number of (flits * distance) for INVALs
522
523      uint32_t     m_cpt_get;
524
525      uint32_t     m_cpt_put;
526
527      size_t       m_prev_count;
528
529      protected:
530
531      SC_HAS_PROCESS(VciMemCache);
532
533      public:
534      sc_in<bool>                                 p_clk;
535      sc_in<bool>                                 p_resetn;
536      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
537      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
538      soclib::caba::DspinInput<dspin_in_width>    p_dspin_in;
539      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_out;
540
541      VciMemCache(
542          sc_module_name name,                                // Instance Name
543          const soclib::common::MappingTable &mtp,            // Mapping table INT network
544          const soclib::common::MappingTable &mtx,            // Mapping table RAM network
545          const soclib::common::IntTab       &srcid_x,        // global index RAM network
546          const soclib::common::IntTab       &tgtid_d,        // global index INT network
547          const size_t                       cc_global_id,    // global index CC network
548          const size_t                       nways,           // Number of ways per set
549          const size_t                       nsets,           // Number of sets
550          const size_t                       nwords,          // Number of words per line
551          const size_t                       max_copies,      // max number of copies
552          const size_t                       heap_size=HEAP_ENTRIES,
553          const size_t                       trt_lines=TRT_ENTRIES, 
554          const size_t                       upt_lines=UPT_ENTRIES,     
555          const size_t                       debug_start_cycle=0,
556          const bool                         debug_ok=false );
557
558      ~VciMemCache();
559
560      void clear_stats();
561      void print_stats();
562      void print_trace();
563      void cache_monitor(addr_t addr);
564      void start_monitor(addr_t addr, addr_t length);
565      void stop_monitor();
566
567      private:
568
569      void transition();
570      void genMoore();
571      void check_monitor(addr_t addr, data_t data, bool read);
572
573      // Component attributes
574      std::list<soclib::common::Segment> m_seglist;          // segments allocated
575      size_t                             m_nseg;             // number of segments
576      soclib::common::Segment            **m_seg;            // array of segments pointers
577      size_t                             m_seg_config;       // config segment index
578      const size_t                       m_srcid_x;          // global index on RAM network
579      const size_t                       m_initiators;       // Number of initiators
580      const size_t                       m_heap_size;        // Size of the heap
581      const size_t                       m_ways;             // Number of ways in a set
582      const size_t                       m_sets;             // Number of cache sets
583      const size_t                       m_words;            // Number of words in a line
584      const size_t                       m_cc_global_id;     // global_index on cc network
585      size_t                             m_debug_start_cycle;
586      bool                               m_debug_ok;
587      uint32_t                           m_trt_lines;
588      TransactionTab                     m_trt;              // xram transaction table
589      uint32_t                           m_upt_lines;
590      UpdateTab                          m_upt;              // pending update & invalidate
591      CacheDirectory                     m_cache_directory;  // data cache directory
592      CacheData                          m_cache_data;       // data array[set][way][word]
593      HeapDirectory                      m_heap;             // heap for copies
594      size_t                             m_max_copies;       // max number of copies in heap
595      GenericLLSCGlobalTable
596      < 32  ,    // number of slots
597        4096,    // number of processors in the system
598        8000,    // registration life (# of LL operations)
599        addr_t >                         m_llsc_table;       // ll/sc registration table
600
601      // adress masks
602      const soclib::common::AddressMaskingTable<addr_t>   m_x;
603      const soclib::common::AddressMaskingTable<addr_t>   m_y;
604      const soclib::common::AddressMaskingTable<addr_t>   m_z;
605      const soclib::common::AddressMaskingTable<addr_t>   m_nline;
606
607      // broadcast address
608      uint32_t                           m_broadcast_boundaries;
609
610      //////////////////////////////////////////////////
611      // Registers controlled by the TGT_CMD fsm
612      //////////////////////////////////////////////////
613
614      sc_signal<int>         r_tgt_cmd_fsm;
615
616      // Fifo between TGT_CMD fsm and READ fsm
617      GenericFifo<addr_t>    m_cmd_read_addr_fifo;
618      GenericFifo<size_t>    m_cmd_read_length_fifo;
619      GenericFifo<size_t>    m_cmd_read_srcid_fifo;
620      GenericFifo<size_t>    m_cmd_read_trdid_fifo;
621      GenericFifo<size_t>    m_cmd_read_pktid_fifo;
622
623      // Fifo between TGT_CMD fsm and WRITE fsm
624      GenericFifo<addr_t>    m_cmd_write_addr_fifo;
625      GenericFifo<bool>      m_cmd_write_eop_fifo;
626      GenericFifo<size_t>    m_cmd_write_srcid_fifo;
627      GenericFifo<size_t>    m_cmd_write_trdid_fifo;
628      GenericFifo<size_t>    m_cmd_write_pktid_fifo;
629      GenericFifo<data_t>    m_cmd_write_data_fifo;
630      GenericFifo<be_t>      m_cmd_write_be_fifo;
631
632      // Fifo between TGT_CMD fsm and CAS fsm
633      GenericFifo<addr_t>    m_cmd_cas_addr_fifo;
634      GenericFifo<bool>      m_cmd_cas_eop_fifo;
635      GenericFifo<size_t>    m_cmd_cas_srcid_fifo;
636      GenericFifo<size_t>    m_cmd_cas_trdid_fifo;
637      GenericFifo<size_t>    m_cmd_cas_pktid_fifo;
638      GenericFifo<data_t>    m_cmd_cas_wdata_fifo;
639
640      // Fifo between CC_RECEIVE fsm and CLEANUP fsm
641      GenericFifo<uint64_t>  m_cc_receive_to_cleanup_fifo;
642     
643      // Fifo between CC_RECEIVE fsm and MULTI_ACK fsm
644      GenericFifo<uint64_t>  m_cc_receive_to_multi_ack_fifo;
645
646      // Buffer between TGT_CMD fsm and TGT_RSP fsm
647      // (segmentation violation response request)
648      sc_signal<bool>     r_tgt_cmd_to_tgt_rsp_req;
649
650      sc_signal<uint32_t> r_tgt_cmd_to_tgt_rsp_rdata;
651      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_error;
652      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_srcid;
653      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_trdid;
654      sc_signal<size_t>   r_tgt_cmd_to_tgt_rsp_pktid;
655
656      sc_signal<addr_t>   r_tgt_cmd_config_addr;
657      sc_signal<size_t>   r_tgt_cmd_config_cmd;
658
659      ///////////////////////////////////////////////////////
660      // Registers controlled by the CONFIG fsm
661      ///////////////////////////////////////////////////////
662
663      sc_signal<int>      r_config_fsm;            // FSM state
664      sc_signal<bool>     r_config_lock;           // lock protecting exclusive access
665      sc_signal<int>      r_config_cmd;            // config request status
666      sc_signal<addr_t>   r_config_address;        // target buffer physical address
667      sc_signal<size_t>   r_config_srcid;          // config request srcid
668      sc_signal<size_t>   r_config_trdid;          // config request trdid
669      sc_signal<size_t>   r_config_pktid;          // config request pktid
670      sc_signal<size_t>   r_config_nlines;         // number of lines covering the buffer
671      sc_signal<size_t>   r_config_dir_way;        // DIR: selected way
672      sc_signal<size_t>   r_config_dir_count;      // DIR: number of copies
673      sc_signal<bool>     r_config_dir_is_cnt;     // DIR: counter mode (broadcast required)
674      sc_signal<size_t>   r_config_dir_copy_srcid; // DIR: first copy SRCID
675      sc_signal<bool>     r_config_dir_copy_inst;  // DIR: first copy L1 type
676      sc_signal<size_t>   r_config_dir_next_ptr;   // DIR: index of next copy in HEAP
677      sc_signal<size_t>   r_config_heap_next;      // current pointer to scan HEAP
678
679      sc_signal<size_t>   r_config_upt_index;  // UPT index
680
681      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
682      sc_signal<bool>     r_config_to_tgt_rsp_req;    // valid request
683      sc_signal<bool>     r_config_to_tgt_rsp_error;  // error response
684      sc_signal<size_t>   r_config_to_tgt_rsp_srcid;  // Transaction srcid
685      sc_signal<size_t>   r_config_to_tgt_rsp_trdid;  // Transaction trdid
686      sc_signal<size_t>   r_config_to_tgt_rsp_pktid;  // Transaction pktid
687
688      // Buffer between CONFIG fsm and CC_SEND fsm (multi-inval / broadcast-inval)
689      sc_signal<bool>     r_config_to_cc_send_multi_req;    // multi-inval request
690      sc_signal<bool>     r_config_to_cc_send_brdcast_req;  // broadcast-inval request
691      sc_signal<addr_t>   r_config_to_cc_send_nline;        // line index
692      sc_signal<size_t>   r_config_to_cc_send_trdid;        // UPT index
693      GenericFifo<bool>   m_config_to_cc_send_inst_fifo;    // fifo for the L1 type
694      GenericFifo<size_t> m_config_to_cc_send_srcid_fifo;   // fifo for owners srcid
695
696#if L1_MULTI_CACHE
697      GenericFifo<size_t> m_config_to_cc_send_cache_id_fifo; // fifo for cache_id
698#endif
699
700      ///////////////////////////////////////////////////////
701      // Registers controlled by the READ fsm
702      ///////////////////////////////////////////////////////
703
704      sc_signal<int>      r_read_fsm;          // FSM state
705      sc_signal<size_t>   r_read_copy;         // Srcid of the first copy
706      sc_signal<size_t>   r_read_copy_cache;   // Srcid of the first copy
707      sc_signal<bool>     r_read_copy_inst;    // Type of the first copy
708      sc_signal<tag_t>    r_read_tag;          // cache line tag (in directory)
709      sc_signal<bool>     r_read_is_cnt;       // is_cnt bit (in directory)
710      sc_signal<bool>     r_read_lock;         // lock bit (in directory)
711      sc_signal<bool>     r_read_dirty;        // dirty bit (in directory)
712      sc_signal<size_t>   r_read_count;        // number of copies
713      sc_signal<size_t>   r_read_ptr;          // pointer to the heap
714      sc_signal<data_t> * r_read_data;         // data (one cache line)
715      sc_signal<size_t>   r_read_way;          // associative way (in cache)
716      sc_signal<size_t>   r_read_trt_index;    // Transaction Table index
717      sc_signal<size_t>   r_read_next_ptr;     // Next entry to point to
718      sc_signal<bool>     r_read_last_free;    // Last free entry
719      sc_signal<addr_t>   r_read_ll_key;       // LL key from the llsc_global_table
720
721      // Buffer between READ fsm and IXR_CMD fsm (ask a missing cache line to XRAM)
722      sc_signal<bool>     r_read_to_ixr_cmd_req;    // valid request
723      sc_signal<addr_t>   r_read_to_ixr_cmd_nline;  // cache line index
724      sc_signal<size_t>   r_read_to_ixr_cmd_trdid;  // index in Transaction Table
725
726      // Buffer between READ fsm and TGT_RSP fsm (send a hit read response to L1 cache)
727      sc_signal<bool>     r_read_to_tgt_rsp_req;    // valid request
728      sc_signal<size_t>   r_read_to_tgt_rsp_srcid;  // Transaction srcid
729      sc_signal<size_t>   r_read_to_tgt_rsp_trdid;  // Transaction trdid
730      sc_signal<size_t>   r_read_to_tgt_rsp_pktid;  // Transaction pktid
731      sc_signal<data_t> * r_read_to_tgt_rsp_data;   // data (one cache line)
732      sc_signal<size_t>   r_read_to_tgt_rsp_word;   // first word of the response
733      sc_signal<size_t>   r_read_to_tgt_rsp_length; // length of the response
734      sc_signal<addr_t>   r_read_to_tgt_rsp_ll_key; // LL key from the llsc_global_table
735
736      ///////////////////////////////////////////////////////////////
737      // Registers controlled by the WRITE fsm
738      ///////////////////////////////////////////////////////////////
739
740      sc_signal<int>      r_write_fsm;        // FSM state
741      sc_signal<addr_t>   r_write_address;    // first word address
742      sc_signal<size_t>   r_write_word_index; // first word index in line
743      sc_signal<size_t>   r_write_word_count; // number of words in line
744      sc_signal<size_t>   r_write_srcid;      // transaction srcid
745      sc_signal<size_t>   r_write_trdid;      // transaction trdid
746      sc_signal<size_t>   r_write_pktid;      // transaction pktid
747      sc_signal<data_t> * r_write_data;       // data (one cache line)
748      sc_signal<be_t>   * r_write_be;         // one byte enable per word
749      sc_signal<bool>     r_write_byte;       // (BE != 0X0) and (BE != 0xF)
750      sc_signal<bool>     r_write_is_cnt;     // is_cnt bit (in directory)
751      sc_signal<bool>     r_write_lock;       // lock bit (in directory)
752      sc_signal<tag_t>    r_write_tag;        // cache line tag (in directory)
753      sc_signal<size_t>   r_write_copy;       // first owner of the line
754      sc_signal<size_t>   r_write_copy_cache; // first owner of the line
755      sc_signal<bool>     r_write_copy_inst;  // is this owner a ICache ?
756      sc_signal<size_t>   r_write_count;      // number of copies
757      sc_signal<size_t>   r_write_ptr;        // pointer to the heap
758      sc_signal<size_t>   r_write_next_ptr;   // next pointer to the heap
759      sc_signal<bool>     r_write_to_dec;     // need to decrement update counter
760      sc_signal<size_t>   r_write_way;        // way of the line
761      sc_signal<size_t>   r_write_trt_index;  // index in Transaction Table
762      sc_signal<size_t>   r_write_upt_index;  // index in Update Table
763      sc_signal<bool>     r_write_sc_fail;    // sc command failed
764      sc_signal<bool>     r_write_pending_sc; // sc command pending
765
766      // Buffer between WRITE fsm and TGT_RSP fsm (acknowledge a write command from L1)
767      sc_signal<bool>     r_write_to_tgt_rsp_req;     // valid request
768      sc_signal<size_t>   r_write_to_tgt_rsp_srcid;   // transaction srcid
769      sc_signal<size_t>   r_write_to_tgt_rsp_trdid;   // transaction trdid
770      sc_signal<size_t>   r_write_to_tgt_rsp_pktid;   // transaction pktid
771      sc_signal<bool>     r_write_to_tgt_rsp_sc_fail; // sc command failed
772
773      // Buffer between WRITE fsm and IXR_CMD fsm (ask a missing cache line to XRAM)
774      sc_signal<bool>     r_write_to_ixr_cmd_req;   // valid request
775      sc_signal<bool>     r_write_to_ixr_cmd_write; // write request
776      sc_signal<addr_t>   r_write_to_ixr_cmd_nline; // cache line index
777      sc_signal<data_t> * r_write_to_ixr_cmd_data;  // cache line data
778      sc_signal<size_t>   r_write_to_ixr_cmd_trdid; // index in Transaction Table
779
780      // Buffer between WRITE fsm and CC_SEND fsm (Update/Invalidate L1 caches)
781      sc_signal<bool>     r_write_to_cc_send_multi_req;     // valid multicast request
782      sc_signal<bool>     r_write_to_cc_send_brdcast_req;   // valid brdcast request
783      sc_signal<addr_t>   r_write_to_cc_send_nline;         // cache line index
784      sc_signal<size_t>   r_write_to_cc_send_trdid;         // index in Update Table
785      sc_signal<data_t> * r_write_to_cc_send_data;          // data (one cache line)
786      sc_signal<be_t>   * r_write_to_cc_send_be;            // word enable
787      sc_signal<size_t>   r_write_to_cc_send_count;         // number of words in line
788      sc_signal<size_t>   r_write_to_cc_send_index;         // index of first word in line
789      GenericFifo<bool>   m_write_to_cc_send_inst_fifo;     // fifo for the L1 type
790      GenericFifo<size_t> m_write_to_cc_send_srcid_fifo;    // fifo for srcids
791
792#if L1_MULTI_CACHE
793      GenericFifo<size_t> m_write_to_cc_send_cache_id_fifo; // fifo for srcids
794#endif
795
796      // Buffer between WRITE fsm and MULTI_ACK fsm (Decrement UPT entry)
797      sc_signal<bool>     r_write_to_multi_ack_req;       // valid request
798      sc_signal<size_t>   r_write_to_multi_ack_upt_index; // index in update table
799
800      /////////////////////////////////////////////////////////
801      // Registers controlled by MULTI_ACK fsm
802      //////////////////////////////////////////////////////////
803
804      sc_signal<int>      r_multi_ack_fsm;       // FSM state
805      sc_signal<size_t>   r_multi_ack_upt_index; // index in the Update Table
806      sc_signal<size_t>   r_multi_ack_srcid;     // pending write srcid
807      sc_signal<size_t>   r_multi_ack_trdid;     // pending write trdid
808      sc_signal<size_t>   r_multi_ack_pktid;     // pending write pktid
809      sc_signal<addr_t>   r_multi_ack_nline;     // pending write nline
810
811      // signaling completion of multi-inval to CONFIG fsm
812      sc_signal<bool>     r_multi_ack_to_config_ack; 
813
814      // Buffer between MULTI_ACK fsm and TGT_RSP fsm (complete write/update transaction)
815      sc_signal<bool>     r_multi_ack_to_tgt_rsp_req;   // valid request
816      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_srcid; // Transaction srcid
817      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_trdid; // Transaction trdid
818      sc_signal<size_t>   r_multi_ack_to_tgt_rsp_pktid; // Transaction pktid
819
820      ///////////////////////////////////////////////////////
821      // Registers controlled by CLEANUP fsm
822      ///////////////////////////////////////////////////////
823
824      sc_signal<int>      r_cleanup_fsm;           // FSM state
825      sc_signal<size_t>   r_cleanup_srcid;         // transaction srcid
826      sc_signal<bool>     r_cleanup_inst;          // Instruction or Data ?
827      sc_signal<size_t>   r_cleanup_way_index;     // L1 Cache Way index
828      sc_signal<addr_t>   r_cleanup_nline;         // cache line index
829
830#if L1_MULTI_CACHE
831      sc_signal<size_t>   r_cleanup_pktid;         // transaction pktid
832#endif
833
834      sc_signal<copy_t>   r_cleanup_copy;          // first copy
835      sc_signal<copy_t>   r_cleanup_copy_cache;    // first copy
836      sc_signal<size_t>   r_cleanup_copy_inst;     // type of the first copy
837      sc_signal<copy_t>   r_cleanup_count;         // number of copies
838      sc_signal<size_t>   r_cleanup_ptr;           // pointer to the heap
839      sc_signal<size_t>   r_cleanup_prev_ptr;      // previous pointer to the heap
840      sc_signal<size_t>   r_cleanup_prev_srcid;    // srcid of previous heap entry
841      sc_signal<size_t>   r_cleanup_prev_cache_id; // srcid of previous heap entry
842      sc_signal<bool>     r_cleanup_prev_inst;     // inst bit of previous heap entry
843      sc_signal<size_t>   r_cleanup_next_ptr;      // next pointer to the heap
844      sc_signal<tag_t>    r_cleanup_tag;           // cache line tag (in directory)
845      sc_signal<bool>     r_cleanup_is_cnt;        // inst bit (in directory)
846      sc_signal<bool>     r_cleanup_lock;          // lock bit (in directory)
847      sc_signal<bool>     r_cleanup_dirty;         // dirty bit (in directory)
848      sc_signal<size_t>   r_cleanup_way;           // associative way (in cache)
849
850      sc_signal<size_t>   r_cleanup_write_srcid;   // srcid of write rsp
851      sc_signal<size_t>   r_cleanup_write_trdid;   // trdid of write rsp
852      sc_signal<size_t>   r_cleanup_write_pktid;   // pktid of write rsp
853
854      sc_signal<bool>     r_cleanup_need_rsp;      // write response required
855      sc_signal<bool>     r_cleanup_need_ack;      // config acknowledge required
856
857      sc_signal<size_t>   r_cleanup_index;         // index of the INVAL line (in the UPT)
858
859      // signaling completion of broadcast-inval to CONFIG fsm
860      sc_signal<bool>     r_cleanup_to_config_ack; 
861       
862      // Buffer between CLEANUP fsm and TGT_RSP fsm (acknowledge a write command from L1)
863      sc_signal<bool>     r_cleanup_to_tgt_rsp_req;   // valid request
864      sc_signal<size_t>   r_cleanup_to_tgt_rsp_srcid; // transaction srcid
865      sc_signal<size_t>   r_cleanup_to_tgt_rsp_trdid; // transaction trdid
866      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
867
868      // Buffer between CLEANUP fsm and CC_SEND fsm (acknowledge a cleanup command from L1)
869      sc_signal<bool>     r_cleanup_to_cc_send_req;       // valid request
870      sc_signal<size_t>   r_cleanup_to_cc_send_srcid;     // L1 srcid
871      sc_signal<size_t>   r_cleanup_to_cc_send_set_index; // L1 set index
872      sc_signal<size_t>   r_cleanup_to_cc_send_way_index; // L1 way index
873      sc_signal<bool>     r_cleanup_to_cc_send_inst;      // Instruction Cleanup Ack
874
875      ///////////////////////////////////////////////////////
876      // Registers controlled by CAS fsm
877      ///////////////////////////////////////////////////////
878
879      sc_signal<int>      r_cas_fsm;        // FSM state
880      sc_signal<data_t>   r_cas_wdata;      // write data word
881      sc_signal<data_t> * r_cas_rdata;      // read data word
882      sc_signal<uint32_t> r_cas_lfsr;       // lfsr for random introducing
883      sc_signal<size_t>   r_cas_cpt;        // size of command
884      sc_signal<copy_t>   r_cas_copy;       // Srcid of the first copy
885      sc_signal<copy_t>   r_cas_copy_cache; // Srcid of the first copy
886      sc_signal<bool>     r_cas_copy_inst;  // Type of the first copy
887      sc_signal<size_t>   r_cas_count;      // number of copies
888      sc_signal<size_t>   r_cas_ptr;        // pointer to the heap
889      sc_signal<size_t>   r_cas_next_ptr;   // next pointer to the heap
890      sc_signal<bool>     r_cas_is_cnt;     // is_cnt bit (in directory)
891      sc_signal<bool>     r_cas_dirty;      // dirty bit (in directory)
892      sc_signal<size_t>   r_cas_way;        // way in directory
893      sc_signal<size_t>   r_cas_set;        // set in directory
894      sc_signal<data_t>   r_cas_tag;        // cache line tag (in directory)
895      sc_signal<size_t>   r_cas_trt_index;  // Transaction Table index
896      sc_signal<size_t>   r_cas_upt_index;  // Update Table index
897      sc_signal<data_t> * r_cas_data;       // cache line data
898
899      // Buffer between CAS fsm and IXR_CMD fsm (XRAM write)
900      sc_signal<bool>     r_cas_to_ixr_cmd_req;   // valid request
901      sc_signal<addr_t>   r_cas_to_ixr_cmd_nline; // cache line index
902      sc_signal<size_t>   r_cas_to_ixr_cmd_trdid; // index in Transaction Table
903      sc_signal<bool>     r_cas_to_ixr_cmd_write; // write request
904      sc_signal<data_t> * r_cas_to_ixr_cmd_data;  // cache line data
905
906
907      // Buffer between CAS fsm and TGT_RSP fsm
908      sc_signal<bool>     r_cas_to_tgt_rsp_req;   // valid request
909      sc_signal<data_t>   r_cas_to_tgt_rsp_data;  // read data word
910      sc_signal<size_t>   r_cas_to_tgt_rsp_srcid; // Transaction srcid
911      sc_signal<size_t>   r_cas_to_tgt_rsp_trdid; // Transaction trdid
912      sc_signal<size_t>   r_cas_to_tgt_rsp_pktid; // Transaction pktid
913
914      // Buffer between CAS fsm and CC_SEND fsm (Update/Invalidate L1 caches)
915      sc_signal<bool>     r_cas_to_cc_send_multi_req;     // valid request
916      sc_signal<bool>     r_cas_to_cc_send_brdcast_req;   // brdcast request
917      sc_signal<addr_t>   r_cas_to_cc_send_nline;         // cache line index
918      sc_signal<size_t>   r_cas_to_cc_send_trdid;         // index in Update Table
919      sc_signal<data_t>   r_cas_to_cc_send_wdata;         // data (one word)
920      sc_signal<bool>     r_cas_to_cc_send_is_long;       // it is a 64 bits CAS
921      sc_signal<data_t>   r_cas_to_cc_send_wdata_high;    // data high (one word)
922      sc_signal<size_t>   r_cas_to_cc_send_index;         // index of the word in line
923      GenericFifo<bool>   m_cas_to_cc_send_inst_fifo;     // fifo for the L1 type
924      GenericFifo<size_t> m_cas_to_cc_send_srcid_fifo;    // fifo for srcids
925
926#if L1_MULTI_CACHE
927      GenericFifo<size_t> m_cas_to_cc_send_cache_id_fifo; // fifo for srcids
928#endif
929
930      ////////////////////////////////////////////////////
931      // Registers controlled by the IXR_RSP fsm
932      ////////////////////////////////////////////////////
933
934      sc_signal<int>      r_ixr_rsp_fsm;       // FSM state
935      sc_signal<size_t>   r_ixr_rsp_trt_index; // TRT entry index
936      sc_signal<size_t>   r_ixr_rsp_cpt;       // word counter
937
938      // Buffer between IXR_RSP fsm and XRAM_RSP fsm  (response from the XRAM)
939      sc_signal<bool>   * r_ixr_rsp_to_xram_rsp_rok; // A xram response is ready
940      sc_signal<bool>   * r_ixr_rsp_to_xram_rsp_no_coherent; // A xram response is ready and no coherent (ODCCP)
941
942      ////////////////////////////////////////////////////
943      // Registers controlled by the XRAM_RSP fsm
944      ////////////////////////////////////////////////////
945
946      sc_signal<int>      r_xram_rsp_fsm;               // FSM state
947      sc_signal<size_t>   r_xram_rsp_trt_index;         // TRT entry index
948      TransactionTabEntry r_xram_rsp_trt_buf;           // TRT entry local buffer
949      sc_signal<bool>     r_xram_rsp_victim_inval;      // victim line invalidate
950      sc_signal<bool>     r_xram_rsp_victim_coherent;   // victim line coherent
951      sc_signal<bool>     r_xram_rsp_victim_is_cnt;     // victim line inst bit
952      sc_signal<bool>     r_xram_rsp_victim_dirty;      // victim line dirty bit
953      sc_signal<size_t>   r_xram_rsp_victim_way;        // victim line way
954      sc_signal<size_t>   r_xram_rsp_victim_set;        // victim line set
955      sc_signal<addr_t>   r_xram_rsp_victim_nline;      // victim line index
956      sc_signal<copy_t>   r_xram_rsp_victim_copy;       // victim line first copy
957      sc_signal<copy_t>   r_xram_rsp_victim_copy_cache; // victim line first copy
958      sc_signal<bool>     r_xram_rsp_victim_copy_inst;  // victim line type of first copy
959      sc_signal<size_t>   r_xram_rsp_victim_count;      // victim line number of copies
960      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
961      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
962      sc_signal<size_t>   r_xram_rsp_upt_index;         // UPT entry index
963      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
964
965      // Buffer between XRAM_RSP fsm and TGT_RSP fsm  (response to L1 cache)
966      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_req;    // Valid request
967      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_srcid;  // Transaction srcid
968      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_trdid;  // Transaction trdid
969      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_pktid;  // Transaction pktid
970      sc_signal<data_t> * r_xram_rsp_to_tgt_rsp_data;   // data (one cache line)
971      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_word;   // first word index
972      sc_signal<size_t>   r_xram_rsp_to_tgt_rsp_length; // length of the response
973      sc_signal<bool>     r_xram_rsp_to_tgt_rsp_rerror; // send error to requester
974      sc_signal<addr_t>   r_xram_rsp_to_tgt_rsp_ll_key; // LL key from llsc_global_table
975
976      // Buffer between XRAM_RSP fsm and CC_SEND fsm (Inval L1 Caches)
977      sc_signal<bool>     r_xram_rsp_to_cc_send_multi_req;     // Valid request
978      sc_signal<bool>     r_xram_rsp_to_cc_send_brdcast_req;   // Broadcast request
979      sc_signal<addr_t>   r_xram_rsp_to_cc_send_nline;         // cache line index;
980      sc_signal<size_t>   r_xram_rsp_to_cc_send_trdid;         // index of UPT entry
981      GenericFifo<bool>   m_xram_rsp_to_cc_send_inst_fifo;     // fifo for the L1 type
982      GenericFifo<size_t> m_xram_rsp_to_cc_send_srcid_fifo;    // fifo for srcids
983
984#if L1_MULTI_CACHE
985      GenericFifo<size_t> m_xram_rsp_to_cc_send_cache_id_fifo; // fifo for srcids
986#endif
987
988      // Buffer between XRAM_RSP fsm and IXR_CMD fsm (XRAM write)
989      sc_signal<bool>     r_xram_rsp_to_ixr_cmd_req;   // Valid request
990      sc_signal<addr_t>   r_xram_rsp_to_ixr_cmd_nline; // cache line index
991      sc_signal<data_t> * r_xram_rsp_to_ixr_cmd_data;  // cache line data
992      sc_signal<size_t>   r_xram_rsp_to_ixr_cmd_trdid; // index in transaction table
993
994      ////////////////////////////////////////////////////
995      // Registers controlled by the IXR_CMD fsm
996      ////////////////////////////////////////////////////
997
998      sc_signal<int>      r_ixr_cmd_fsm;
999      sc_signal<size_t>   r_ixr_cmd_cpt;
1000
1001      ////////////////////////////////////////////////////
1002      // Registers controlled by TGT_RSP fsm
1003      ////////////////////////////////////////////////////
1004
1005      sc_signal<int>      r_tgt_rsp_fsm;
1006      sc_signal<size_t>   r_tgt_rsp_cpt;
1007      sc_signal<bool>     r_tgt_rsp_key_sent;
1008
1009      ////////////////////////////////////////////////////
1010      // Registers controlled by CC_SEND fsm
1011      ////////////////////////////////////////////////////
1012
1013      sc_signal<int>      r_cc_send_fsm;
1014      sc_signal<size_t>   r_cc_send_cpt;
1015      sc_signal<bool>     r_cc_send_inst;
1016
1017      ////////////////////////////////////////////////////
1018      // Registers controlled by CC_RECEIVE fsm
1019      ////////////////////////////////////////////////////
1020
1021      sc_signal<int>      r_cc_receive_fsm;
1022
1023      ////////////////////////////////////////////////////
1024      // Registers controlled by ALLOC_DIR fsm
1025      ////////////////////////////////////////////////////
1026
1027      sc_signal<int>      r_alloc_dir_fsm;
1028      sc_signal<unsigned> r_alloc_dir_reset_cpt;
1029
1030      ////////////////////////////////////////////////////
1031      // Registers controlled by ALLOC_TRT fsm
1032      ////////////////////////////////////////////////////
1033
1034      sc_signal<int>      r_alloc_trt_fsm;
1035
1036      ////////////////////////////////////////////////////
1037      // Registers controlled by ALLOC_UPT fsm
1038      ////////////////////////////////////////////////////
1039
1040      sc_signal<int>      r_alloc_upt_fsm;
1041
1042      ////////////////////////////////////////////////////
1043      // Registers controlled by ALLOC_HEAP fsm
1044      ////////////////////////////////////////////////////
1045
1046      sc_signal<int>      r_alloc_heap_fsm;
1047      sc_signal<unsigned> r_alloc_heap_reset_cpt;
1048
1049
1050      ////////////////////////////////////////////////////
1051      // REGISTERS FOR ODCCP
1052      ////////////////////////////////////////////////////
1053
1054      sc_signal<uint32_t>  r_cleanup_data_index;
1055      sc_signal<uint32_t>  r_cleanup_trdid;
1056      sc_signal<uint32_t>  r_cleanup_pktid;
1057      sc_signal<data_t>    *r_cleanup_data;          // buffer for saving data from cleanup
1058      sc_signal<bool>      r_cleanup_contains_data;
1059      sc_signal<bool>      r_cleanup_ncc;
1060     
1061      sc_signal<bool>      r_xram_rsp_to_ixr_cmd_inval_ncc_pending;
1062     
1063      sc_signal<bool>      r_cleanup_to_ixr_cmd_req;
1064      sc_signal<data_t>    *r_cleanup_to_ixr_cmd_data;
1065      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_srcid;
1066      sc_signal<bool>      r_cleanup_to_ixr_cmd_l1_dirty_ncc; // this cleanup was dirty in L1
1067      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_trdid;
1068      sc_signal<uint32_t>  r_cleanup_to_ixr_cmd_pktid;
1069      sc_signal<addr_t>    r_cleanup_to_ixr_cmd_nline;
1070    }; // end class VciMemCache
1071
1072}}
1073
1074#endif
1075
1076// Local Variables:
1077// tab-width: 2
1078// c-basic-offset: 2
1079// c-file-offsets:((innamespace . 0)(inline-open . 0))
1080// indent-tabs-mode: nil
1081// End:
1082
1083// vim: filetype=cpp:expandtab:shiftwidth=2:tabstop=2:softtabstop=2
1084
Note: See TracBrowser for help on using the repository browser.