Changeset 468 for trunk


Ignore:
Timestamp:
Jul 24, 2013, 8:47:40 AM (11 years ago)
Author:
cfuguet
Message:


Merging vci_mem_cache from branches/v5 to trunk [441-467]

=-----------------------------------------------------------------------
r441 | cfuguet | 2013-07-17 10:54:07 +0200 (Wed, 17 Jul 2013) | 14 lines

Modifications in branches/v5/vci_mem_cache:

  • Changing name of CC DSPIN ports: + p_dspin_in => p_dspin_p2m + p_dspin_out => p_dspin_m2p
  • Splitting the Update Table in two tables: + UPT (Update Table): Stores the MULTI-UPDATE transactions + IVT (Invalidate Table): Stores the MULTI/BROADCAST INVALIDATE

transactions

Each table has its own allocator FSM: r_alloc_upt and r_alloc_ivt

=-----------------------------------------------------------------------
r442 | cfuguet | 2013-07-17 12:13:51 +0200 (Wed, 17 Jul 2013) | 13 lines

Modifications in branches/v5/modules/vci_mem_cache:

  • Introducing third port for the CLACK network.
  • CLEANUP FSM is no more a CC_SEND FSM client.
  • CLEANUP FSM controls directly the p_dspin_clack port

=-----------------------------------------------------------------------
r445 | cfuguet | 2013-07-18 10:49:36 +0200 (Thu, 18 Jul 2013) | 7 lines

Bugfix in vci_mem_cache:

  • Adding missing "strings" for print_trace() function
  • Adding alloc_ivt fsm (Invalidate Table) in the

print_trace() function

=-----------------------------------------------------------------------
r455 | cfuguet | 2013-07-19 10:16:17 +0200 (Fri, 19 Jul 2013) | 8 lines

Merged

/trunk/modules/vci_mem_cache:449 with
/branches/v5/modules/vci_mem_cache:446.

This merge introduces into the branch the last modifications concerning
the VCI memory cache configuration interface


Merging vci_cc_vcache_wrapper from branches/v5 to trunk [444-467]

=-----------------------------------------------------------------------
r444 | cfuguet | 2013-07-17 14:46:46 +0200 (Wed, 17 Jul 2013) | 7 lines

Modifications in branches/v5/modules/vci_cc_vcache_wrapper:

  • Renaming FROM_MC DSPIN flits fields in M2P
  • Renaming FROM_L1 DSPIN flits fields in P2M
  • Renaming CLEANUP_ACK DSPIN flits fields in CLACK

=-----------------------------------------------------------------------
r446 | cfuguet | 2013-07-18 11:37:47 +0200 (Thu, 18 Jul 2013) | 13 lines

Modifications in vci_cc_vcache_wrapper:

  • Merging the states DCACHE/ICACHE_CC_BROADCAST and DCACHE/ICACHE_CC_INVAL. This is because, the BROADCAST INVALIDATE and the MULTICAST INVALIDATE are both acknowledged by a CLEANUP.
  • Adding third port for the clack coherence network.
  • Renaming the port dspin_in to dspin_m2p and the port dspin_out to dspin_p2m

=-----------------------------------------------------------------------
r454 | haoliu | 2013-07-19 10:15:13 +0200 (Fri, 19 Jul 2013) | 2 lines

modified CC_RECEIVE FSM and CC_CHECK FSM (icache and dcache) for new
version V5

=-----------------------------------------------------------------------
r461 | cfuguet | 2013-07-19 15:49:43 +0200 (Fri, 19 Jul 2013) | 9 lines

Bugfix in vci_cc_vcache_wrapper:

  • In the states DCACHE/ICACHE CC_UPDT the FSM returns to the state CC_CHECK only when the cc_send_req is occupied.

We must not return to the CC_CHECK state if not ROK of the
DATA FIFO because the counter word counter will be reset.

=-----------------------------------------------------------------------
r462 | cfuguet | 2013-07-19 16:26:26 +0200 (Fri, 19 Jul 2013) | 8 lines

Modification in vci_cc_vcache_wrapper:

  • Optimization in DCACHE/ICACHE CC_CHECK state. We can handle a CLACK and a CC request if the latter does a MISS match. This is because the CC request doing MISS match does not need to access the directory

=-----------------------------------------------------------------------
r463 | cfuguet | 2013-07-19 16:52:06 +0200 (Fri, 19 Jul 2013) | 12 lines

Modification in vci_cc_vcache_wrapper:

  • Optimization in DCACHE/ICACHE CC_CHECK state. If pending request to CC_SEND, we wait in the CC_CHECK state. Doing this, during the wait, we can handle incoming CLACK avoiding any deadlock situation.

The states CC_UPDT and CC_INVAL do not need to test anymore if
there is a pending request to CC_SEND.


Merging tsar_generic_xbar from branches/v5 to trunk [447-467]

=-----------------------------------------------------------------------
r447 | cfuguet | 2013-07-18 16:12:05 +0200 (Thu, 18 Jul 2013) | 8 lines

Adding tsar_generic_xbar platform in branches/v5/platforms:

  • This platform contains a third local crossbar interconnect for the CLACK network.
  • It works only in a monocluster topology

=-----------------------------------------------------------------------
r448 | cfuguet | 2013-07-18 17:51:18 +0200 (Thu, 18 Jul 2013) | 9 lines

Modification in branches/v5/platforms/tsar_generic_xbar:

  • Adding a DSPIN router to the platform to allow the inter-cluster communication for the CLACK commands.

With this modification, the tsar_generic_xbar platform can be used
for multi-cluster simulations

=-----------------------------------------------------------------------
r466 | cfuguet | 2013-07-23 17:01:49 +0200 (Tue, 23 Jul 2013) | 9 lines

Modifications in branches/v5 vci_mem_cache:

  • Replacing the third router CLACK by a third virtual channel in the new virtual_dspin_router supporting several virtual channels.

The third channel has been added in the COMMAND router.

=-----------------------------------------------------------------------
r467 | cfuguet | 2013-07-23 17:23:13 +0200 (Tue, 23 Jul 2013) | 5 lines

Modifications in branches/v5 tsar_generic_xbar:

  • Adding preprocessor conditional statements for ALMOS support


Merging dspin_dhccp_param from branches/v5 to trunk [377-467]

=-----------------------------------------------------------------------
r442 | cfuguet | 2013-07-17 12:13:51 +0200 (Wed, 17 Jul 2013) | 13 lines

Modifications in branches/v5/communication/dspin_dhccp_param:

  • Renaming FROM_MC fields in M2P
  • Renaming FROM_L1 fields in P2M
  • Renaming CLEANUP_ACK fields in CLACK
Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/communication/dspin_dhccp_param

  • trunk/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h

    r356 r468  
    6161
    6262/*
    63  * Memory Cache to L1 cache command packets
    64  *
    65  * CLEANUP ACKNOWLEDGEMENT
    66  *
    67  * flit 1
    68  * ----------------------------------------------------------------------------------------------
    69  * EOP:1 | DEST(14 bits) | X(3 bits) | SET_INDEX(16 bits) | WAY_INDEX(2 bits) | TYPE:0b10X | BC:0
    70  * ----------------------------------------------------------------------------------------------
    71  *                                                                            | X: 0 DATA  |
    72  *                                                                            |    1 INST  |
     63 * M2P command packets
    7364 *
    7465 * MULTICAST UPDATE
     
    7667 * flit 1
    7768 * ----------------------------------------------------------------------------------------------
    78  * EOP:0 | DEST(14 bits) | X(3 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b00X  | BC:0
     69 * EOP:0 | DEST(14 bits) | X(4 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b0X   | BC:0
    7970 * ----------------------------------------------------------------------------------------------
    8071 *                                                                           | X: 0 DATA   |
     
    9990 * flit 1
    10091 * ----------------------------------------------------------------------------------------------
    101  * EOP:0 | DEST(14 bits) | X(3 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b01X | BC:0
     92 * EOP:0 | DEST(14 bits) | X(4 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b1X | BC:0
    10293 * ----------------------------------------------------------------------------------------------
    10394 *                                                                           | X: 0 DATA  |
     
    120111 * EOP:1 |        X(5 bits)       |                                              NLINE (34 bits)
    121112 * ----------------------------------------------------------------------------------------------
     113 *
     114 * M2P clack commands
     115 *
     116 * CLEANUP ACKNOWLEDGEMENT
     117 *
     118 * flit 1
     119 * ----------------------------------------------------------------------------------------------
     120 * EOP:1 | DEST(14 bits) | X(5 bits) | SET_INDEX(16 bits) | WAY_INDEX(2 bits) | TYPE:0bX   | BC:0
     121 * ----------------------------------------------------------------------------------------------
     122 *                                                                            | X: 0 CLACK |
     123 *                                                                            |      DATA  |
     124 *                                                                            |    1 CLACK |
     125 *                                                                            |      INST  |
     126 *
    122127 */
    123128
     
    135140  public:
    136141
    137     static const uint8_t  from_memc_flit_width         = 40;
    138     static const uint8_t  from_l1_flit_width           = 33;
     142    static const uint8_t  m2p_flit_width               = 40;
     143    static const uint8_t  p2m_flit_width               = 33;
     144    static const uint8_t  clack_flit_width             = 40;
    139145
    140146    static const uint8_t  UPDT_INDEX_WIDTH             = 4;
     
    148154    static const uint8_t  WAY_INDEX_WIDTH              = 2;
    149155    static const uint8_t  BROADCAST_BOX_WIDTH          = 20;
    150     static const uint8_t  MC_TYPE_WIDTH                = 3;
    151     static const uint8_t  L1_TYPE_WIDTH                = 2;
    152 
    153     static const uint8_t  FROM_L1_TYPE_SHIFT           = 1;
    154     static const uint64_t FROM_L1_TYPE_MASK            = ((1ULL<<L1_TYPE_WIDTH)-1);
    155     static const uint8_t  FROM_L1_EOP_SHIFT            = 32;
    156     static const uint64_t FROM_L1_EOP_MASK             = 1;
    157     static const uint8_t  FROM_L1_BC_SHIFT             = 0;
    158     static const uint64_t FROM_L1_BC_MASK              = 1;
     156    static const uint8_t  M2P_TYPE_WIDTH               = 2;
     157    static const uint8_t  P2M_TYPE_WIDTH               = 2;
     158    static const uint8_t  CLACK_TYPE_WIDTH             = 1;
     159
     160    static const uint8_t  P2M_TYPE_SHIFT               = 1;
     161    static const uint64_t P2M_TYPE_MASK                = ((1ULL<<P2M_TYPE_WIDTH)-1);
     162    static const uint8_t  P2M_EOP_SHIFT                = 32;
     163    static const uint64_t P2M_EOP_MASK                 = 1;
     164    static const uint8_t  P2M_BC_SHIFT                 = 0;
     165    static const uint64_t P2M_BC_MASK                  = 1;
    159166
    160167    static const uint8_t  CLEANUP_DEST_SHIFT           = 22;
     
    174181    static const uint64_t MULTI_ACK_UPDT_INDEX_MASK    = ((1ULL<<UPDT_INDEX_WIDTH)-1);
    175182
    176     static const uint8_t  FROM_MC_TYPE_SHIFT           = 1;
    177     static const uint64_t FROM_MC_TYPE_MASK            = ((1ULL<<MC_TYPE_WIDTH)-1);
    178     static const uint8_t  FROM_MC_EOP_SHIFT            = 39;
    179     static const uint64_t FROM_MC_EOP_MASK             = 1;
    180     static const uint8_t  FROM_MC_BC_SHIFT             = 0;
    181     static const uint64_t FROM_MC_BC_MASK              = 1;
     183    static const uint8_t  M2P_TYPE_SHIFT               = 1;
     184    static const uint64_t M2P_TYPE_MASK                = ((1ULL<<M2P_TYPE_WIDTH)-1);
     185    static const uint8_t  M2P_EOP_SHIFT                = 39;
     186    static const uint64_t M2P_EOP_MASK                 = 1;
     187    static const uint8_t  M2P_BC_SHIFT                 = 0;
     188    static const uint64_t M2P_BC_MASK                  = 1;
    182189
    183190    static const uint8_t  MULTI_INVAL_DEST_SHIFT       = 25;
     
    205212    static const uint64_t MULTI_UPDT_DATA_MASK         = ((1ULL<<DATA_WIDTH)-1);
    206213
    207     static const uint8_t  CLEANUP_ACK_DEST_SHIFT       = MULTI_INVAL_DEST_SHIFT;
    208     static const uint64_t CLEANUP_ACK_DEST_MASK        = MULTI_INVAL_DEST_MASK;
    209     static const uint8_t  CLEANUP_ACK_SET_SHIFT        = 6;
    210     static const uint64_t CLEANUP_ACK_SET_MASK         = ((1ULL<<SET_INDEX_WIDTH)-1);
    211     static const uint8_t  CLEANUP_ACK_WAY_SHIFT        = 4;
    212     static const uint64_t CLEANUP_ACK_WAY_MASK         = ((1ULL<<WAY_INDEX_WIDTH)-1);
    213 
    214214    static const uint8_t  BROADCAST_BOX_SHIFT          = 19;
    215215    static const uint64_t BROADCAST_BOX_MASK           = ((1ULL<<BROADCAST_BOX_WIDTH)-1);
     
    219219    static const uint64_t BROADCAST_NLINE_MASK         = MULTI_INVAL_NLINE_MASK;
    220220
     221    static const uint8_t  CLACK_TYPE_SHIFT             = 1;
     222    static const uint64_t CLACK_TYPE_MASK              = ((1ULL<<CLACK_TYPE_WIDTH)-1);
     223    static const uint8_t  CLACK_EOP_SHIFT              = 39;
     224    static const uint64_t CLACK_EOP_MASK               = 1;
     225    static const uint8_t  CLACK_BC_SHIFT               = 0;
     226    static const uint64_t CLACK_BC_MASK                = 1;
     227    static const uint8_t  CLACK_DEST_SHIFT             = 25;
     228    static const uint64_t CLACK_DEST_MASK              = ((1ULL<<SRCID_WIDTH)-1);
     229    static const uint8_t  CLACK_SET_SHIFT              = 6;
     230    static const uint64_t CLACK_SET_MASK               = ((1ULL<<SET_INDEX_WIDTH)-1);
     231    static const uint8_t  CLACK_WAY_SHIFT              = 4;
     232    static const uint64_t CLACK_WAY_MASK               = ((1ULL<<WAY_INDEX_WIDTH)-1);
     233
    221234    /*
    222      * L1 cache to Memory Cache command types
     235     * P2M command types
    223236     */
    224237    enum
     
    231244
    232245    /*
    233      * Memory Cache to L1 cache command types
     246     * M2P command types
    234247     */
    235248    enum
     
    240253      TYPE_MULTI_INVAL      = 2,
    241254      TYPE_MULTI_INVAL_DATA = TYPE_MULTI_INVAL,
    242       TYPE_MULTI_INVAL_INST = 3,
    243       TYPE_CLEANUP_ACK      = 4,
    244       TYPE_CLEANUP_ACK_DATA = TYPE_CLEANUP_ACK,
    245       TYPE_CLEANUP_ACK_INST = 5
     255      TYPE_MULTI_INVAL_INST = 3
    246256    };
    247257
     258    /*
     259     * CLACK command types
     260     */
     261    enum
     262    {
     263      TYPE_CLACK      = 0,
     264      TYPE_CLACK_DATA = TYPE_CLACK,
     265      TYPE_CLACK_INST = 1
     266    };
     267
    248268    enum flit_field_e
    249269    {
    250       FROM_L1_TYPE,
    251       FROM_L1_EOP,
    252       FROM_L1_BC,
     270      P2M_TYPE,
     271      P2M_EOP,
     272      P2M_BC,
    253273
    254274      CLEANUP_DEST,
     
    261281      MULTI_ACK_UPDT_INDEX,
    262282
    263       FROM_MC_TYPE,
    264       FROM_MC_EOP,
    265       FROM_MC_BC,
     283      M2P_TYPE,
     284      M2P_EOP,
     285      M2P_BC,
    266286
    267287      MULTI_INVAL_DEST,
     
    278298      MULTI_UPDT_DATA,
    279299
    280       CLEANUP_ACK_DEST,
    281       CLEANUP_ACK_SET,
    282       CLEANUP_ACK_WAY,
     300      CLACK_TYPE,
     301
     302      CLACK_DEST,
     303      CLACK_SET,
     304      CLACK_WAY,
    283305
    284306      BROADCAST_BOX,
     
    291313      switch(field)
    292314      {
    293         GET_FIELD(flit,FROM_L1_TYPE);
    294         GET_FIELD(flit,FROM_L1_EOP);
    295         GET_FIELD(flit,FROM_L1_BC);
     315        GET_FIELD(flit,P2M_TYPE);
     316        GET_FIELD(flit,P2M_EOP);
     317        GET_FIELD(flit,P2M_BC);
    296318        GET_FIELD(flit,CLEANUP_DEST);
    297319        GET_FIELD(flit,CLEANUP_SRCID);
     
    301323        GET_FIELD(flit,MULTI_ACK_DEST);
    302324        GET_FIELD(flit,MULTI_ACK_UPDT_INDEX);
    303         GET_FIELD(flit,FROM_MC_TYPE);
    304         GET_FIELD(flit,FROM_MC_EOP);
    305         GET_FIELD(flit,FROM_MC_BC);
     325        GET_FIELD(flit,M2P_TYPE);
     326        GET_FIELD(flit,M2P_EOP);
     327        GET_FIELD(flit,M2P_BC);
    306328        GET_FIELD(flit,MULTI_INVAL_DEST);
    307329        GET_FIELD(flit,MULTI_INVAL_SRCID);
     
    315337        GET_FIELD(flit,MULTI_UPDT_BE);
    316338        GET_FIELD(flit,MULTI_UPDT_DATA);
    317         GET_FIELD(flit,CLEANUP_ACK_DEST);
    318         GET_FIELD(flit,CLEANUP_ACK_SET);
    319         GET_FIELD(flit,CLEANUP_ACK_WAY);
     339        GET_FIELD(flit,CLACK_TYPE);
     340        GET_FIELD(flit,CLACK_DEST);
     341        GET_FIELD(flit,CLACK_SET);
     342        GET_FIELD(flit,CLACK_WAY);
    320343        GET_FIELD(flit,BROADCAST_BOX);
    321344        GET_FIELD(flit,BROADCAST_SRCID);
     
    330353      switch(field)
    331354      {
    332         SET_FIELD(flit,value,FROM_L1_TYPE);
    333         SET_FIELD(flit,value,FROM_L1_EOP);
    334         SET_FIELD(flit,value,FROM_L1_BC);
     355        SET_FIELD(flit,value,P2M_TYPE);
     356        SET_FIELD(flit,value,P2M_EOP);
     357        SET_FIELD(flit,value,P2M_BC);
    335358        SET_FIELD(flit,value,CLEANUP_DEST);
    336359        SET_FIELD(flit,value,CLEANUP_SRCID);
     
    340363        SET_FIELD(flit,value,MULTI_ACK_DEST);
    341364        SET_FIELD(flit,value,MULTI_ACK_UPDT_INDEX);
    342         SET_FIELD(flit,value,FROM_MC_TYPE);
    343         SET_FIELD(flit,value,FROM_MC_EOP);
    344         SET_FIELD(flit,value,FROM_MC_BC);
     365        SET_FIELD(flit,value,M2P_TYPE);
     366        SET_FIELD(flit,value,M2P_EOP);
     367        SET_FIELD(flit,value,M2P_BC);
    345368        SET_FIELD(flit,value,MULTI_INVAL_DEST);
    346369        SET_FIELD(flit,value,MULTI_INVAL_SRCID);
     
    354377        SET_FIELD(flit,value,MULTI_UPDT_BE);
    355378        SET_FIELD(flit,value,MULTI_UPDT_DATA);
    356         SET_FIELD(flit,value,CLEANUP_ACK_DEST);
    357         SET_FIELD(flit,value,CLEANUP_ACK_SET);
    358         SET_FIELD(flit,value,CLEANUP_ACK_WAY);
     379        SET_FIELD(flit,value,CLACK_TYPE);
     380        SET_FIELD(flit,value,CLACK_DEST);
     381        SET_FIELD(flit,value,CLACK_SET);
     382        SET_FIELD(flit,value,CLACK_WAY);
    359383        SET_FIELD(flit,value,BROADCAST_BOX);
    360384        SET_FIELD(flit,value,BROADCAST_SRCID);
  • trunk/modules/vci_cc_vcache_wrapper

  • trunk/modules/vci_cc_vcache_wrapper/caba/metadata/vci_cc_vcache_wrapper.sd

    r421 r468  
    3737            ports = [
    3838            Port('caba:vci_initiator', 'p_vci'),
    39             Port('caba:dspin_input', 'p_dspin_in',
     39            Port('caba:dspin_input', 'p_dspin_m2p',
    4040                  dspin_data_size = parameter.Reference('dspin_in_width')),
    41             Port('caba:dspin_output', 'p_dspin_out',
     41            Port('caba:dspin_output', 'p_dspin_p2m',
    4242                  dspin_data_size = parameter.Reference('dspin_out_width')),
     43            Port('caba:dspin_input', 'p_dspin_clack',
     44                  dspin_data_size = parameter.Reference('dspin_in_width')),
    4345                Port('caba:bit_in','p_irq', parameter.Constant('n_irq')),
    4446                Port('caba:bit_in', 'p_resetn', auto = 'resetn'),
  • trunk/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r432 r468  
    8989        // handling coherence requests
    9090        ICACHE_CC_CHECK,
     91        ICACHE_CC_UPDT,
    9192        ICACHE_CC_INVAL,
    92         ICACHE_CC_UPDT,
    93         ICACHE_CC_BROADCAST,
    94         ICACHE_CC_SEND_WAIT,
    9593    };
    9694
     
    138136        // handling coherence requests
    139137        DCACHE_CC_CHECK,
     138        DCACHE_CC_UPDT,
    140139        DCACHE_CC_INVAL,
    141         DCACHE_CC_UPDT,
    142         DCACHE_CC_BROADCAST,
    143         DCACHE_CC_SEND_WAIT,
    144140        // handling TLB inval (after a coherence or XTN request)
    145141        DCACHE_INVAL_TLB_SCAN,
     
    173169    {
    174170        CC_RECEIVE_IDLE,
    175         CC_RECEIVE_CLACK,
    176171        CC_RECEIVE_BRDCAST_HEADER,
    177172        CC_RECEIVE_BRDCAST_NLINE,
    178         CC_RECEIVE_INVAL_HEADER,
    179         CC_RECEIVE_INVAL_NLINE,
    180         CC_RECEIVE_UPDT_HEADER,
    181         CC_RECEIVE_UPDT_NLINE,
    182         CC_RECEIVE_UPDT_DATA,
     173        CC_RECEIVE_INS_INVAL_HEADER,
     174        CC_RECEIVE_INS_INVAL_NLINE,
     175        CC_RECEIVE_INS_UPDT_HEADER,
     176        CC_RECEIVE_INS_UPDT_NLINE,
     177        CC_RECEIVE_INS_UPDT_DATA,
     178        CC_RECEIVE_DATA_INVAL_HEADER,
     179        CC_RECEIVE_DATA_INVAL_NLINE,
     180        CC_RECEIVE_DATA_UPDT_HEADER,
     181        CC_RECEIVE_DATA_UPDT_NLINE,
     182        CC_RECEIVE_DATA_UPDT_DATA,
    183183    };
    184184
     
    285285
    286286public:
    287     sc_in<bool>                                 p_clk;
    288     sc_in<bool>                                 p_resetn;
    289     sc_in<bool>                                 p_irq[iss_t::n_irq];
    290     soclib::caba::VciInitiator<vci_param>       p_vci;
    291     soclib::caba::DspinInput <dspin_in_width>   p_dspin_in;
    292     soclib::caba::DspinOutput<dspin_out_width>  p_dspin_out;
     287    sc_in<bool>                                p_clk;
     288    sc_in<bool>                                p_resetn;
     289    sc_in<bool>                                p_irq[iss_t::n_irq];
     290    soclib::caba::VciInitiator<vci_param>      p_vci;
     291    soclib::caba::DspinInput<dspin_in_width>   p_dspin_m2p;
     292    soclib::caba::DspinOutput<dspin_out_width> p_dspin_p2m;
     293    soclib::caba::DspinInput<dspin_in_width>   p_dspin_clack;
    293294
    294295private:
     
    371372    sc_signal<bool>         r_icache_cc_need_write;     // activate the cache for writing
    372373
     374    // coherence clack handling
     375    sc_signal<bool>         r_icache_clack_req;         // clack request
     376    sc_signal<size_t>       r_icache_clack_way;             // clack way
     377    sc_signal<size_t>       r_icache_clack_set;             // clack set
     378
    373379    // icache flush handling
    374380    sc_signal<size_t>       r_icache_flush_count;           // slot counter used for cache flush
     
    444450    sc_signal<bool>         r_dcache_cc_need_write;     // activate the cache for writing
    445451
     452    // coherence clack handling
     453    sc_signal<bool>         r_dcache_clack_req;         // clack request
     454    sc_signal<size_t>       r_dcache_clack_way;             // clack way
     455    sc_signal<size_t>       r_dcache_clack_set;             // clack set
     456
    446457    // dcache flush handling
    447458    sc_signal<size_t>       r_dcache_flush_count;           // slot counter used for cache flush
     
    537548    sc_signal<paddr_t>      r_cc_receive_dcache_nline;      // cache line physical address
    538549
     550    ///////////////////////////////////
     551    //  DSPIN CLACK INTERFACE REGISTER
     552    ///////////////////////////////////
     553    sc_signal<bool>         r_dspin_clack_req;
     554    sc_signal<uint64_t>     r_dspin_clack_flit;
     555   
    539556    //////////////////////////////////////////////////////////////////
    540557    // processor, write buffer, caches , TLBs
  • trunk/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r434 r468  
    6262
    6363        "ICACHE_CC_CHECK",
     64        "ICACHE_CC_UPDT",
    6465        "ICACHE_CC_INVAL",
    65         "ICACHE_CC_UPDT",
    66         "ICACHE_CC_BROADCAST",
    67         "ICACHE_CC_SEND_WAIT",
    6866    };
    6967
     
    110108
    111109        "DCACHE_CC_CHECK",
     110        "DCACHE_CC_UPDT",
    112111        "DCACHE_CC_INVAL",
    113         "DCACHE_CC_UPDT",
    114         "DCACHE_CC_BROADCAST",
    115         "DCACHE_CC_SEND_WAIT",
    116112
    117113        "DCACHE_INVAL_TLB_SCAN",
     
    160156const char *cc_receive_fsm_state_str[] = {
    161157        "CC_RECEIVE_IDLE",
    162         "CC_RECEIVE_CLACK",
    163158        "CC_RECEIVE_BRDCAST_HEADER",
    164159        "CC_RECEIVE_BRDCAST_NLINE",
    165         "CC_RECEIVE_INVAL_HEADER",
    166         "CC_RECEIVE_INVAL_NLINE",
    167         "CC_RECEIVE_UPDT_HEADER",
    168         "CC_RECEIVE_UPDT_NLINE",
    169         "CC_RECEIVE_UPDT_DATA",
     160        "CC_RECEIVE_INS_INVAL_HEADER",
     161        "CC_RECEIVE_INS_INVAL_NLINE",
     162        "CC_RECEIVE_INS_UPDT_HEADER",
     163        "CC_RECEIVE_INS_UPDT_NLINE",
     164        "CC_RECEIVE_INS_UPDT_DATA",
     165        "CC_RECEIVE_DATA_INVAL_HEADER",
     166        "CC_RECEIVE_DATA_INVAL_NLINE",
     167        "CC_RECEIVE_DATA_UPDT_HEADER",
     168        "CC_RECEIVE_DATA_UPDT_NLINE",
     169        "CC_RECEIVE_DATA_UPDT_DATA",
    170170    };
    171171
     
    216216      p_resetn("p_resetn"),
    217217      p_vci("p_vci"),
    218       p_dspin_in("p_dspin_in"),
    219       p_dspin_out("p_dspin_out"),
     218      p_dspin_m2p("p_dspin_m2p"),
     219      p_dspin_p2m("p_dspin_p2m"),
     220      p_dspin_clack("p_dspin_clack"),
    220221
    221222      m_cacheability_table( mtd.getCacheabilityTable() ),
     
    755756        r_icache_cc_send_req       = false;
    756757
     758        r_icache_clack_req         = false;
     759
    757760        // No pending write in pipeline
    758761        r_dcache_wbuf_req          = false;
     
    775778        r_dcache_cc_send_req       = false;
    776779
     780        r_dcache_clack_req         = false;
     781
    777782        // No request from CC_RECEIVE FSM to ICACHE/DCACHE FSMs
    778783        r_cc_receive_icache_req    = false;
     
    789794        r_icache_miss_inval        = false;
    790795        r_dcache_miss_inval        = false;
     796
     797        r_dspin_clack_req          = false;
    791798
    792799        // No signalisation  of errors
     
    10141021                        // 5/ uncacheable read miss                     => ICACHE_UNC_REQ
    10151022    {
     1023        // coherence clack interrupt
     1024        if ( r_icache_clack_req.read() )
     1025        {
     1026            r_icache_fsm = ICACHE_CC_CHECK;
     1027            r_icache_fsm_save = r_icache_fsm.read();
     1028            break;
     1029        }
     1030
    10161031        // coherence interrupt
    10171032        if ( r_cc_receive_icache_req.read() )
     
    12421257                            // external coherence request are accepted in this state.
    12431258    {
     1259        // coherence clack interrupt
     1260        if ( r_icache_clack_req.read() )
     1261        {
     1262            r_icache_fsm = ICACHE_CC_CHECK;
     1263            r_icache_fsm_save = r_icache_fsm.read();
     1264            break;
     1265        }
     1266
    12441267        // coherence interrupt
    12451268        if ( r_cc_receive_icache_req.read() )
     
    12861309                                        // A cleanup request is generated for each valid line
    12871310    {
     1311        // coherence clack interrupt
     1312        if ( r_icache_clack_req.read() )
     1313        {
     1314            r_icache_fsm = ICACHE_CC_CHECK;
     1315            r_icache_fsm_save = r_icache_fsm.read();
     1316            break;
     1317        }
     1318
    12881319        // coherence request (from CC_RECEIVE FSM)
    12891320        if ( r_cc_receive_icache_req.read() )
     
    14841515    {
    14851516        if (m_ireq.valid) m_cost_ins_miss_frz++;
     1517
     1518        // coherence clack interrupt
     1519        if ( r_icache_clack_req.read() )
     1520        {
     1521            r_icache_fsm = ICACHE_CC_CHECK;
     1522            r_icache_fsm_save = r_icache_fsm.read();
     1523            break;
     1524        }
    14861525
    14871526        // coherence interrupt
     
    15741613        if (m_ireq.valid) m_cost_ins_miss_frz++;
    15751614
     1615        // coherence clack interrupt
     1616        if ( r_icache_clack_req.read() )
     1617        {
     1618            r_icache_fsm = ICACHE_CC_CHECK;
     1619            r_icache_fsm_save = r_icache_fsm.read();
     1620            break;
     1621        }
     1622
    15761623        // coherence interrupt
    15771624        if ( r_cc_receive_icache_req.read() )
     
    16451692        if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    16461693
     1694        // coherence clack interrupt
     1695        if ( r_icache_clack_req.read() )
     1696        {
     1697            r_icache_fsm = ICACHE_CC_CHECK;
     1698            r_icache_fsm_save = r_icache_fsm.read();
     1699            break;
     1700        }
     1701
    16471702        // coherence interrupt
    16481703        if ( r_cc_receive_icache_req.read() )
     
    17161771    case ICACHE_UNC_WAIT:       // waiting a response to an uncacheable read from VCI_RSP FSM
    17171772    {
     1773        // coherence clack interrupt
     1774        if ( r_icache_clack_req.read() )
     1775        {
     1776            r_icache_fsm = ICACHE_CC_CHECK;
     1777            r_icache_fsm_save = r_icache_fsm.read();
     1778            break;
     1779        }
     1780
    17181781        // coherence interrupt
    17191782        if ( r_cc_receive_icache_req.read() )
     
    17561819        paddr_t  mask  = ~((m_icache_words<<2)-1);
    17571820
    1758         if (r_cc_receive_icache_type.read() == CC_TYPE_CLACK)
    1759                                 // We switch the directory slot to EMPTY state
    1760                             // and reset r_icache_miss_clack if the cleanup ack
    1761                             // is matching a pending miss
    1762         {
    1763 
    1764             if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    1765 
    1766 #ifdef INSTRUMENTATION
    1767 m_cpt_icache_dir_write++;
    1768 #endif
    1769             r_icache.write_dir( 0,
    1770                                 r_cc_receive_icache_way.read(),
    1771                                 r_cc_receive_icache_set.read(),
    1772                                 CACHE_SLOT_STATE_EMPTY);
    1773 
    1774             if ( (r_icache_miss_set.read() == r_cc_receive_icache_set.read()) and
    1775                  (r_icache_miss_way.read() == r_cc_receive_icache_way.read()) )
    1776                     r_icache_miss_clack = false;
    1777 
    1778             r_icache_fsm = r_icache_fsm_save.read() ;
    1779             r_cc_receive_icache_req = false;
    1780 
    1781 #if DEBUG_ICACHE
    1782 if ( m_debug_activated )
    1783 {
    1784     std::cout << "  <PROC " << name()
    1785     << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
    1786     << " set = " << r_cc_receive_icache_set.read()
    1787     << " / way = " << r_cc_receive_icache_way.read() << std::endl;
    1788 }
    1789 #endif
    1790         }
    1791         else if( ((r_icache_fsm_save.read() == ICACHE_MISS_SELECT) or
    1792                  (r_icache_fsm_save.read() == ICACHE_MISS_WAIT) or
    1793                  (r_icache_fsm_save.read() == ICACHE_MISS_DIR_UPDT)) and
    1794                  ((r_icache_vci_paddr.read() & mask) == (paddr & mask)) ) // matching
     1821
     1822        // Match between MISS address and CC address
     1823        // note: In the same cycle we can handle a CLACK and a MISS match
     1824        // because the CLACK access the directory but the MISS match dont.
     1825        if (r_cc_receive_icache_req.read() and
     1826          ((r_icache_fsm_save.read() == ICACHE_MISS_SELECT  )  or
     1827           (r_icache_fsm_save.read() == ICACHE_MISS_WAIT    )  or
     1828           (r_icache_fsm_save.read() == ICACHE_MISS_DIR_UPDT)) and
     1829          ((r_icache_vci_paddr.read() & mask) == (paddr & mask)) ) // matching
    17951830        {
    17961831            // signaling the matching
     
    18031838                r_icache_fsm        = ICACHE_CC_UPDT;
    18041839                r_icache_cc_word    = r_cc_receive_word_idx.read();
     1840
    18051841                // just pop the fifo , don't write in icache
    18061842                r_icache_cc_need_write = false;
     
    18211857#endif
    18221858        }
    1823         else                                                                                        // no match
    1824         {
    1825             int         state = 0;
    1826             size_t          way = 0;
    1827             size_t          set = 0;
    1828             size_t          word = 0;
     1859
     1860        // CLACK handler
     1861        // We switch the directory slot to EMPTY state
     1862        // and reset r_icache_miss_clack if the cleanup ack
     1863        // is matching a pending miss.
     1864        if ( r_icache_clack_req.read() )
     1865        {
     1866
     1867            if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    18291868
    18301869#ifdef INSTRUMENTATION
    1831 m_cpt_icache_dir_read++;
    1832 #endif
    1833             r_icache.read_dir(paddr,
    1834                               &state,
    1835                               &way,
    1836                               &set,
    1837                               &word);
    1838 
    1839             r_icache_cc_way = way;
    1840             r_icache_cc_set = set;
    1841 
    1842             if ( state == CACHE_SLOT_STATE_VALID)            // hit
    1843             {
    1844                 // need to update the cache state
    1845                 r_icache_cc_need_write = true;
    1846                 if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)  // hit update
    1847                 {
    1848                     r_icache_fsm          = ICACHE_CC_UPDT;
    1849                     r_icache_cc_word      = r_cc_receive_word_idx.read();
    1850                 }
    1851                 else if (r_cc_receive_icache_type.read() == CC_TYPE_INVAL)   // hit inval
    1852                 {
    1853                     r_icache_fsm          = ICACHE_CC_INVAL;
    1854                 }
    1855                 else if (r_cc_receive_icache_type.read() == CC_TYPE_BRDCAST)  // hit broadcast
    1856                 {
    1857                     r_icache_fsm          = ICACHE_CC_BROADCAST;
    1858                 }
    1859             }
    1860             else                                      // miss
    1861             {
    1862                 // multicast acknowledgement required in case of update
    1863                 if(r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
    1864                 {
    1865                     r_icache_fsm          = ICACHE_CC_UPDT;
    1866                     r_icache_cc_word      = r_cc_receive_word_idx.read();
    1867                     // just pop the fifo , don't write in icache
    1868                     r_icache_cc_need_write = false;
    1869                 }
    1870                 else // No response needed
    1871                 {
    1872                     r_cc_receive_icache_req = false;
    1873                     r_icache_fsm          = r_icache_fsm_save.read();
    1874                 }
    1875             }
    1876         }
    1877         break;
    1878     }
    1879     /////////////////////
    1880     case ICACHE_CC_INVAL:       // hit inval : switch slot to EMPTY state
    1881     {
     1870m_cpt_icache_dir_write++;
     1871#endif
     1872            r_icache.write_dir( 0,
     1873                                r_icache_clack_way.read(),
     1874                                r_icache_clack_set.read(),
     1875                                CACHE_SLOT_STATE_EMPTY);
     1876
     1877            if ( (r_icache_miss_set.read() == r_icache_clack_set.read()) and
     1878                 (r_icache_miss_way.read() == r_icache_clack_way.read()) )
     1879            {
     1880                r_icache_miss_clack = false;
     1881            }
     1882
     1883            r_icache_clack_req = false;
     1884
     1885            // return to cc_save state if no pending CC request
     1886            if ( not r_cc_receive_icache_req.read() )
     1887                r_icache_fsm = r_icache_fsm_save.read();
    18821888
    18831889#if DEBUG_ICACHE
     
    18851891{
    18861892    std::cout << "  <PROC " << name()
    1887               << " ICACHE_CC_INVAL> slot returns to empty state"
    1888               << " set = " << r_icache_cc_set.read()
    1889               << " / way = " << r_icache_cc_way.read() << std::endl;
     1893        << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
     1894        << " set = " << r_icache_clack_set.read()
     1895        << " / way = " << r_icache_clack_way.read() << std::endl;
    18901896}
    18911897#endif
     1898
     1899            break;
     1900        }
     1901
     1902        // wait if pending request to CC_SEND. This way if there are pending
     1903        // CLACK they can be treated in this state and then a deadlock
     1904        // situation is avoided
     1905        if ( r_icache_cc_send_req.read() ) break;
     1906
     1907        // CC request handler
     1908
     1909        int             state = 0;
     1910        size_t      way = 0;
     1911        size_t      set = 0;
     1912        size_t      word = 0;
    18921913
    18931914#ifdef INSTRUMENTATION
    18941915m_cpt_icache_dir_read++;
    18951916#endif
    1896         if (r_icache_cc_need_write.read())
    1897         {
    1898             r_icache.write_dir( 0,
    1899                                     r_icache_cc_way.read(),
    1900                                     r_icache_cc_set.read(),
    1901                                 CACHE_SLOT_STATE_EMPTY );
    1902             // no need to write in the cache anymore
    1903             r_icache_cc_need_write = false;
    1904         }
    1905 
    1906         // multicast acknowledgement
    1907         // send a request to cc_send_fsm
    1908         if(not r_icache_cc_send_req.read()) // cc_send is available
    1909         {
    1910             // coherence request completed
    1911             r_cc_receive_icache_req = false;
    1912             // request multicast acknowledgement
    1913             r_icache_cc_send_req = true;
    1914             r_icache_cc_send_nline = r_cc_receive_icache_nline.read();
    1915             r_icache_cc_send_updt_tab_idx = r_cc_receive_icache_updt_tab_idx.read();
    1916             r_icache_cc_send_type = CC_TYPE_MULTI_ACK;
    1917 
    1918             r_icache_fsm          = r_icache_fsm_save.read();
    1919         }
    1920         //else wait for previous cc_send request to be sent
     1917        r_icache.read_dir(paddr,
     1918                          &state,
     1919                          &way,
     1920                          &set,
     1921                          &word);
     1922
     1923        r_icache_cc_way = way;
     1924        r_icache_cc_set = set;
     1925
     1926        if ( state == CACHE_SLOT_STATE_VALID)            // hit
     1927        {
     1928            // need to update the cache state
     1929            if (r_cc_receive_icache_type.read() == CC_TYPE_UPDT)  // hit update
     1930            {
     1931                r_icache_cc_need_write = true;
     1932                r_icache_fsm           = ICACHE_CC_UPDT;
     1933                r_icache_cc_word       = r_cc_receive_word_idx.read();
     1934            }
     1935            else if ( r_cc_receive_icache_type.read() == CC_TYPE_INVAL ) // hit inval
     1936            {
     1937                r_icache_fsm           = ICACHE_CC_INVAL;
     1938            }
     1939        }
     1940        else                                      // miss
     1941        {
     1942            // multicast acknowledgement required in case of update
     1943            if(r_cc_receive_icache_type.read() == CC_TYPE_UPDT)
     1944            {
     1945                r_icache_fsm           = ICACHE_CC_UPDT;
     1946                r_icache_cc_word       = r_cc_receive_word_idx.read();
     1947
     1948                // just pop the fifo , don't write in icache
     1949                r_icache_cc_need_write = false;
     1950            }
     1951            else // No response needed
     1952            {
     1953                r_cc_receive_icache_req = false;
     1954                r_icache_fsm            = r_icache_fsm_save.read();
     1955            }
     1956        }
     1957        break;
     1958    }
     1959    /////////////////////
     1960    case ICACHE_CC_INVAL:       // hit inval : switch slot to ZOMBI state
     1961    {
     1962        assert (not r_icache_cc_send_req.read() &&
     1963                "ERROR in ICACHE_CC_INVAL: the r_icache_cc_send_req "
     1964                "must not be set");
     1965
     1966#ifdef INSTRUMENTATION
     1967m_cpt_icache_dir_read++;
     1968#endif
     1969
     1970        // Switch slot state to ZOMBI and send CLEANUP command
     1971        r_icache.write_dir( 0,
     1972                            r_icache_cc_way.read(),
     1973                            r_icache_cc_set.read(),
     1974                            CACHE_SLOT_STATE_ZOMBI );
     1975
     1976        // coherence request completed
     1977        r_icache_cc_send_req   = true;
     1978        r_icache_cc_send_nline = r_cc_receive_icache_nline.read();
     1979        r_icache_cc_send_way   = r_icache_cc_way.read();
     1980        r_icache_cc_send_type  = CC_TYPE_CLEANUP;
     1981
     1982        r_icache_fsm           = r_icache_fsm_save.read();
     1983
     1984#if DEBUG_ICACHE
     1985if ( m_debug_activated )
     1986{
     1987std::cout << "  <PROC " << name()
     1988          << " ICACHE_CC_INVAL> slot returns to ZOMBI state"
     1989          << " set = " << r_icache_cc_set.read()
     1990          << " / way = " << r_icache_cc_way.read() << std::endl;
     1991}
     1992#endif
     1993
    19211994        break;
    19221995    }
     
    19241997    case ICACHE_CC_UPDT:        // hit update : write one word per cycle
    19251998    {
     1999        assert (not r_icache_cc_send_req.read() &&
     2000                "ERROR in ICACHE_CC_UPDT: the r_icache_cc_send_req "
     2001                "must not be set");
     2002
     2003        if ( not r_cc_receive_updt_fifo_be.rok() ) break;
     2004
     2005
     2006        size_t  word  = r_icache_cc_word.read();
     2007        size_t  way   = r_icache_cc_way.read();
     2008        size_t  set   = r_icache_cc_set.read();
     2009
     2010        if (r_icache_cc_need_write.read())
     2011        {
     2012            r_icache.write( way,
     2013                            set,
     2014                            word,
     2015                            r_cc_receive_updt_fifo_data.read(),
     2016                            r_cc_receive_updt_fifo_be.read() );
     2017
     2018            r_icache_cc_word = word+1;
     2019
     2020#ifdef INSTRUMENTATION
     2021m_cpt_icache_data_write++;
     2022#endif
    19262023
    19272024#if DEBUG_ICACHE
     
    19352032}
    19362033#endif
    1937 
    1938 #ifdef INSTRUMENTATION
    1939 m_cpt_icache_data_write++;
    1940 #endif
    1941         size_t  word  = r_icache_cc_word.read();
    1942         size_t  way   = r_icache_cc_way.read();
    1943         size_t  set   = r_icache_cc_set.read();
    1944 
    1945         if (r_cc_receive_updt_fifo_be.rok())
    1946         {
    1947             if (r_icache_cc_need_write.read())
    1948             {
    1949                 r_icache.write( way,
    1950                                 set,
    1951                                 word,
    1952                                 r_cc_receive_updt_fifo_data.read(),
    1953                                 r_cc_receive_updt_fifo_be.read() );
    1954 
    1955                 r_icache_cc_word = word+1;
    1956             }
    1957             if ( r_cc_receive_updt_fifo_eop.read() )    // last word
    1958             {
    1959                 // no need to write in the cache anymore
    1960                 r_icache_cc_need_write = false;
    1961                 // wait to send a request to cc_send_fsm
    1962                 if(not r_icache_cc_send_req.read()) // cc_send is available
    1963                 {
    1964                     //consume last flit
    1965                     cc_receive_updt_fifo_get  = true;
    1966                     // coherence request completed
    1967                     r_cc_receive_icache_req = false;
    1968                     // request multicast acknowledgement
    1969                     r_icache_cc_send_req = true;
    1970                     r_icache_cc_send_nline = r_cc_receive_icache_nline.read();
    1971                     r_icache_cc_send_updt_tab_idx = r_cc_receive_icache_updt_tab_idx.read();
    1972                     r_icache_cc_send_type = CC_TYPE_MULTI_ACK;
    1973 
    1974                     r_icache_fsm          = r_icache_fsm_save.read();
    1975                 }
    1976             }
    1977             else
    1978             {
    1979                 //consume fifo if not eop
    1980                 cc_receive_updt_fifo_get  = true;
    1981             }
    1982         }
     2034        }
     2035
     2036        if ( r_cc_receive_updt_fifo_eop.read() )        // last word
     2037        {
     2038            // no need to write in the cache anymore
     2039            r_icache_cc_need_write        = false;
     2040
     2041            // coherence request completed
     2042            r_cc_receive_icache_req       = false;
     2043
     2044            // request multicast acknowledgement
     2045            r_icache_cc_send_req          = true;
     2046            r_icache_cc_send_nline        = r_cc_receive_icache_nline.read();
     2047            r_icache_cc_send_updt_tab_idx = r_cc_receive_icache_updt_tab_idx.read();
     2048            r_icache_cc_send_type         = CC_TYPE_MULTI_ACK;
     2049
     2050            r_icache_fsm                  = r_icache_fsm_save.read();
     2051        }
     2052        //consume fifo if not eop
     2053        cc_receive_updt_fifo_get  = true;
     2054
    19832055        break;
    19842056    }
    1985     /////////////////////////
    1986     case ICACHE_CC_BROADCAST:  // hit broadcast : switch slot to ZOMBI state
    1987                                // and request a cleanup
    1988     {
    1989 
    1990 #if DEBUG_ICACHE
    1991 if ( m_debug_activated )
    1992 {
    1993     std::cout << "  <PROC " << name()
    1994               << " ICACHE_CC_BROADCAST > Slot goes to zombi state "
    1995               << " set = " << r_icache_cc_set.read()
    1996               << " / way = " << r_icache_cc_way.read() << std::endl;
    1997 }
    1998 #endif
    1999 
    2000 #ifdef INSTRUMENTATION
    2001 m_cpt_icache_dir_write++;
    2002 #endif
    2003         if (r_icache_cc_need_write.read())
    2004         {
    2005             r_icache.write_dir( r_icache_cc_way.read(),
    2006                                     r_icache_cc_set.read(),
    2007                                 CACHE_SLOT_STATE_ZOMBI );
    2008             // no need to write in the cache anymore
    2009             r_icache_cc_need_write = false;
    2010         }
    2011 
    2012         // cleanup
    2013         // send a request to cc_send_fsm
    2014         if(not r_icache_cc_send_req.read()) // cc_send is available
    2015         {
    2016             // coherence request completed
    2017             r_cc_receive_icache_req = false;
    2018             // request cleanup
    2019             r_icache_cc_send_req = true;
    2020             r_icache_cc_send_nline = r_cc_receive_icache_nline.read();
    2021             r_icache_cc_send_way   = r_icache_cc_way.read();
    2022             r_icache_cc_send_type  = CC_TYPE_CLEANUP;
    2023 
    2024             r_icache_fsm          = r_icache_fsm_save.read();
    2025         }
    2026         //else wait for previous cc_send request to be sent
    2027         break;
    2028     }
     2057
    20292058    } // end switch r_icache_fsm
    20302059
     
    23082337        }
    23092338
     2339        // coherence clack request (from DSPIN CLACK)
     2340        else if ( r_dcache_clack_req.read() )
     2341        {
     2342            r_dcache_fsm = DCACHE_CC_CHECK;
     2343            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     2344        }
    23102345        // coherence request (from CC_RECEIVE FSM)
    23112346        else if ( r_cc_receive_dcache_req.read() )
     
    29122947    case DCACHE_TLB_PTE1_GET:   // try to read a PT1 entry in dcache
    29132948    {
     2949        // coherence clack request (from DSPIN CLACK)
     2950        if ( r_dcache_clack_req.read() )
     2951        {
     2952            r_dcache_fsm = DCACHE_CC_CHECK;
     2953            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     2954            break;
     2955        }
     2956
    29142957        // coherence request (from CC_RECEIVE FSM)
    29152958        if ( r_cc_receive_dcache_req.read() )
     
    32093252    case DCACHE_TLB_PTE2_GET:   // Try to get a PTE2 (64 bits) in the dcache
    32103253    {
     3254        // coherence clack request (from DSPIN CLACK)
     3255        if ( r_dcache_clack_req.read() )
     3256        {
     3257            r_dcache_fsm = DCACHE_CC_CHECK;
     3258            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3259            break;
     3260        }
     3261
    32113262        // coherence request (from CC_RECEIVE FSM)
    32123263        if ( r_cc_receive_dcache_req.read() )
     
    35063557
    35073558    {
     3559        // coherence clack request (from DSPIN CLACK)
     3560        if ( r_dcache_clack_req.read() )
     3561        {
     3562            r_dcache_fsm = DCACHE_CC_CHECK;
     3563            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3564            break;
     3565        }
     3566
    35083567        // coherence request (from CC_RECEIVE FSM)
    35093568        if ( r_cc_receive_dcache_req.read() )
     
    35773636                                // as there is a risk of dead-lock
    35783637    {
     3638        // coherence clack request (from DSPIN CLACK)
     3639        if ( r_dcache_clack_req.read() )
     3640        {
     3641            r_dcache_fsm = DCACHE_CC_CHECK;
     3642            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3643            break;
     3644        }
     3645
    35793646        // coherence request (from CC_RECEIVE FSM)
    35803647        if ( r_cc_receive_dcache_req.read() )
     
    35823649            r_dcache_fsm = DCACHE_CC_CHECK;
    35833650            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3651            break;
    35843652        }
    35853653
     
    35983666                                    // and because it can exist a simultaneous ITLB miss
    35993667    {
     3668        // coherence clack request (from DSPIN CLACK)
     3669        if ( r_dcache_clack_req.read() )
     3670        {
     3671            r_dcache_fsm = DCACHE_CC_CHECK;
     3672            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3673            break;
     3674        }
     3675
    36003676        // coherence request (from CC_RECEIVE FSM)
    36013677        if ( r_cc_receive_dcache_req.read() )
     
    36333709                                // returns to IDLE and flush TLBs when last slot
    36343710    {
     3711        // coherence clack request (from DSPIN CLACK)
     3712        if ( r_dcache_clack_req.read() )
     3713        {
     3714            r_dcache_fsm = DCACHE_CC_CHECK;
     3715            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3716            break;
     3717        }
     3718
    36353719        // coherence request (from CC_RECEIVE FSM)
    36363720        if ( r_cc_receive_dcache_req.read() )
     
    38933977    {
    38943978        if ( m_dreq.valid) m_cost_data_miss_frz++;
     3979
     3980        // coherence clack request (from DSPIN CLACK)
     3981        if ( r_dcache_clack_req.read() )
     3982        {
     3983            r_dcache_fsm = DCACHE_CC_CHECK;
     3984            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     3985            break;
     3986        }
    38953987
    38963988        // coherence request (from CC_RECEIVE FSM)
     
    40094101    {
    40104102        if ( m_dreq.valid) m_cost_data_miss_frz++;
     4103
     4104        // coherence clack request (from DSPIN CLACK)
     4105        if ( r_dcache_clack_req.read() )
     4106        {
     4107            r_dcache_fsm = DCACHE_CC_CHECK;
     4108            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4109            break;
     4110        }
    40114111
    40124112        // coherence request (from CC_RECEIVE FSM)
     
    41254225        if ( m_dreq.valid) m_cost_data_miss_frz++;
    41264226
     4227        // coherence clack request (from DSPIN CLACK)
     4228        if ( r_dcache_clack_req.read() )
     4229        {
     4230            r_dcache_fsm = DCACHE_CC_CHECK;
     4231            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4232            break;
     4233        }
     4234
    41274235        // coherence request (from CC_RECEIVE FSM)
    41284236        if ( r_cc_receive_dcache_req.read() )
     
    41994307    case DCACHE_UNC_WAIT:  // waiting a response to an uncacheable read
    42004308    {
     4309        // coherence clack request (from DSPIN CLACK)
     4310        if ( r_dcache_clack_req.read() )
     4311        {
     4312            r_dcache_fsm = DCACHE_CC_CHECK;
     4313            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4314            break;
     4315        }
     4316
    42014317        // coherence request (from CC_RECEIVE FSM)
    42024318        if ( r_cc_receive_dcache_req.read() )
     
    42364352    case DCACHE_LL_WAIT:    // waiting VCI response to a LL transaction
    42374353    {
     4354        // coherence clack request (from DSPIN CLACK)
     4355        if ( r_dcache_clack_req.read() )
     4356        {
     4357            r_dcache_fsm = DCACHE_CC_CHECK;
     4358            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4359            break;
     4360        }
     4361
    42384362        // coherence request (from CC_RECEIVE FSM)
    42394363        if ( r_cc_receive_dcache_req.read() )
     
    42824406    case DCACHE_SC_WAIT:        // waiting VCI response to a SC transaction
    42834407    {
     4408        // coherence clack request (from DSPIN CLACK)
     4409        if ( r_dcache_clack_req.read() )
     4410        {
     4411            r_dcache_fsm = DCACHE_CC_CHECK;
     4412            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4413            break;
     4414        }
     4415
    42844416        // coherence request (from CC_RECEIVE FSM)
    42854417        if ( r_cc_receive_dcache_req.read() )
     
    43214453        size_t   way;
    43224454        size_t   set;
    4323         size_t   word;  // unused
     4455        size_t   word; // unused
    43244456        int      state;
    43254457
     
    43744506                                    // - if the CAS is a failure, we just retry the write.
    43754507    {
     4508        // coherence clack request (from DSPIN CLACK)
     4509        if ( r_dcache_clack_req.read() )
     4510        {
     4511            r_dcache_fsm = DCACHE_CC_CHECK;
     4512            r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4513            break;
     4514        }
     4515
    43764516        // coherence request (from CC_RECEIVE FSM)
    43774517        if ( r_cc_receive_dcache_req.read() )
     
    43824522        }
    43834523
    4384         if ( r_vci_rsp_data_error.read() )      // bus error
     4524        if ( r_vci_rsp_data_error.read() )      // bus error
    43854525        {
    43864526            std::cout << "BUS ERROR in DCACHE_DIRTY_WAIT state" << std::endl;
     
    43884528            exit(0);
    43894529        }
    4390         else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
     4530        else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
    43914531        {
    43924532            vci_rsp_fifo_dcache_get = true;
     
    44324572#endif
    44334573
    4434         if (r_cc_receive_dcache_type.read() == CC_TYPE_CLACK)
    4435                             // We switch the directory slot to EMPTY state
    4436                             // and reset r_icache_miss_clack if the cleanup ack
    4437                             // is matching a pending miss.
    4438         {
    4439 
    4440             if ( m_dreq.valid ) m_cost_data_miss_frz++;
    4441 
    4442 #ifdef INSTRUMENTATION
    4443 m_cpt_dcache_dir_write++;
    4444 #endif
    4445             r_dcache.write_dir( 0,
    4446                                 r_cc_receive_dcache_way.read(),
    4447                                 r_cc_receive_dcache_set.read(),
    4448                                 CACHE_SLOT_STATE_EMPTY);
    4449 
    4450             if ( (r_dcache_miss_set.read() == r_cc_receive_dcache_set.read()) and
    4451                  (r_dcache_miss_way.read() == r_cc_receive_dcache_way.read()) )
    4452                   r_dcache_miss_clack = false;
    4453 
    4454             r_dcache_fsm = r_dcache_fsm_cc_save.read() ;
    4455             r_cc_receive_dcache_req = false;
    4456 #if DEBUG_DCACHE
    4457 if ( m_debug_activated )
    4458 {
    4459     std::cout << "  <PROC " << name()
    4460               << " DCACHE_CC_CHECK> CC_TYPE_CLACK Switch slot to EMPTY state"
    4461               << " set = " << r_cc_receive_dcache_set.read()
    4462               << " / way = " << r_cc_receive_dcache_way.read() << std::endl;
    4463 }
    4464 #endif
    4465         }
    4466         else if( ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT) or
    4467                   (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT) or
    4468                   (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT)) and
    4469                   ((r_dcache_vci_paddr.read() & mask) == (paddr & mask)) ) // matching
     4574       
     4575        // Match between MISS address and CC address
     4576        // note: In the same cycle we can handle a CLACK and a MISS match
     4577        // because the CLACK access the directory but the MISS match dont.
     4578        if (r_cc_receive_dcache_req.read() and
     4579          ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT  )  or
     4580           (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT    )  or
     4581           (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT)) and
     4582          ((r_dcache_vci_paddr.read() & mask) == (paddr & mask))) // matching
    44704583        {
    44714584            // signaling matching
     
    44784591                r_dcache_fsm        = DCACHE_CC_UPDT;
    44794592                r_dcache_cc_word    = r_cc_receive_word_idx.read();
     4593
    44804594                // just pop the fifo , don't write in icache
    44814595                r_dcache_cc_need_write = false;
     
    44854599            {
    44864600                r_cc_receive_dcache_req = false;
    4487                 r_dcache_fsm          = r_dcache_fsm_cc_save.read();
     4601                r_dcache_fsm            = r_dcache_fsm_cc_save.read();
    44884602            }
    44894603
     
    44964610}
    44974611#endif
    4498 
    4499         }
    4500         else                                                    // no match
    4501             {
    4502             int        state = 0;
    4503             size_t         way = 0;
    4504             size_t         set = 0;
    4505             size_t         word = 0;
     4612        }
     4613
     4614        // CLACK handler
     4615        // We switch the directory slot to EMPTY state and reset
     4616        // r_dcache_miss_clack if the cleanup ack is matching a pending miss.
     4617        if ( r_dcache_clack_req.read() )
     4618        {
     4619            if ( m_dreq.valid ) m_cost_data_miss_frz++;
     4620
     4621#ifdef INSTRUMENTATION
     4622m_cpt_dcache_dir_write++;
     4623#endif
     4624            r_dcache.write_dir( 0,
     4625                                r_dcache_clack_way.read(),
     4626                                r_dcache_clack_set.read(),
     4627                                CACHE_SLOT_STATE_EMPTY);
     4628
     4629            if ( (r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
     4630                 (r_dcache_miss_way.read() == r_dcache_clack_way.read()) )
     4631            {
     4632                  r_dcache_miss_clack = false;
     4633            }
     4634
     4635            r_dcache_clack_req = false;
     4636
     4637            // return to cc_save state if no pending CC request
     4638            if ( not r_cc_receive_dcache_req.read() )
     4639            {
     4640                r_dcache_fsm = r_dcache_fsm_cc_save.read() ;
     4641            }
     4642
     4643#if DEBUG_DCACHE
     4644if ( m_debug_activated )
     4645{
     4646    std::cout << "  <PROC " << name()
     4647              << " DCACHE_CC_CHECK> CC_TYPE_CLACK Switch slot to EMPTY state"
     4648              << " set = " << r_dcache_clack_set.read()
     4649              << " / way = " << r_dcache_clack_way.read() << std::endl;
     4650}
     4651#endif
     4652            break;
     4653        }
     4654
     4655        // wait if pending request to CC_SEND. This way if there are pending
     4656        // CLACK they can be treated in this state and then a deadlock
     4657        // situation is avoided
     4658        if ( r_dcache_cc_send_req.read() ) break;
     4659
     4660        // CC request handler
     4661       
     4662        int    state = 0;
     4663        size_t way   = 0;
     4664        size_t set   = 0;
     4665        size_t word  = 0;
    45064666
    45074667#ifdef INSTRUMENTATION
    45084668m_cpt_dcache_dir_read++;
    45094669#endif
    4510             r_dcache.read_dir( paddr,
    4511                                &state,
    4512                                &way,
    4513                                &set,
    4514                                &word ); // unused
    4515 
    4516             r_dcache_cc_way = way;
    4517             r_dcache_cc_set = set;
    4518 
    4519             if ( state == CACHE_SLOT_STATE_VALID)            // hit
    4520             {
    4521                 // need to update the cache state
     4670        r_dcache.read_dir( paddr,
     4671                           &state,
     4672                           &way,
     4673                           &set,
     4674                           &word ); // unused
     4675
     4676        r_dcache_cc_way = way;
     4677        r_dcache_cc_set = set;
     4678
     4679        if ( state == CACHE_SLOT_STATE_VALID) // hit
     4680        {
     4681            // need to update the cache state
     4682            if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT) // hit update
     4683            {
    45224684                r_dcache_cc_need_write = true;
    4523                 if (r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)  // hit update
    4524                 {
    4525                     r_dcache_fsm          = DCACHE_CC_UPDT;
    4526                     r_dcache_cc_word      = r_cc_receive_word_idx.read();
    4527                 }
    4528                 else if (r_cc_receive_dcache_type.read() == CC_TYPE_INVAL)   // hit inval
    4529                 {
    4530                     r_dcache_fsm          = DCACHE_CC_INVAL;
    4531                 }
    4532                 else if ( r_cc_receive_dcache_type.read() == CC_TYPE_BRDCAST)  // hit broadcast
    4533                 {
    4534                     r_dcache_fsm          = DCACHE_CC_BROADCAST;
    4535                 }
    4536             }
    4537             else                                      // miss
    4538             {
    4539                 // multicast acknowledgement required in case of update
    4540                 if(r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
    4541                 {
    4542                     r_dcache_fsm          = DCACHE_CC_UPDT;
    4543                     r_dcache_cc_word      = r_cc_receive_word_idx.read();
    4544                     // just pop the fifo , don't write in icache
    4545                     r_dcache_cc_need_write = false;
    4546                 }
    4547                 else // No response needed
    4548                 {
    4549                     r_cc_receive_dcache_req = false;
    4550                     r_dcache_fsm          = r_dcache_fsm_cc_save.read();
    4551                 }
    4552             }
     4685                r_dcache_fsm           = DCACHE_CC_UPDT;
     4686                r_dcache_cc_word       = r_cc_receive_word_idx.read();
     4687            }
     4688            else if ( r_cc_receive_dcache_type.read() == CC_TYPE_INVAL ) // hit inval
     4689            {
     4690                r_dcache_fsm           = DCACHE_CC_INVAL;
     4691            }
     4692        }
     4693        else                                  // miss
     4694        {
     4695            // multicast acknowledgement required in case of update
     4696            if(r_cc_receive_dcache_type.read() == CC_TYPE_UPDT)
     4697            {
     4698                r_dcache_fsm           = DCACHE_CC_UPDT;
     4699                r_dcache_cc_word       = r_cc_receive_word_idx.read();
     4700
     4701                // just pop the fifo , don't write in icache
     4702                r_dcache_cc_need_write = false;
     4703            }
     4704            else // No response needed
     4705            {
     4706                r_cc_receive_dcache_req = false;
     4707                r_dcache_fsm            = r_dcache_fsm_cc_save.read();
     4708            }
     4709        }
    45534710
    45544711#if DEBUG_DCACHE
     
    45624719}
    45634720#endif
    4564         }
     4721
    45654722        break;
    45664723    }
    45674724    /////////////////////
    4568     case DCACHE_CC_INVAL:       // hit inval: switch slot to EMPTY state,
    4569                                 // after possible invalidation of copies in TLBs
    4570     {
    4571         size_t   way    = r_dcache_cc_way.read();
    4572         size_t   set    = r_dcache_cc_set.read();
    4573 
    4574         if (r_dcache_cc_need_write.read())
    4575         {
    4576             if ( r_dcache_in_tlb[way*m_dcache_sets+set] )                       // selective TLB inval
    4577             {
    4578                 r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4579                 r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
    4580                 r_dcache_tlb_inval_set   = 0;
    4581                 r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    4582                 r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    4583                 break;
    4584             }
    4585             else
    4586             {
    4587                 if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )     // TLB flush
    4588                 {
    4589                     r_itlb.reset();
    4590                     r_dtlb.reset();
    4591                     r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4725    case DCACHE_CC_INVAL: // hit inval: switch slot to ZOMBI state and send a
     4726                          // CLEANUP after possible invalidation of copies in
     4727                          // TLBs
     4728    {
     4729        size_t way    = r_dcache_cc_way.read();
     4730        size_t set    = r_dcache_cc_set.read();
     4731
     4732        if ( r_dcache_in_tlb[way*m_dcache_sets+set] )       // selective TLB inval
     4733        {
     4734            r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     4735            r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
     4736            r_dcache_tlb_inval_set   = 0;
     4737            r_dcache_fsm_scan_save   = r_dcache_fsm.read();
     4738            r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
     4739            break;
     4740        }
     4741
     4742        if ( r_dcache_contains_ptd[way*m_dcache_sets+set] ) // TLB flush
     4743        {
     4744            r_itlb.reset();
     4745            r_dtlb.reset();
     4746            r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    45924747
    45934748#if DEBUG_DCACHE
     
    45984753}
    45994754#endif
    4600                 }
    4601 
    4602                 r_dcache.write_dir( 0,
    4603                                     way,
    4604                                     set,
    4605                                     CACHE_SLOT_STATE_EMPTY );
    4606 
    4607                 r_dcache_cc_need_write = false;
     4755        }
     4756
     4757        assert (not r_dcache_cc_send_req.read() &&
     4758                "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
     4759                "must not be set");
     4760
     4761        // Switch slot state to ZOMBI and send CLEANUP command
     4762        r_dcache.write_dir( 0,
     4763                            way,
     4764                            set,
     4765                            CACHE_SLOT_STATE_ZOMBI );
     4766
     4767        // coherence request completed
     4768        r_cc_receive_dcache_req = false;
     4769        r_dcache_cc_send_req    = true;
     4770        r_dcache_cc_send_nline  = r_cc_receive_dcache_nline.read();
     4771        r_dcache_cc_send_way    = r_dcache_cc_way.read();
     4772        r_dcache_cc_send_type   = CC_TYPE_CLEANUP;
     4773        r_dcache_fsm            = r_dcache_fsm_cc_save.read();
    46084774
    46094775#if DEBUG_DCACHE
     
    46114777{
    46124778    std::cout << "  <PROC " << name()
    4613               << " DCACHE_CC_INVAL> Switch slot to EMPTY state:" << std::dec
    4614               << " / WAY = " << way
    4615               << " / SET = " << set << std::endl;
     4779        << " DCACHE_CC_INVAL> Switch slot to EMPTY state:" << std::dec
     4780        << " / WAY = " << way
     4781        << " / SET = " << set << std::endl;
    46164782}
    46174783#endif
    4618             }
    4619         }
    4620         // multicast acknowledgement
    4621         // send a request to cc_send_fsm
    4622         if(not r_dcache_cc_send_req.read()) // cc_send is available
    4623         {
    4624             // coherence request completed
    4625             r_cc_receive_dcache_req = false;
    4626             // request multicast acknowledgement
    4627             r_dcache_cc_send_req = true;
    4628             r_dcache_cc_send_nline = r_cc_receive_dcache_nline.read();
    4629             r_dcache_cc_send_updt_tab_idx = r_cc_receive_dcache_updt_tab_idx.read();
    4630             r_dcache_cc_send_type = CC_TYPE_MULTI_ACK;
    4631 
    4632             r_dcache_fsm          = r_dcache_fsm_cc_save.read();
    4633         }
    4634         //else wait for previous cc_send request to be sent
    46354784        break;
    46364785    }
    46374786    ///////////////////
    4638     case DCACHE_CC_UPDT:        // hit update: write one word per cycle,
     4787    case DCACHE_CC_UPDT:        // hit update: write one word per cycle,
    46394788                                // after possible invalidation of copies in TLBs
    46404789    {
    4641         size_t   word       = r_dcache_cc_word.read();
    4642         size_t   way        = r_dcache_cc_way.read();
    4643         size_t   set        = r_dcache_cc_set.read();
    4644 
    4645         if (r_cc_receive_updt_fifo_be.rok())
    4646         {
    4647             if (r_dcache_cc_need_write.read())
    4648             {
    4649                 if ( r_dcache_in_tlb[way*m_dcache_sets+set] )                   // selective TLB inval
    4650                 {
    4651                     r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4652                     r_dcache_tlb_inval_line  = r_cc_receive_dcache_nline.read();
    4653                     r_dcache_tlb_inval_set   = 0;
    4654                     r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    4655                     r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    4656                     break;
    4657                 }
    4658 
    4659                 if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )     // TLB flush
    4660                 {
    4661                     r_itlb.reset();
    4662                     r_dtlb.reset();
    4663                     r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
     4790        size_t word       = r_dcache_cc_word.read();
     4791        size_t way        = r_dcache_cc_way.read();
     4792        size_t set        = r_dcache_cc_set.read();
     4793
     4794        if ( r_dcache_in_tlb[way*m_dcache_sets+set] )       // selective TLB inval
     4795        {
     4796            r_dcache_in_tlb[way*m_dcache_sets+set] = false;
     4797            r_dcache_tlb_inval_line = r_cc_receive_dcache_nline.read();
     4798            r_dcache_tlb_inval_set  = 0;
     4799            r_dcache_fsm_scan_save  = r_dcache_fsm.read();
     4800            r_dcache_fsm            = DCACHE_INVAL_TLB_SCAN;
     4801
     4802            break;
     4803        }
     4804
     4805        if ( r_dcache_contains_ptd[way*m_dcache_sets+set] ) // TLB flush
     4806        {
     4807            r_itlb.reset();
     4808            r_dtlb.reset();
     4809            r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    46644810
    46654811#if DEBUG_DCACHE
     
    46704816}
    46714817#endif
    4672                 }
    4673 
     4818        }
     4819
     4820        assert (not r_dcache_cc_send_req.read() &&
     4821                "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
     4822                "must not be set");
     4823       
     4824        if ( not r_cc_receive_updt_fifo_be.rok() ) break;
     4825
     4826        if (r_dcache_cc_need_write.read())
     4827        {
     4828       
    46744829#ifdef INSTRUMENTATION
    46754830m_cpt_dcache_data_write++;
    46764831#endif
    4677                 r_dcache.write( way,
    4678                                 set,
    4679                                 word,
    4680                                 r_cc_receive_updt_fifo_data.read(),
    4681                                 r_cc_receive_updt_fifo_be.read() );
    4682 
    4683                 r_dcache_cc_word = word + 1;
     4832            r_dcache.write( way,
     4833                            set,
     4834                            word,
     4835                            r_cc_receive_updt_fifo_data.read(),
     4836                            r_cc_receive_updt_fifo_be.read() );
     4837
     4838            r_dcache_cc_word = word + 1;
    46844839
    46854840#if DEBUG_DCACHE
     
    46944849}
    46954850#endif
    4696             }
    4697 
    4698             if ( r_cc_receive_updt_fifo_eop.read() )    // last word
    4699             {
    4700                 // no need to write in the cache anymore
    4701                 r_dcache_cc_need_write = false;
    4702 
    4703                 // wait to send a request to cc_send_fsm
    4704                 if(not r_dcache_cc_send_req.read())
    4705                 // cc_send is available
    4706                 {
    4707                     //consume last fifo flit if eop and request to cc_send possible
    4708                     cc_receive_updt_fifo_get  = true;
    4709 
    4710                     // coherence request completed
    4711                     r_cc_receive_dcache_req = false;
    4712 
    4713                     // request multicast acknowledgement
    4714                     r_dcache_cc_send_req = true;
    4715                     r_dcache_cc_send_nline = r_cc_receive_dcache_nline.read();
    4716                     r_dcache_cc_send_updt_tab_idx = r_cc_receive_dcache_updt_tab_idx.read();
    4717                     r_dcache_cc_send_type = CC_TYPE_MULTI_ACK;
    4718 
    4719                     r_dcache_fsm          = r_dcache_fsm_cc_save.read();
    4720                 }
    4721             }
    4722             else
    4723             {
    4724                 //consume fifo if not eop
    4725                 cc_receive_updt_fifo_get  = true;
    4726             }
    4727         }
    4728         break;
    4729     }
    4730     /////////////////////////
    4731     case DCACHE_CC_BROADCAST:   // hit broadcast : switch state to ZOMBI state
    4732                                 // and request a cleanup, after possible
    4733                                 // invalidation of copies in TLBs
    4734     {
    4735         size_t   way   = r_dcache_cc_way.read();
    4736         size_t   set   = r_dcache_cc_set.read();
    4737         paddr_t  nline = r_cc_receive_dcache_nline.read();
    4738 
    4739         if (r_dcache_cc_need_write.read())
    4740         {
    4741             if ( r_dcache_in_tlb[way*m_dcache_sets+set] )                       // selective TLB inval
    4742             {
    4743                 r_dcache_in_tlb[way*m_dcache_sets+set] = false;
    4744                 r_dcache_tlb_inval_line  = nline;
    4745                 r_dcache_tlb_inval_set   = 0;
    4746                 r_dcache_fsm_scan_save   = r_dcache_fsm.read();
    4747                 r_dcache_fsm             = DCACHE_INVAL_TLB_SCAN;
    4748                 break;
    4749             }
    4750             else
    4751             {
    4752                 if ( r_dcache_contains_ptd[way*m_dcache_sets+set] )     // TLB flush
    4753                 {
    4754                     r_itlb.reset();
    4755                     r_dtlb.reset();
    4756                     r_dcache_contains_ptd[way*m_dcache_sets+set] = false;
    4757 
    4758 #if DEBUG_DCACHE
    4759 if ( m_debug_activated )
    4760 {
    4761     std::cout << "  <PROC " << name()
    4762               << " DCACHE_CC_BROADCAST> Flush DTLB & ITLB" << std::endl;
    4763 }
    4764 #endif
    4765                 }
    4766 
    4767 #ifdef INSTRUMENTATION
    4768 m_cpt_dcache_dir_write++;
    4769 #endif
    4770                 r_dcache.write_dir( way,
    4771                                     set,
    4772                                     CACHE_SLOT_STATE_ZOMBI );
    4773 
    4774                 r_dcache_cc_need_write = false;
    4775 #if DEBUG_DCACHE
    4776 if ( m_debug_activated )
    4777 {
    4778     std::cout << "  <PROC " << name()
    4779               << " DCACHE_CC_BROADCAST > Slot goes to ZOMBI state "
    4780               << " SET = " << set
    4781               << " / WAY = " << way << std::endl;
    4782 }
    4783 #endif
    4784             }
    4785         }
    4786         // cleanup
    4787         // send a request to cc_send_fsm
    4788         if(not r_dcache_cc_send_req.read()) // cc_send is available
    4789         {
     4851        }
     4852
     4853        if ( r_cc_receive_updt_fifo_eop.read() )  // last word
     4854        {
     4855            // no need to write in the cache anymore
     4856            r_dcache_cc_need_write = false;
     4857
    47904858            // coherence request completed
    47914859            r_cc_receive_dcache_req = false;
    4792             // request cleanup
    4793             r_dcache_cc_send_req = true;
    4794             r_dcache_cc_send_nline = r_cc_receive_dcache_nline.read();
    4795             r_dcache_cc_send_way   = r_dcache_cc_way.read();
    4796             r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
    4797 
    4798             r_dcache_fsm          = r_dcache_fsm_cc_save.read();
    4799         }
    4800         //else wait for previous cc_send request to be sent
     4860
     4861            // request multicast acknowledgement
     4862            r_dcache_cc_send_req          = true;
     4863            r_dcache_cc_send_nline        = r_cc_receive_dcache_nline.read();
     4864            r_dcache_cc_send_updt_tab_idx = r_cc_receive_dcache_updt_tab_idx.read();
     4865            r_dcache_cc_send_type         = CC_TYPE_MULTI_ACK;
     4866
     4867            r_dcache_fsm                  = r_dcache_fsm_cc_save.read();
     4868        }
     4869
     4870        //consume fifo if not eop
     4871        cc_receive_updt_fifo_get  = true;
     4872
    48014873        break;
    48024874    }
     
    53895461        {
    53905462            // wait for the first flit to be consumed
    5391             if (p_dspin_out.read.read())
     5463            if (p_dspin_p2m.read.read())
    53925464                r_cc_send_fsm = CC_SEND_CLEANUP_2;
    53935465
     
    53985470        {
    53995471            // wait for the second flit to be consumed
    5400             if (p_dspin_out.read.read())
     5472            if (p_dspin_p2m.read.read())
    54015473            {
    54025474                if (r_cc_send_last_client.read() == 0) // dcache active request
     
    54145486        {
    54155487            // wait for the flit to be consumed
    5416             if(p_dspin_out.read.read())
     5488            if(p_dspin_p2m.read.read())
    54175489            {
    54185490                if(r_cc_send_last_client.read() == 0) // dcache active request
     
    54285500
    54295501    ///////////////////////////////////////////////////////////////////////////////
    5430     //   C_RECEIVE  FSM
     5502    //  CC_RECEIVE  FSM
    54315503    // This FSM receive all coherence packets on a DSPIN40 port.
    5432     // There is 7 packet types:
     5504    // There is 5 packet types:
    54335505    // - CC_DATA_INVAL : DCACHE invalidate request
    54345506    // - CC_DATA_UPDT  : DCACHE update request (multi-words)
     
    54365508    // - CC_INST_UPDT  : ICACHE update request (multi-words)
    54375509    // - CC_BROADCAST  : Broadcast invalidate request (both DCACHE & ICACHE)
    5438     // - CC_DATA_CLACK : DCACHE cleanup acknowledge
    5439     // - CC_INST_CLACK : ICACHE cleanup acknowledge
    54405510    //////////////////////////////////////////////////////////////////////////////
    54415511    switch( r_cc_receive_fsm.read() )
     
    54455515        {
    54465516            // a coherence request has arrived
    5447             if (p_dspin_in.write.read())
     5517            if (p_dspin_m2p.write.read())
    54485518            {
    54495519                // initialize dspin received data
    5450                 uint64_t receive_data = p_dspin_in.data.read();
     5520                uint64_t receive_data = p_dspin_m2p.data.read();
    54515521                // initialize coherence packet type
    54525522                uint64_t receive_type = DspinDhccpParam::dspin_get(receive_data,
    5453                                             DspinDhccpParam::FROM_MC_TYPE);
    5454                 // initialize data/ins flip_flop (0 data / 1 ins)
    5455                 r_cc_receive_data_ins = (bool)(receive_type & 0x1);
     5523                                            DspinDhccpParam::M2P_TYPE);
    54565524                // test for a broadcast
    5457                 if (DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::FROM_MC_BC))
     5525                if (DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::M2P_BC))
    54585526                {
    54595527                    r_cc_receive_fsm = CC_RECEIVE_BRDCAST_HEADER;
    54605528                }
    5461                 // test for a CLACK
    5462                 else if ((receive_type == DspinDhccpParam::TYPE_CLEANUP_ACK_DATA) or
    5463                          (receive_type == DspinDhccpParam::TYPE_CLEANUP_ACK_INST))
     5529                // test for a multi updt
     5530                else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA)
    54645531                {
    5465                     r_cc_receive_fsm = CC_RECEIVE_CLACK;
     5532                    r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_HEADER;
    54665533                }
    5467                 // test for a multi updt
    5468                 else if ((receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA) or
    5469                          (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_INST))
     5534                else if (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_INST)
    54705535                {
    5471                     r_cc_receive_fsm = CC_RECEIVE_UPDT_HEADER;
     5536                    r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_HEADER;
    54725537                }
    54735538                // test for a multi inval
     5539                else if (receive_type == DspinDhccpParam::TYPE_MULTI_INVAL_DATA)
     5540                {
     5541                    r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_HEADER;
     5542                }
    54745543                else
    54755544                {
    5476                     r_cc_receive_fsm = CC_RECEIVE_INVAL_HEADER;
     5545                    r_cc_receive_fsm = CC_RECEIVE_INS_INVAL_HEADER;
    54775546                }
    54785547            }
    5479             break;
    5480         }
    5481         //////////////////////
    5482         case CC_RECEIVE_CLACK:
    5483         {
    5484             // initialize dspin received data
    5485             uint64_t receive_data = p_dspin_in.data.read();
    5486 
    5487             // for data CLACK, wait for dcache to take the request
    5488             if ((r_cc_receive_data_ins.read() == 0) and
    5489                    not (r_cc_receive_dcache_req.read()))
    5490             {
    5491                 // request dcache to handle the CLACK
    5492                 r_cc_receive_dcache_req  = true;
    5493                 r_cc_receive_dcache_set  = DspinDhccpParam::dspin_get(receive_data,
    5494                                            DspinDhccpParam::CLEANUP_ACK_SET) &
    5495                                            ((1ULL<<(uint32_log2(m_dcache_sets)))-1);
    5496                 r_cc_receive_dcache_way  = DspinDhccpParam::dspin_get(receive_data,
    5497                                            DspinDhccpParam::CLEANUP_ACK_WAY) &
    5498                                            ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
    5499                 r_cc_receive_dcache_type = CC_TYPE_CLACK;
    5500                 // get back to idle state
    5501                 r_cc_receive_fsm = CC_RECEIVE_IDLE;
    5502                 break;
    5503             }
    5504             // for ins CLACK, wait for icache to take the request
    5505             if ((r_cc_receive_data_ins.read() == 1) and
    5506                    not (r_cc_receive_icache_req.read()))
    5507             {
    5508                 // request icache to handle the CLACK
    5509                 r_cc_receive_icache_req  = true;
    5510                 r_cc_receive_icache_set  = DspinDhccpParam::dspin_get(receive_data,
    5511                                            DspinDhccpParam::CLEANUP_ACK_SET) &
    5512                                            ((1ULL<<(uint32_log2(m_icache_sets)))-1);
    5513                 r_cc_receive_icache_way  = DspinDhccpParam::dspin_get(receive_data,
    5514                                            DspinDhccpParam::CLEANUP_ACK_WAY) &
    5515                                            ((1ULL<<(uint32_log2(m_icache_ways)))-1);
    5516                 r_cc_receive_icache_type = CC_TYPE_CLACK;
    5517                 // get back to idle state
    5518                 r_cc_receive_fsm = CC_RECEIVE_IDLE;
    5519                 break;
    5520             }
    5521             // keep waiting for the correct cache to accept the request
    55225548            break;
    55235549        }
     
    55335559        {
    55345560            // initialize dspin received data
    5535             uint64_t receive_data = p_dspin_in.data.read();
     5561            uint64_t receive_data = p_dspin_m2p.data.read();
    55365562            // wait for both dcache and icache to take the request
    55375563            // TODO maybe we need to wait for both only to leave the state, but
     
    55405566            if (not (r_cc_receive_icache_req.read()) and
    55415567                not (r_cc_receive_dcache_req.read()) and
    5542                 (p_dspin_in.write.read()))
     5568                (p_dspin_m2p.write.read()))
    55435569            {
    55445570                // request dcache to handle the BROADCAST
    5545                 r_cc_receive_dcache_req  = true;
     5571                r_cc_receive_dcache_req = true;
    55465572                r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,
    55475573                                             DspinDhccpParam::BROADCAST_NLINE);
    5548                 r_cc_receive_dcache_type = CC_TYPE_BRDCAST;
     5574                r_cc_receive_dcache_type = CC_TYPE_INVAL;
    55495575                // request icache to handle the BROADCAST
    5550                 r_cc_receive_icache_req  = true;
     5576                r_cc_receive_icache_req = true;
    55515577                r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,
    55525578                                             DspinDhccpParam::BROADCAST_NLINE);
    5553                 r_cc_receive_icache_type = CC_TYPE_BRDCAST;
     5579                r_cc_receive_icache_type = CC_TYPE_INVAL;
    55545580                // get back to idle state
    55555581                r_cc_receive_fsm = CC_RECEIVE_IDLE;
     
    55605586        }
    55615587        /////////////////////////////
    5562         case CC_RECEIVE_INVAL_HEADER:
     5588        case CC_RECEIVE_DATA_INVAL_HEADER:
    55635589        {
    55645590            // sample updt tab index in the HEADER, then skip to second flit
    5565             uint64_t receive_data = p_dspin_in.data.read();
     5591            r_cc_receive_fsm = CC_RECEIVE_DATA_INVAL_NLINE;
     5592            break;
     5593        }
     5594        /////////////////////////////
     5595        case CC_RECEIVE_INS_INVAL_HEADER:
     5596        {
     5597            // sample updt tab index in the HEADER, then skip to second flit
     5598            r_cc_receive_fsm = CC_RECEIVE_INS_INVAL_NLINE;
     5599            break;
     5600        }
     5601        ////////////////////////////
     5602        case CC_RECEIVE_DATA_INVAL_NLINE:
     5603        {
     5604            // sample nline in the second flit
     5605            uint64_t receive_data = p_dspin_m2p.data.read();
    55665606            // for data INVAL, wait for dcache to take the request
    5567             if ((r_cc_receive_data_ins.read() == 0) and
    5568                  not (r_cc_receive_dcache_req.read()))
    5569             {
    5570                 r_cc_receive_dcache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,
    5571                                                    DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
    5572                 r_cc_receive_fsm = CC_RECEIVE_INVAL_NLINE;
    5573                 break;
    5574             }
    5575             // for ins INVAL, wait for icache to take the request
    5576             if ((r_cc_receive_data_ins.read() == 1) and
    5577                  not (r_cc_receive_icache_req.read()))
    5578             {
    5579                 r_cc_receive_icache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,
    5580                                                    DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
    5581                 r_cc_receive_fsm = CC_RECEIVE_INVAL_NLINE;
    5582                 break;
    5583             }
    5584             // keep waiting for the correct cache to accept the request
    5585             break;
    5586         }
    5587         ////////////////////////////
    5588         case CC_RECEIVE_INVAL_NLINE:
    5589         {
    5590             // sample nline in the second flit
    5591             uint64_t receive_data = p_dspin_in.data.read();
    5592             // for data INVAL, wait for dcache to take the request
    5593             if ( (r_cc_receive_data_ins.read() == 0) and
    5594                  not (r_cc_receive_dcache_req.read()) and
    5595                  (p_dspin_in.write.read()) )
     5607            if (p_dspin_m2p.write.read() and not r_cc_receive_dcache_req.read())
    55965608            {
    55975609                // request dcache to handle the INVAL
    5598                 r_cc_receive_dcache_req  = true;
    5599                 r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
     5610                r_cc_receive_dcache_req = true;
     5611                r_cc_receive_dcache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
    56005612                r_cc_receive_dcache_type = CC_TYPE_INVAL;
    56015613                // get back to idle state
     
    56035615                break;
    56045616            }
     5617            break;
     5618        }
     5619        //////////////////////////////
     5620        case CC_RECEIVE_INS_INVAL_NLINE:
     5621        {
     5622            // sample nline in the second flit
     5623            uint64_t receive_data = p_dspin_m2p.data.read();
    56055624            // for ins INVAL, wait for icache to take the request
    5606             if ((r_cc_receive_data_ins.read() == 1) and not (r_cc_receive_icache_req.read()) and (p_dspin_in.write.read()))
     5625            if (p_dspin_m2p.write.read() and not r_cc_receive_icache_req.read())
    56075626            {
    56085627                // request icache to handle the INVAL
    5609                 r_cc_receive_icache_req  = true;
    5610                 r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
     5628                r_cc_receive_icache_req = true;
     5629                r_cc_receive_icache_nline = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
    56115630                r_cc_receive_icache_type = CC_TYPE_INVAL;
    56125631                // get back to idle state
     
    56145633                break;
    56155634            }
    5616             // we should never get there
    5617             assert ( false && "ERROR in CC_VCACHE : CC_RECEIVE_INVAL_NLINE\n");
     5635            break;
    56185636        }
    56195637        ////////////////////////////
    5620         case CC_RECEIVE_UPDT_HEADER:
     5638        case CC_RECEIVE_DATA_UPDT_HEADER:
    56215639        {
    56225640            // sample updt tab index in the HEADER, than skip to second flit
    5623             uint64_t receive_data = p_dspin_in.data.read();
     5641            uint64_t receive_data = p_dspin_m2p.data.read();
    56245642            // for data INVAL, wait for dcache to take the request and fifo to
    56255643            // be empty
    5626             if ((r_cc_receive_data_ins.read() == 0) and not r_cc_receive_dcache_req.read() and r_cc_receive_updt_fifo_be.empty())
     5644            if (not r_cc_receive_dcache_req.read())
    56275645            {
    56285646                r_cc_receive_dcache_updt_tab_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
    5629                 r_cc_receive_fsm = CC_RECEIVE_UPDT_NLINE;
     5647                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_NLINE;
    56305648                break;
    56315649            }
     5650            break;
     5651        }
     5652        ////////////////////////////
     5653        case CC_RECEIVE_INS_UPDT_HEADER:
     5654        {
     5655            // sample updt tab index in the HEADER, than skip to second flit
     5656            uint64_t receive_data = p_dspin_m2p.data.read();
    56325657            // for ins INVAL, wait for icache to take the request and fifo to be
    56335658            // empty
    5634             if ((r_cc_receive_data_ins.read() == 1) and not r_cc_receive_icache_req.read() and r_cc_receive_updt_fifo_be.empty())
     5659            if (not r_cc_receive_icache_req.read())
    56355660            {
    56365661                r_cc_receive_icache_updt_tab_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
    5637                 r_cc_receive_fsm = CC_RECEIVE_UPDT_NLINE;
     5662                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_NLINE;
    56385663                break;
    56395664            }
     
    56425667        }
    56435668        ///////////////////////////
    5644         case CC_RECEIVE_UPDT_NLINE:
     5669        case CC_RECEIVE_DATA_UPDT_NLINE:
    56455670        {
    56465671            // sample nline and word index in the second flit
    5647             uint64_t receive_data = p_dspin_in.data.read();
     5672            uint64_t receive_data = p_dspin_m2p.data.read();
    56485673            // for data INVAL, wait for dcache to take the request and fifo to
    56495674            // be empty
    5650             if ( (r_cc_receive_data_ins.read() == 0) and
    5651                  not (r_cc_receive_dcache_req.read()) and
    5652                  r_cc_receive_updt_fifo_be.empty() and
    5653                  (p_dspin_in.write.read()) )
    5654             {
     5675            if ( r_cc_receive_updt_fifo_be.empty() and
     5676                 p_dspin_m2p.write.read() )
     5677            {
     5678                r_cc_receive_dcache_req = true;
    56555679                r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
    56565680                r_cc_receive_word_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
    56575681                r_cc_receive_dcache_type = CC_TYPE_UPDT;
    56585682                // get back to idle state
    5659                 r_cc_receive_fsm = CC_RECEIVE_UPDT_DATA;
     5683                r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_DATA;
    56605684                break;
    56615685            }
     5686            break;
     5687        }
     5688        ////////////////////////////
     5689        case CC_RECEIVE_INS_UPDT_NLINE:
     5690        {
     5691            // sample nline and word index in the second flit
     5692            uint64_t receive_data = p_dspin_m2p.data.read();
    56625693            // for ins INVAL, wait for icache to take the request and fifo to be
    56635694            // empty
    5664             if ( (r_cc_receive_data_ins.read() == 1) and
    5665                  not (r_cc_receive_icache_req.read()) and
    5666                  r_cc_receive_updt_fifo_be.empty() and
    5667                  (p_dspin_in.write.read()))
    5668             {
     5695            if ( r_cc_receive_updt_fifo_be.empty() and
     5696                 p_dspin_m2p.write.read() )
     5697            {
     5698                r_cc_receive_icache_req = true;
    56695699                r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
    56705700                r_cc_receive_word_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
    56715701                r_cc_receive_icache_type = CC_TYPE_UPDT;
    56725702                // get back to idle state
    5673                 r_cc_receive_fsm = CC_RECEIVE_UPDT_DATA;
     5703                r_cc_receive_fsm = CC_RECEIVE_INS_UPDT_DATA;
    56745704                break;
    56755705            }
    5676             // we should never get there
    5677             assert ( false && "ERROR in CC_VCACHE : CC_RECEIVE_UPDT_NLINE \n");
    56785706            break;
    56795707        }
    56805708        //////////////////////////
    5681         case CC_RECEIVE_UPDT_DATA:
    5682         {
    5683             if ((r_cc_receive_data_ins.read() == 0) and not (r_cc_receive_dcache_req.read()) and (p_dspin_in.write.read()))
    5684                 r_cc_receive_dcache_req = true;
    5685             if ((r_cc_receive_data_ins.read() == 1) and not (r_cc_receive_icache_req.read()) and (p_dspin_in.write.read()))
    5686                 r_cc_receive_icache_req = true;
    5687 
     5709        case CC_RECEIVE_DATA_UPDT_DATA:
     5710        {
    56885711            // wait for the fifo
    5689             if (r_cc_receive_updt_fifo_be.wok() and (p_dspin_in.write.read()))
    5690             {
    5691                 uint64_t receive_data = p_dspin_in.data.read();
    5692                 bool     receive_eop  = p_dspin_in.eop.read();
     5712            if (r_cc_receive_updt_fifo_be.wok() and (p_dspin_m2p.write.read()))
     5713            {
     5714                uint64_t receive_data = p_dspin_m2p.data.read();
     5715                bool     receive_eop  = p_dspin_m2p.eop.read();
    56935716                cc_receive_updt_fifo_be   = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE);
    56945717                cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA);
     
    56995722            break;
    57005723        }
     5724        //////////////////////////
     5725        case CC_RECEIVE_INS_UPDT_DATA:
     5726        {
     5727            // wait for the fifo
     5728            if (r_cc_receive_updt_fifo_be.wok() and (p_dspin_m2p.write.read()))
     5729            {
     5730                uint64_t receive_data = p_dspin_m2p.data.read();
     5731                bool     receive_eop  = p_dspin_m2p.eop.read();
     5732                cc_receive_updt_fifo_be   = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE);
     5733                cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA);
     5734                cc_receive_updt_fifo_eop  = receive_eop;
     5735                cc_receive_updt_fifo_put  = true;
     5736                if ( receive_eop ) r_cc_receive_fsm = CC_RECEIVE_IDLE;
     5737            }
     5738            break;
     5739        }
     5740
    57015741    } // end switch CC_RECEIVE FSM
     5742
     5743    ///////////////// DSPIN CLACK interface ///////////////
     5744   
     5745    uint64_t clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
     5746                                                     DspinDhccpParam::CLACK_TYPE);
     5747
     5748    size_t clack_way  = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
     5749                                                   DspinDhccpParam::CLACK_WAY);
     5750
     5751    size_t clack_set  = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
     5752                                                   DspinDhccpParam::CLACK_SET);
     5753
     5754    bool dspin_clack_get      = false;
     5755    bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA);
     5756    bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST);
     5757
     5758    if (r_dspin_clack_req.read())
     5759    {
     5760        // CLACK DATA: Send request to DCACHE FSM
     5761        if (dcache_clack_request and not r_dcache_clack_req.read()){
     5762            r_dcache_clack_req = true;
     5763            r_dcache_clack_way = clack_way & ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
     5764            r_dcache_clack_set = clack_set & ((1ULL<<(uint32_log2(m_dcache_sets)))-1);
     5765            dspin_clack_get    = true;
     5766        }
     5767
     5768        // CLACK INST: Send request to ICACHE FSM
     5769        else if (icache_clack_request and not r_icache_clack_req.read()){
     5770            r_icache_clack_req = true;
     5771            r_icache_clack_way = clack_way & ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
     5772            r_icache_clack_set = clack_set & ((1ULL<<(uint32_log2(m_icache_sets)))-1);
     5773            dspin_clack_get    = true;
     5774        }
     5775    }
     5776    else
     5777    {
     5778        dspin_clack_get = true;
     5779    }
     5780
     5781    if (dspin_clack_get)
     5782    {
     5783        r_dspin_clack_req  = p_dspin_clack.write.read();
     5784        r_dspin_clack_flit = p_dspin_clack.data.read();
     5785    }
    57025786
    57035787    ///////////////// Response FIFOs update  //////////////////////
     
    58975981        case CC_SEND_IDLE:
    58985982        {
    5899             p_dspin_out.write = false;
     5983            p_dspin_p2m.write = false;
    59005984            break;
    59015985        }
     
    59065990//            DspinDhccpParam::dspin_set(dspin_send_data,
    59075991//                                       0,
    5908 //                                       DspinDhccpParam::FROM_L1_EOP);
     5992//                                       DspinDhccpParam::P2M_EOP);
    59095993            DspinDhccpParam::dspin_set(dspin_send_data,
    59105994                                       m_cc_global_id,
     
    59125996            DspinDhccpParam::dspin_set(dspin_send_data,
    59135997                                       0,
    5914                                        DspinDhccpParam::FROM_L1_BC);
     5998                                       DspinDhccpParam::P2M_BC);
    59155999
    59166000            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    59346018                DspinDhccpParam::dspin_set(dspin_send_data,
    59356019                                           DspinDhccpParam::TYPE_CLEANUP_DATA,
    5936                                            DspinDhccpParam::FROM_L1_TYPE);
     6020                                           DspinDhccpParam::P2M_TYPE);
    59376021            }
    59386022            else                                // icache active request
     
    59566040                DspinDhccpParam::dspin_set(dspin_send_data,
    59576041                                           DspinDhccpParam::TYPE_CLEANUP_INST,
    5958                                            DspinDhccpParam::FROM_L1_TYPE);
     6042                                           DspinDhccpParam::P2M_TYPE);
    59596043            }
    59606044            // send flit
    5961             p_dspin_out.data  = dspin_send_data;
    5962             p_dspin_out.write = true;
    5963             p_dspin_out.eop   = false;
     6045            p_dspin_p2m.data  = dspin_send_data;
     6046            p_dspin_p2m.write = true;
     6047            p_dspin_p2m.eop   = false;
    59646048            break;
    59656049        }
     
    59706054//            DspinDhccpParam::dspin_set(dspin_send_data,
    59716055//                                       1,
    5972 //                                       DspinDhccpParam::FROM_L1_EOP);
     6056//                                       DspinDhccpParam::P2M_EOP);
    59736057
    59746058            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    59856069            }
    59866070            // send flit
    5987             p_dspin_out.data  = dspin_send_data;
    5988             p_dspin_out.write = true;
    5989             p_dspin_out.eop   = true;
     6071            p_dspin_p2m.data  = dspin_send_data;
     6072            p_dspin_p2m.write = true;
     6073            p_dspin_p2m.eop   = true;
    59906074            break;
    59916075        }
     
    59966080//            DspinDhccpParam::dspin_set(dspin_send_data,
    59976081//                                       1,
    5998 //                                       DspinDhccpParam::FROM_L1_EOP);
     6082//                                       DspinDhccpParam::P2M_EOP);
    59996083            DspinDhccpParam::dspin_set(dspin_send_data,
    60006084                                       0,
    6001                                        DspinDhccpParam::FROM_L1_BC);
     6085                                       DspinDhccpParam::P2M_BC);
    60026086            DspinDhccpParam::dspin_set(dspin_send_data,
    60036087                                       DspinDhccpParam::TYPE_MULTI_ACK,
    6004                                        DspinDhccpParam::FROM_L1_TYPE);
     6088                                       DspinDhccpParam::P2M_TYPE);
    60056089
    60066090            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    60346118            }
    60356119            // send flit
    6036             p_dspin_out.data  = dspin_send_data;
    6037             p_dspin_out.write = true;
    6038             p_dspin_out.eop   = true;
     6120            p_dspin_p2m.data  = dspin_send_data;
     6121            p_dspin_p2m.write = true;
     6122            p_dspin_p2m.eop   = true;
    60396123
    60406124            break;
     
    60446128    // Receive coherence packets
    60456129    // It depends on the CC_RECEIVE FSM
    6046 
    60476130    switch( r_cc_receive_fsm.read() )
    60486131    {
     
    60506133        case CC_RECEIVE_IDLE:
    60516134        {
    6052             p_dspin_in.read = false;
    6053             break;
    6054         }
    6055         //////////////////////
    6056         case CC_RECEIVE_CLACK:
    6057         {
    6058             if (((r_cc_receive_data_ins.read() == 0) and not (r_cc_receive_dcache_req.read())) or
    6059                 ((r_cc_receive_data_ins.read() == 1) and not (r_cc_receive_icache_req.read())))
    6060                 p_dspin_in.read = true;
    6061             else
    6062                 p_dspin_in.read = false;
     6135            p_dspin_m2p.read = false;
    60636136            break;
    60646137        }
     
    60666139        case CC_RECEIVE_BRDCAST_HEADER:
    60676140        {
    6068             p_dspin_in.read = true;
     6141            p_dspin_m2p.read = true;
    60696142            break;
    60706143        }
     
    60766149            // flip_flop to check that ?
    60776150            if (not (r_cc_receive_icache_req.read()) and not (r_cc_receive_dcache_req.read()))
    6078                 p_dspin_in.read = true;
     6151                p_dspin_m2p.read = true;
    60796152            else
    6080                 p_dspin_in.read = false;
     6153                p_dspin_m2p.read = false;
    60816154            break;
    60826155        }
    60836156        /////////////////////////////
    6084         case CC_RECEIVE_INVAL_HEADER:
    6085         {
    6086             if (((r_cc_receive_data_ins.read() == 0) and not (r_cc_receive_dcache_req.read())) or
    6087                 ((r_cc_receive_data_ins.read() == 1) and not (r_cc_receive_icache_req.read())))
    6088                 p_dspin_in.read = true;
     6157        case CC_RECEIVE_DATA_INVAL_HEADER:
     6158        case CC_RECEIVE_INS_INVAL_HEADER:
     6159        {
     6160            p_dspin_m2p.read = true;
     6161            break;
     6162        }
     6163        ////////////////////////////
     6164        case CC_RECEIVE_DATA_INVAL_NLINE:
     6165        {
     6166            p_dspin_m2p.read = not r_cc_receive_dcache_req.read();
     6167            break;
     6168        }
     6169        case CC_RECEIVE_INS_INVAL_NLINE:
     6170        {
     6171            p_dspin_m2p.read = not r_cc_receive_icache_req.read();
     6172            break;
     6173        }
     6174        ///////////////////////////
     6175        case CC_RECEIVE_DATA_UPDT_HEADER:
     6176        {
     6177            if (not r_cc_receive_dcache_req.read())
     6178                p_dspin_m2p.read = true;
    60896179            else
    6090                 p_dspin_in.read = false;
     6180                p_dspin_m2p.read = false;
    60916181            break;
    60926182        }
    60936183        ////////////////////////////
    6094         case CC_RECEIVE_INVAL_NLINE:
    6095         {
    6096             p_dspin_in.read = true;
    6097             break;
    6098         }
    6099         ////////////////////////////
    6100         case CC_RECEIVE_UPDT_HEADER:
    6101         {
    6102             if (((r_cc_receive_data_ins.read() == 0) and
    6103                 not r_cc_receive_dcache_req.read() and
    6104                 r_cc_receive_updt_fifo_be.empty())
    6105                 or
    6106                 (((r_cc_receive_data_ins.read() == 1) and
    6107                 not r_cc_receive_icache_req.read()) and
    6108                 r_cc_receive_updt_fifo_be.empty()))
    6109                 p_dspin_in.read = true;
     6184        case CC_RECEIVE_INS_UPDT_HEADER:
     6185        {
     6186            if ( not r_cc_receive_icache_req.read())
     6187                p_dspin_m2p.read = true;
    61106188            else
    6111                 p_dspin_in.read = false;
     6189                p_dspin_m2p.read = false;
    61126190            break;
    61136191        }
    61146192        ///////////////////////////
    6115         case CC_RECEIVE_UPDT_NLINE:
    6116         {
    6117             if (((r_cc_receive_data_ins.read() == 0) and
    6118                 not (r_cc_receive_dcache_req.read()) and
    6119                 r_cc_receive_updt_fifo_be.empty())
    6120                 or
    6121                 ((r_cc_receive_data_ins.read() == 1) and
    6122                 not (r_cc_receive_icache_req.read()) and
    6123                 r_cc_receive_updt_fifo_be.empty()))
    6124                 p_dspin_in.read = true;
     6193        case CC_RECEIVE_DATA_UPDT_NLINE:
     6194        case CC_RECEIVE_INS_UPDT_NLINE:
     6195        {
     6196            if(r_cc_receive_updt_fifo_be.empty())
     6197                p_dspin_m2p.read = true;
    61256198            else
    6126                 p_dspin_in.read = false;
    6127             break;
    6128         }
    6129         //////////////////////////
    6130         case CC_RECEIVE_UPDT_DATA:
     6199                p_dspin_m2p.read = false;
     6200            break;
     6201        }
     6202        ///////////////////////////
     6203        case CC_RECEIVE_DATA_UPDT_DATA:
     6204        case CC_RECEIVE_INS_UPDT_DATA:
    61316205        {
    61326206            if (r_cc_receive_updt_fifo_be.wok())
    6133                 p_dspin_in.read = true;
     6207                p_dspin_m2p.read = true;
    61346208            else
    6135                 p_dspin_in.read = false;
     6209                p_dspin_m2p.read = false;
    61366210            break;
    61376211        }
    61386212    } // end switch CC_RECEIVE FSM
    61396213
     6214
     6215    int clack_type = DspinDhccpParam::dspin_get(r_dspin_clack_flit.read(),
     6216                                                DspinDhccpParam::CLACK_TYPE);
     6217
     6218    bool dspin_clack_get      = false;
     6219    bool dcache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_DATA);
     6220    bool icache_clack_request = (clack_type == DspinDhccpParam::TYPE_CLACK_INST);
     6221
     6222    if (r_dspin_clack_req.read())
     6223    {
     6224        // CLACK DATA: wait if pending request to DCACHE FSM
     6225        if (dcache_clack_request and not r_dcache_clack_req.read())
     6226        {
     6227            dspin_clack_get = true;
     6228        }
     6229
     6230        // CLACK INST: wait if pending request to ICACHE FSM
     6231        else if (icache_clack_request and not r_icache_clack_req.read())
     6232        {
     6233            dspin_clack_get = true;
     6234        }
     6235    }
     6236    else
     6237    {
     6238        dspin_clack_get = true;
     6239    }
     6240
     6241    p_dspin_clack.read = dspin_clack_get;
    61406242} // end genMoore
    61416243
  • trunk/modules/vci_mem_cache

  • trunk/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd

    r434 r468  
    4949            Port('caba:vci_initiator', 'p_vci_ixr'),
    5050            Port('caba:dspin_input',
    51                 'p_dspin_in',
     51                'p_dspin_p2m',
    5252                dspin_data_size = parameter.Reference('dspin_in_width')
    5353            ),
    5454            Port('caba:dspin_output',
    55                 'p_dspin_out',
     55                'p_dspin_m2p',
     56                dspin_data_size = parameter.Reference('dspin_out_width')
     57            ),
     58            Port('caba:dspin_output',
     59                'p_dspin_clack',
    5660                dspin_data_size = parameter.Reference('dspin_out_width')
    5761            ),
  • trunk/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r449 r468  
    5454#define TRT_ENTRIES      4      // Number of entries in TRT
    5555#define UPT_ENTRIES      4      // Number of entries in UPT
     56#define IVT_ENTRIES      4      // Number of entries in IVT
    5657#define HEAP_ENTRIES     1024   // Number of entries in HEAP
    5758
     
    122123        CC_SEND_WRITE_IDLE,
    123124        CC_SEND_CAS_IDLE,
    124         CC_SEND_CLEANUP_IDLE,
    125125        CC_SEND_CONFIG_INVAL_HEADER,
    126126        CC_SEND_CONFIG_INVAL_NLINE,
    127127        CC_SEND_CONFIG_BRDCAST_HEADER,
    128128        CC_SEND_CONFIG_BRDCAST_NLINE,
    129         CC_SEND_CLEANUP_ACK,
    130129        CC_SEND_XRAM_RSP_BRDCAST_HEADER,
    131130        CC_SEND_XRAM_RSP_BRDCAST_NLINE,
     
    163162        CONFIG_DIR_REQ,
    164163        CONFIG_DIR_ACCESS,
    165         CONFIG_DIR_UPT_LOCK,
     164        CONFIG_DIR_IVT_LOCK,
    166165        CONFIG_BC_SEND,
    167166        CONFIG_BC_WAIT,
     
    211210        WRITE_MISS_XRAM_REQ,
    212211        WRITE_BC_TRT_LOCK,
    213         WRITE_BC_UPT_LOCK,
     212        WRITE_BC_IVT_LOCK,
    214213        WRITE_BC_DIR_INVAL,
    215214        WRITE_BC_CC_SEND,
     
    274273        CAS_UPT_NEXT,
    275274        CAS_BC_TRT_LOCK,
    276         CAS_BC_UPT_LOCK,
     275        CAS_BC_IVT_LOCK,
    277276        CAS_BC_DIR_INVAL,
    278277        CAS_BC_CC_SEND,
     
    299298        CLEANUP_HEAP_CLEAN,
    300299        CLEANUP_HEAP_FREE,
    301         CLEANUP_UPT_LOCK,
    302         CLEANUP_UPT_DECREMENT,
    303         CLEANUP_UPT_CLEAR,
     300        CLEANUP_IVT_LOCK,
     301        CLEANUP_IVT_DECREMENT,
     302        CLEANUP_IVT_CLEAR,
    304303        CLEANUP_WRITE_RSP,
    305304        CLEANUP_CONFIG_ACK,
     
    332331      enum alloc_upt_fsm_state_e
    333332      {
    334         ALLOC_UPT_CONFIG,
    335333        ALLOC_UPT_WRITE,
    336         ALLOC_UPT_XRAM_RSP,
    337         ALLOC_UPT_MULTI_ACK,
    338         ALLOC_UPT_CLEANUP,
    339         ALLOC_UPT_CAS
     334        ALLOC_UPT_CAS,
     335        ALLOC_UPT_MULTI_ACK
     336      };
     337
     338      /* States of the ALLOC_IVT fsm */
     339      enum alloc_ivt_fsm_state_e
     340      {
     341        ALLOC_IVT_WRITE,
     342        ALLOC_IVT_XRAM_RSP,
     343        ALLOC_IVT_CLEANUP,
     344        ALLOC_IVT_CAS,
     345        ALLOC_IVT_CONFIG
    340346      };
    341347
     
    451457      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
    452458      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
    453       soclib::caba::DspinInput<dspin_in_width>    p_dspin_in;
    454       soclib::caba::DspinOutput<dspin_out_width>  p_dspin_out;
     459      soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
     460      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
     461      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
    455462
    456463      VciMemCache(
     
    468475          const size_t                       trt_lines=TRT_ENTRIES,
    469476          const size_t                       upt_lines=UPT_ENTRIES,     
     477          const size_t                       ivt_lines=IVT_ENTRIES,     
    470478          const size_t                       debug_start_cycle=0,
    471479          const bool                         debug_ok=false );
     
    502510      TransactionTab                     m_trt;              // xram transaction table
    503511      uint32_t                           m_upt_lines;
    504       UpdateTab                          m_upt;              // pending update & invalidate
     512      UpdateTab                          m_upt;              // pending update
     513      UpdateTab                          m_ivt;              // pending invalidate
    505514      CacheDirectory                     m_cache_directory;  // data cache directory
    506515      CacheData                          m_cache_data;       // data array[set][way][word]
     
    591600      sc_signal<size_t>   r_config_heap_next;      // current pointer to scan HEAP
    592601
    593       sc_signal<size_t>   r_config_upt_index;  // UPT index
     602      sc_signal<size_t>   r_config_ivt_index;      // IVT index
    594603
    595604      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
     
    780789      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
    781790
    782       // Buffer between CLEANUP fsm and CC_SEND fsm (acknowledge a cleanup command from L1)
    783       sc_signal<bool>     r_cleanup_to_cc_send_req;       // valid request
    784       sc_signal<size_t>   r_cleanup_to_cc_send_srcid;     // L1 srcid
    785       sc_signal<size_t>   r_cleanup_to_cc_send_set_index; // L1 set index
    786       sc_signal<size_t>   r_cleanup_to_cc_send_way_index; // L1 way index
    787       sc_signal<bool>     r_cleanup_to_cc_send_inst;      // Instruction Cleanup Ack
    788 
    789791      ///////////////////////////////////////////////////////
    790792      // Registers controlled by CAS fsm
     
    872874      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
    873875      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
    874       sc_signal<size_t>   r_xram_rsp_upt_index;         // UPT entry index
     876      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
    875877      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
    876878
     
    953955
    954956      ////////////////////////////////////////////////////
     957      // Registers controlled by ALLOC_IVT fsm
     958      ////////////////////////////////////////////////////
     959
     960      sc_signal<int>      r_alloc_ivt_fsm;
     961
     962      ////////////////////////////////////////////////////
    955963      // Registers controlled by ALLOC_HEAP fsm
    956964      ////////////////////////////////////////////////////
  • trunk/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r449 r468  
    9999  "CC_SEND_WRITE_IDLE",
    100100  "CC_SEND_CAS_IDLE",
    101   "CC_SEND_CLEANUP_IDLE",
    102101  "CC_SEND_CONFIG_INVAL_HEADER",
    103102  "CC_SEND_CONFIG_INVAL_NLINE",
    104103  "CC_SEND_CONFIG_BRDCAST_HEADER",
    105104  "CC_SEND_CONFIG_BRDCAST_NLINE",
    106   "CC_SEND_CLEANUP_ACK",
    107105  "CC_SEND_XRAM_RSP_BRDCAST_HEADER",
    108106  "CC_SEND_XRAM_RSP_BRDCAST_NLINE",
     
    136134  "CONFIG_DIR_REQ",
    137135  "CONFIG_DIR_ACCESS",
    138   "CONFIG_DIR_UPT_LOCK",
     136  "CONFIG_DIR_IVT_LOCK",
    139137  "CONFIG_BC_SEND",
    140138  "CONFIG_BC_WAIT",
     
    180178  "WRITE_MISS_XRAM_REQ",
    181179  "WRITE_BC_TRT_LOCK",
    182   "WRITE_BC_UPT_LOCK",
     180  "WRITE_BC_IVT_LOCK",
    183181  "WRITE_BC_DIR_INVAL",
    184182  "WRITE_BC_CC_SEND",
     
    235233  "CAS_UPT_NEXT",
    236234  "CAS_BC_TRT_LOCK",
    237   "CAS_BC_UPT_LOCK",
     235  "CAS_BC_IVT_LOCK",
    238236  "CAS_BC_DIR_INVAL",
    239237  "CAS_BC_CC_SEND",
     
    258256  "CLEANUP_HEAP_CLEAN",
    259257  "CLEANUP_HEAP_FREE",
    260   "CLEANUP_UPT_LOCK",
    261   "CLEANUP_UPT_DECREMENT",
    262   "CLEANUP_UPT_CLEAR",
     258  "CLEANUP_IVT_LOCK",
     259  "CLEANUP_IVT_DECREMENT",
     260  "CLEANUP_IVT_CLEAR",
    263261  "CLEANUP_WRITE_RSP",
    264262  "CLEANUP_CONFIG_ACK",
     
    268266{
    269267  "ALLOC_DIR_RESET",
     268  "ALLOC_DIR_CONFIG",
    270269  "ALLOC_DIR_READ",
    271270  "ALLOC_DIR_WRITE",
     
    285284{
    286285  "ALLOC_UPT_WRITE",
    287   "ALLOC_UPT_XRAM_RSP",
    288   "ALLOC_UPT_MULTI_ACK",
    289   "ALLOC_UPT_CLEANUP",
    290   "ALLOC_UPT_CAS"
     286  "ALLOC_UPT_CAS",
     287  "ALLOC_UPT_MULTI_ACK"
     288};
     289const char *alloc_ivt_fsm_str[] =
     290{
     291  "ALLOC_IVT_WRITE",
     292  "ALLOC_IVT_XRAM_RSP",
     293  "ALLOC_IVT_CLEANUP",
     294  "ALLOC_IVT_CAS",
     295  "ALLOC_IVT_CONFIG"
    291296};
    292297const char *alloc_heap_fsm_str[] =
     
    328333  const size_t        trt_lines,         // number of TRT entries
    329334  const size_t        upt_lines,         // number of UPT entries
     335  const size_t        ivt_lines,         // number of IVT entries
    330336  const size_t        debug_start_cycle,
    331337  const bool          debug_ok)
     
    337343    p_vci_tgt( "p_vci_tgt" ),
    338344    p_vci_ixr( "p_vci_ixr" ),
    339     p_dspin_in( "p_dspin_in" ),
    340     p_dspin_out( "p_dspin_out" ),
     345    p_dspin_p2m( "p_dspin_p2m" ),
     346    p_dspin_m2p( "p_dspin_m2p" ),
     347    p_dspin_clack( "p_dspin_clack" ),
    341348
    342349    m_seglist( mtp.getSegmentList(tgtid_d) ),
     
    355362    m_upt_lines(upt_lines),
    356363    m_upt(upt_lines),
     364    m_ivt(ivt_lines),
    357365    m_cache_directory(nways, nsets, nwords, vci_param_int::N),
    358366    m_cache_data(nways, nsets, nwords),
     
    446454    r_alloc_trt_fsm("r_alloc_trt_fsm"),
    447455    r_alloc_upt_fsm("r_alloc_upt_fsm"),
     456    r_alloc_ivt_fsm("r_alloc_ivt_fsm"),
    448457    r_alloc_heap_fsm("r_alloc_heap_fsm"),
    449458    r_alloc_heap_reset_cpt("r_alloc_heap_reset_cpt")
     
    623632            << " | " << ixr_cmd_fsm_str[r_ixr_cmd_fsm.read()]
    624633            << " | " << ixr_rsp_fsm_str[r_ixr_rsp_fsm.read()]
    625             << " | " << xram_rsp_fsm_str[r_xram_rsp_fsm] << std::endl;
     634            << " | " << xram_rsp_fsm_str[r_xram_rsp_fsm.read()] << std::endl;
    626635  std::cout << "  "  << alloc_dir_fsm_str[r_alloc_dir_fsm.read()]
    627636            << " | " << alloc_trt_fsm_str[r_alloc_trt_fsm.read()]
    628637            << " | " << alloc_upt_fsm_str[r_alloc_upt_fsm.read()]
     638            << " | " << alloc_ivt_fsm_str[r_alloc_ivt_fsm.read()]
    629639            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
    630640}
     
    702712    r_alloc_trt_fsm  = ALLOC_TRT_READ;
    703713    r_alloc_upt_fsm  = ALLOC_UPT_WRITE;
     714    r_alloc_ivt_fsm  = ALLOC_IVT_XRAM_RSP;
    704715    r_ixr_rsp_fsm    = IXR_RSP_IDLE;
    705716    r_xram_rsp_fsm   = XRAM_RSP_IDLE;
     
    714725    m_trt.init();
    715726    m_upt.init();
     727    m_ivt.init();
    716728    m_llsc_table.init();
    717729
     
    15341546              r_config_dir_next_ptr   = entry.ptr;
    15351547
    1536               r_config_fsm    = CONFIG_DIR_UPT_LOCK;
     1548              r_config_fsm    = CONFIG_DIR_IVT_LOCK;
    15371549          }
    15381550          else if ( entry.valid and                       // hit & sync command
     
    15631575      }
    15641576      /////////////////////////
    1565       case CONFIG_DIR_UPT_LOCK:  // enter this state in case of INVAL command
    1566                                  // Try to get both DIR & UPT locks, and return
    1567                                  // to LOOP state if UPT full.
    1568                                  // Register inval in UPT, and invalidate the
    1569                                  // directory if UPT not full.
    1570       {
    1571           if ( r_alloc_upt_fsm.read() == ALLOC_UPT_CONFIG )
     1577      case CONFIG_DIR_IVT_LOCK:  // enter this state in case of INVAL command
     1578                                 // Try to get both DIR & IVT locks, and return
     1579                                 // to LOOP state if IVT full.
     1580                                 // Register inval in IVT, and invalidate the
     1581                                 // directory if IVT not full.
     1582      {
     1583          if ( r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG )
    15721584          {
    15731585              size_t set        = m_y[(addr_t)(r_config_address.read())];
     
    15831595#if DEBUG_MEMC_CONFIG
    15841596if(m_debug)
    1585 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
     1597std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
    15861598          << " No copies in L1 : inval DIR entry"  << std::endl;
    15871599#endif
    15881600              }
    1589               else    // try to register inval in UPT
     1601              else    // try to register inval in IVT
    15901602              {
    15911603                  bool        wok       = false;
     
    15981610                  size_t      nb_copies = r_config_dir_count.read();
    15991611
    1600                   wok = m_upt.set(false,       // it's an inval transaction
     1612                  wok = m_ivt.set(false,       // it's an inval transaction
    16011613                                  broadcast,   
    16021614                                  false,       // no response required
     
    16091621                                  index);
    16101622
    1611                   if ( wok )  // UPT success => inval DIR slot
     1623                  if ( wok )  // IVT success => inval DIR slot
    16121624                  {
    16131625                      m_cache_directory.inval( way, set );
    1614                       r_config_upt_index = index;
     1626                      r_config_ivt_index = index;
    16151627                      if ( broadcast )  r_config_fsm = CONFIG_BC_SEND;
    16161628                      else              r_config_fsm = CONFIG_INV_SEND;
     
    16181630#if DEBUG_MEMC_CONFIG
    16191631if(m_debug)
    1620 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1621           << " Inval DIR entry and register inval in UPT"
     1632std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1633          << " Inval DIR entry and register inval in IVT"
    16221634          << " : index = " << std::dec << index
    16231635          << " / broadcast = " << broadcast << std::endl;
    16241636#endif
    16251637                  }
    1626                   else       // UPT full => release both DIR and UPT locks
     1638                  else       // IVT full => release both DIR and IVT locks
    16271639                  {
    16281640                      r_config_fsm = CONFIG_LOOP;
     
    16301642#if DEBUG_MEMC_CONFIG
    16311643if(m_debug)
    1632 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1633           << " UPT full : release DIR & UPT locks and retry" << std::endl;
     1644std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1645          << " IVT full : release DIR & IVT locks and retry" << std::endl;
    16341646#endif
    16351647                  }
     
    16461658              r_config_to_cc_send_multi_req   = false;
    16471659              r_config_to_cc_send_brdcast_req = true;
    1648               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1660              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    16491661              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    16501662              r_cleanup_to_config_ack         = false;
     
    16861698              r_config_to_cc_send_multi_req   = true;
    16871699              r_config_to_cc_send_brdcast_req = false;
    1688               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1700              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    16891701              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    16901702              r_multi_ack_to_config_ack       = false;
     
    18481860  switch(r_read_fsm.read())
    18491861  {
    1850       ///////////////
    1851       case READ_IDLE:  // waiting a read request
    1852       {
     1862    ///////////////
     1863    case READ_IDLE:  // waiting a read request
     1864    {
    18531865      if(m_cmd_read_addr_fifo.rok())
    18541866      {
    18551867
    18561868#if DEBUG_MEMC_READ
    1857 if(m_debug)
    1858 std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
    1859           << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
    1860           << " / srcid = " << m_cmd_read_srcid_fifo.read()
    1861           << " / trdid = " << m_cmd_read_trdid_fifo.read()
    1862           << " / pktid = " << m_cmd_read_pktid_fifo.read()
    1863           << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
     1869        if(m_debug)
     1870          std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
     1871            << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
     1872            << " / srcid = " << m_cmd_read_srcid_fifo.read()
     1873            << " / trdid = " << m_cmd_read_trdid_fifo.read()
     1874            << " / pktid = " << m_cmd_read_pktid_fifo.read()
     1875            << " / nwords = " << std::dec << m_cmd_read_length_fifo.read() << std::endl;
    18641876#endif
    18651877        r_read_fsm = READ_DIR_REQ;
     
    19611973
    19621974    {
    1963         if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    1964         {
    1965             // check if this is an instruction read, this means pktid is either
    1966             // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
    1967             // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    1968             bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
    1969             // check if this is a cached read, this means pktid is either
    1970             // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
    1971             // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    1972             bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
    1973             bool is_cnt       = r_read_is_cnt.read();
    1974 
    1975             // read data in the cache
    1976             size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
    1977             size_t way        = r_read_way.read();
    1978 
    1979             m_cache_data.read_line(way, set, r_read_data);
    1980 
    1981             if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
    1982 
    1983             // update the cache directory
    1984             DirectoryEntry entry;
    1985             entry.valid   = true;
    1986             entry.is_cnt  = is_cnt;
    1987             entry.dirty   = r_read_dirty.read();
    1988             entry.tag     = r_read_tag.read();
    1989             entry.lock    = r_read_lock.read();
    1990             entry.ptr     = r_read_ptr.read();
    1991 
    1992             if(cached_read)   // Cached read => we must update the copies
    1993             {
    1994                 if(!is_cnt)  // Not counter mode
    1995                 {
    1996                     entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
     1975      if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     1976      {
     1977        // check if this is an instruction read, this means pktid is either
     1978        // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
     1979        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     1980        bool inst_read    = ((m_cmd_read_pktid_fifo.read() & 0x2) != 0);
     1981        // check if this is a cached read, this means pktid is either
     1982        // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
     1983        // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
     1984        bool cached_read  = (m_cmd_read_pktid_fifo.read() & 0x1);
     1985        bool is_cnt       = r_read_is_cnt.read();
     1986
     1987        // read data in the cache
     1988        size_t set        = m_y[(addr_t)(m_cmd_read_addr_fifo.read())];
     1989        size_t way        = r_read_way.read();
     1990
     1991        m_cache_data.read_line(way, set, r_read_data);
     1992
     1993        if(m_monitor_ok) check_monitor( m_cmd_read_addr_fifo.read(), r_read_data[0], true);
     1994
     1995        // update the cache directory
     1996        DirectoryEntry entry;
     1997        entry.valid   = true;
     1998        entry.is_cnt  = is_cnt;
     1999        entry.dirty   = r_read_dirty.read();
     2000        entry.tag     = r_read_tag.read();
     2001        entry.lock    = r_read_lock.read();
     2002        entry.ptr     = r_read_ptr.read();
     2003
     2004        if(cached_read)   // Cached read => we must update the copies
     2005        {
     2006          if(!is_cnt)  // Not counter mode
     2007          {
     2008            entry.owner.srcid    = m_cmd_read_srcid_fifo.read();
    19972009#if L1_MULTI_CACHE
    1998                     entry.owner.cache_id = m_cmd_read_pktid_fifo.read();
    1999 #endif
    2000                     entry.owner.inst     = inst_read;
    2001                     entry.count          = r_read_count.read() + 1;
    2002                 }
    2003                 else  // Counter mode
    2004                 {
    2005                     entry.owner.srcid    = 0;
     2010            entry.owner.cache_id = m_cmd_read_pktid_fifo.read();
     2011#endif
     2012            entry.owner.inst     = inst_read;
     2013            entry.count          = r_read_count.read() + 1;
     2014          }
     2015          else  // Counter mode
     2016          {
     2017            entry.owner.srcid    = 0;
    20062018#if L1_MULTI_CACHE
    2007                     entry.owner.cache_id = 0;
    2008 #endif
    2009                     entry.owner.inst     = false;
    2010                     entry.count          = r_read_count.read() + 1;
    2011                 }
    2012             }
    2013             else            // Uncached read
    2014             {
    2015                 entry.owner.srcid     = r_read_copy.read();
     2019            entry.owner.cache_id = 0;
     2020#endif
     2021            entry.owner.inst     = false;
     2022            entry.count          = r_read_count.read() + 1;
     2023          }
     2024        }
     2025        else            // Uncached read
     2026        {
     2027          entry.owner.srcid     = r_read_copy.read();
    20162028#if L1_MULTI_CACHE
    2017                 entry.owner.cache_id  = r_read_copy_cache.read();
    2018 #endif
    2019                 entry.owner.inst      = r_read_copy_inst.read();
    2020                 entry.count           = r_read_count.read();
    2021             }
     2029          entry.owner.cache_id  = r_read_copy_cache.read();
     2030#endif
     2031          entry.owner.inst      = r_read_copy_inst.read();
     2032          entry.count           = r_read_count.read();
     2033        }
    20222034
    20232035#if DEBUG_MEMC_READ
    2024 if(m_debug)
    2025 std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    2026           << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
    2027           << " / set = " << std::dec << set
    2028           << " / way = " << way
    2029           << " / owner_id = " << std::hex << entry.owner.srcid
    2030           << " / owner_ins = " << std::dec << entry.owner.inst
    2031           << " / count = " << entry.count
    2032           << " / is_cnt = " << entry.is_cnt << std::endl;
    2033 #endif
    2034 
    2035             m_cache_directory.write(set, way, entry);
    2036             r_read_fsm    = READ_RSP;
    2037         }
    2038         break;
     2036        if(m_debug)
     2037          std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
     2038            << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
     2039            << " / set = " << std::dec << set
     2040            << " / way = " << way
     2041            << " / owner_id = " << std::hex << entry.owner.srcid
     2042            << " / owner_ins = " << std::dec << entry.owner.inst
     2043            << " / count = " << entry.count
     2044            << " / is_cnt = " << entry.is_cnt << std::endl;
     2045#endif
     2046
     2047        m_cache_directory.write(set, way, entry);
     2048        r_read_fsm    = READ_RSP;
     2049      }
     2050      break;
    20392051    }
    20402052    ///////////////////
     
    27502762
    27512763        wok = m_upt.set(true,  // it's an update transaction
    2752                         false,    // it's not a broadcast
    2753                         true,     // response required
    2754                         false,    // no acknowledge required
     2764                        false, // it's not a broadcast
     2765                        true,  // response required
     2766                        false, // no acknowledge required
    27552767                        srcid,   
    27562768                        trdid,
     
    29042916          entry.owner.inst)             // put the next srcid in the fifo
    29052917      {
    2906         dec_upt_counter                 = false;
     2918        dec_upt_counter                = false;
    29072919        write_to_cc_send_fifo_put      = true;
    29082920        write_to_cc_send_fifo_inst     = entry.owner.inst;
     
    29572969      {
    29582970        r_write_to_cc_send_multi_req = true;
    2959         if(r_write_to_dec.read() or dec_upt_counter)   r_write_fsm = WRITE_UPT_DEC;
     2971        if(r_write_to_dec.read() or dec_upt_counter)  r_write_fsm = WRITE_UPT_DEC;
    29602972        else                                          r_write_fsm = WRITE_IDLE;
    29612973      }
     
    32003212        {
    32013213          r_write_trt_index = wok_index;
    3202           r_write_fsm       = WRITE_BC_UPT_LOCK;
     3214          r_write_fsm       = WRITE_BC_IVT_LOCK;
    32033215        }
    32043216        else  // wait an empty entry in TRT
     
    32173229
    32183230    //////////////////////
    3219     case WRITE_BC_UPT_LOCK:      // register BC transaction in UPT
    3220     {
    3221       if(r_alloc_upt_fsm.read() == ALLOC_UPT_WRITE)
     3231    case WRITE_BC_IVT_LOCK:      // register BC transaction in IVT
     3232    {
     3233      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    32223234      {
    32233235        bool        wok       = false;
     
    32293241        size_t      nb_copies = r_write_count.read();
    32303242
    3231         wok = m_upt.set(false,  // it's an inval transaction
    3232                         true,     // it's a broadcast
    3233                         true,     // response required
    3234                         false,    // no acknowledge required
     3243        wok = m_ivt.set(false,  // it's an inval transaction
     3244                        true,   // it's a broadcast
     3245                        true,   // response required
     3246                        false,  // no acknowledge required
    32353247                        srcid,
    32363248                        trdid,
     
    32423254#if DEBUG_MEMC_WRITE
    32433255if( m_debug and wok )
    3244 std::cout << "  <MEMC " << name() << " WRITE_BC_UPT_LOCK> Register broadcast inval in UPT"
     3256std::cout << "  <MEMC " << name() << " WRITE_BC_IVT_LOCK> Register broadcast inval in IVT"
    32453257          << " / nb_copies = " << r_write_count.read() << std::endl;
    32463258#endif
     
    32483260
    32493261        if(wok) r_write_fsm = WRITE_BC_DIR_INVAL;
    3250         else       r_write_fsm = WRITE_WAIT;
     3262        else    r_write_fsm = WRITE_WAIT;
    32513263      }
    32523264      break;
     
    32593271      // and invalidate the line in directory
    32603272      if((r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE) or
    3261           (r_alloc_upt_fsm.read() != ALLOC_UPT_WRITE) or
    3262           (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
     3273         (r_alloc_ivt_fsm.read() != ALLOC_IVT_WRITE) or
     3274         (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
    32633275      {
    32643276        std::cout << "VCI_MEM_CACHE ERROR " << name() << " WRITE_BC_DIR_INVAL state" << std::endl;
    3265         std::cout << "bad TRT, DIR, or UPT allocation" << std::endl;
     3277        std::cout << "bad TRT, DIR, or IVT allocation" << std::endl;
    32663278        exit(0);
    32673279      }
     
    37913803    }
    37923804    /////////////////////////
    3793     case XRAM_RSP_INVAL_LOCK: // Take the UPT lock to check a possible pending inval
    3794     {
    3795       if(r_alloc_upt_fsm == ALLOC_UPT_XRAM_RSP)
     3805    case XRAM_RSP_INVAL_LOCK: // Take the IVT lock to check a possible pending inval
     3806    {
     3807      if(r_alloc_ivt_fsm == ALLOC_IVT_XRAM_RSP)
    37963808      {
    37973809        size_t index = 0;
    3798         if(m_upt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
     3810        if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
    37993811        {
    38003812          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    38033815if(m_debug)
    38043816std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3805           << " Get acces to UPT, but line invalidation registered"
     3817          << " Get acces to IVT, but line invalidation registered"
    38063818          << " / nline = " << std::hex << r_xram_rsp_trt_buf.nline
    38073819          << " / index = " << std::dec << index << std::endl;
     
    38093821
    38103822        }
    3811         else if(m_upt.is_full() and r_xram_rsp_victim_inval.read()) // UPT full
     3823        else if(m_ivt.is_full() and r_xram_rsp_victim_inval.read()) // IVT full
    38123824        {
    38133825          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    38163828if(m_debug)
    38173829std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3818           << " Get acces to UPT, but inval required and UPT full" << std::endl;
     3830          << " Get acces to IVT, but inval required and IVT full" << std::endl;
    38193831#endif
    38203832        }
     
    38263838if(m_debug)
    38273839std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3828           << " Get acces to UPT" << std::endl;
     3840          << " Get acces to IVT" << std::endl;
    38293841#endif
    38303842        }
     
    38463858    ///////////////////////
    38473859    case XRAM_RSP_DIR_UPDT:   // updates the cache (both data & directory)
    3848                               // and possibly set an inval request in UPT
     3860                              // and possibly set an inval request in IVT
    38493861    {
    38503862      // check if this is an instruction read, this means pktid is either
     
    39043916      m_cache_directory.write(set, way, entry);
    39053917
    3906       // request an invalidattion request in UPT for victim line
     3918      // request an invalidattion request in IVT for victim line
    39073919      if(r_xram_rsp_victim_inval.read())
    39083920      {
     
    39113923        size_t count_copies = r_xram_rsp_victim_count.read();
    39123924
    3913         bool   wok = m_upt.set(false,      // it's an inval transaction
     3925        bool   wok = m_ivt.set(false,      // it's an inval transaction
    39143926                               broadcast,  // set broadcast bit
    39153927                               false,      // no response required
     
    39223934                               index);
    39233935
    3924         r_xram_rsp_upt_index = index;
     3936        r_xram_rsp_ivt_index = index;
    39253937
    39263938        if(!wok)
    39273939        {
    39283940          std::cout << "VCI_MEM_CACHE ERROR " << name() << " XRAM_RSP_DIR_UPDT"
    3929                     << " update_tab entry free but write unsuccessful" << std::endl;
     3941                    << " invalidate_tab entry free but write unsuccessful" << std::endl;
    39303942          exit(0);
    39313943        }
     
    40364048        r_xram_rsp_to_cc_send_brdcast_req  = r_xram_rsp_victim_is_cnt.read();
    40374049        r_xram_rsp_to_cc_send_nline        = r_xram_rsp_victim_nline.read();
    4038         r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_upt_index;
     4050        r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_ivt_index;
    40394051        xram_rsp_to_cc_send_fifo_srcid     = r_xram_rsp_victim_copy.read();
    40404052        xram_rsp_to_cc_send_fifo_inst      = r_xram_rsp_victim_copy_inst.read();
     
    42524264        DspinDhccpParam::dspin_get(
    42534265            flit,
    4254             DspinDhccpParam::FROM_L1_TYPE);
     4266            DspinDhccpParam::P2M_TYPE);
    42554267
    42564268      r_cleanup_way_index =
     
    43814393      else                // miss : check UPT for a pending invalidation transaction
    43824394      {
    4383         r_cleanup_fsm = CLEANUP_UPT_LOCK;
     4395        r_cleanup_fsm = CLEANUP_IVT_LOCK;
    43844396      }
    43854397
     
    48394851    }
    48404852    //////////////////////
    4841     case CLEANUP_UPT_LOCK:   // get the lock protecting the UPT to search a pending
     4853    case CLEANUP_IVT_LOCK:   // get the lock protecting the IVT to search a pending
    48424854                             // invalidate transaction matching the cleanup
    48434855    {
    4844       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP) break;
     4856      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    48454857
    48464858      size_t index = 0;
    48474859      bool   match_inval;
    48484860
    4849       match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
     4861      match_inval = m_ivt.search_inval(r_cleanup_nline.read(), index);
    48504862
    48514863      if ( not match_inval )     // no pending inval
     
    48564868if(m_debug)
    48574869std::cout << "  <MEMC " << name()
    4858           << " CLEANUP_UPT_LOCK> Unexpected cleanup"
    4859           << " with no corresponding UPT entry:"
     4870          << " CLEANUP_IVT_LOCK> Unexpected cleanup"
     4871          << " with no corresponding IVT entry:"
    48604872          << " address = " << std::hex
    48614873          << (r_cleanup_nline.read() *4*m_words)
     
    48664878
    48674879      // pending inval
    4868       r_cleanup_write_srcid = m_upt.srcid(index);
    4869       r_cleanup_write_trdid = m_upt.trdid(index);
    4870       r_cleanup_write_pktid = m_upt.pktid(index);
    4871       r_cleanup_need_rsp    = m_upt.need_rsp(index);
    4872       r_cleanup_need_ack    = m_upt.need_ack(index);
     4880      r_cleanup_write_srcid = m_ivt.srcid(index);
     4881      r_cleanup_write_trdid = m_ivt.trdid(index);
     4882      r_cleanup_write_pktid = m_ivt.pktid(index);
     4883      r_cleanup_need_rsp    = m_ivt.need_rsp(index);
     4884      r_cleanup_need_ack    = m_ivt.need_ack(index);
    48734885      r_cleanup_index       = index;
    48744886
    4875       r_cleanup_fsm         = CLEANUP_UPT_DECREMENT;
     4887      r_cleanup_fsm         = CLEANUP_IVT_DECREMENT;
    48764888
    48774889#if DEBUG_MEMC_CLEANUP
    48784890if(m_debug)
    48794891std::cout << "  <MEMC " << name()
    4880           << " CLEANUP_UPT_LOCK> Cleanup matching pending"
    4881           << " invalidate transaction on UPT:"
     4892          << " CLEANUP_IVT_LOCK> Cleanup matching pending"
     4893          << " invalidate transaction on IVT:"
    48824894          << " address = " << std::hex << r_cleanup_nline.read() * m_words * 4
    4883           << " / upt_entry = " << index << std::endl;
     4895          << " / ivt_entry = " << index << std::endl;
    48844896#endif
    48854897      break;
    48864898    }
    48874899    ///////////////////////////
    4888     case CLEANUP_UPT_DECREMENT:   // decrement response counter in UPT matching entry
    4889     {
    4890       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     4900    case CLEANUP_IVT_DECREMENT: // decrement response counter in IVT matching entry
     4901    {
     4902      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    48914903      {
    48924904        std::cout
    48934905            << "VCI_MEM_CACHE ERROR "         << name()
    4894             << " CLEANUP_UPT_DECREMENT state" << std::endl
    4895             << "Bad UPT allocation"
     4906            << " CLEANUP_IVT_DECREMENT state" << std::endl
     4907            << "Bad IVT allocation"
    48964908            << std::endl;
    48974909
     
    49004912
    49014913      size_t count = 0;
    4902       m_upt.decrement(r_cleanup_index.read(), count);
     4914      m_ivt.decrement(r_cleanup_index.read(), count);
    49034915
    49044916      if(count == 0)   // multi inval transaction completed
    49054917      {
    4906         r_cleanup_fsm = CLEANUP_UPT_CLEAR;
     4918        r_cleanup_fsm = CLEANUP_IVT_CLEAR;
    49074919      }
    49084920      else             // multi inval transaction not completed
     
    49134925#if DEBUG_MEMC_CLEANUP
    49144926if(m_debug)
    4915 std::cout << "  <MEMC " << name() << " CLEANUP_UPT_DECREMENT>"
    4916           << " Decrement response counter in UPT:"
    4917             << " UPT_index = " << r_cleanup_index.read()
     4927std::cout << "  <MEMC " << name() << " CLEANUP_IVT_DECREMENT>"
     4928          << " Decrement response counter in IVT:"
     4929            << " IVT_index = " << r_cleanup_index.read()
    49184930            << " / rsp_count = " << count << std::endl;
    49194931#endif
     
    49214933    }
    49224934    ///////////////////////
    4923     case CLEANUP_UPT_CLEAR:    // Clear UPT entry
    4924     {
    4925       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     4935    case CLEANUP_IVT_CLEAR:    // Clear IVT entry
     4936    {
     4937      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    49264938      {
    49274939        std::cout
    49284940            << "VCI_MEM_CACHE ERROR "     << name()
    4929             << " CLEANUP_UPT_CLEAR state" << std::endl
    4930             << "Bad UPT allocation"
     4941            << " CLEANUP_IVT_CLEAR state" << std::endl
     4942            << "Bad IVT allocation"
    49314943            << std::endl;
    49324944
     
    49344946      }
    49354947
    4936       m_upt.clear(r_cleanup_index.read());
     4948      m_ivt.clear(r_cleanup_index.read());
    49374949
    49384950      if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
     
    49434955if(m_debug)
    49444956std::cout << "  <MEMC "      << name()
    4945           << " CLEANUP_UPT_CLEAR> Clear entry in UPT:"
    4946           << " UPT_index = " << r_cleanup_index.read() << std::endl;
     4957          << " CLEANUP_IVT_CLEAR> Clear entry in IVT:"
     4958          << " IVT_index = " << r_cleanup_index.read() << std::endl;
    49474959#endif
    49484960      break;
     
    49895001    }
    49905002    ////////////////////////
    4991     case CLEANUP_SEND_CLACK:    // acknowledgement to a cleanup command
    4992                               // on the coherence network (request to the CC_SEND FSM).
    4993                               // wait if pending request to the CC_SEND FSM
    4994     {
    4995       if(r_cleanup_to_cc_send_req.read()) break;
    4996 
    4997       r_cleanup_to_cc_send_req       = true;
    4998       r_cleanup_to_cc_send_set_index = r_cleanup_nline.read() & 0xFFFF;
    4999       r_cleanup_to_cc_send_way_index = r_cleanup_way_index.read();
    5000       r_cleanup_to_cc_send_srcid     = r_cleanup_srcid.read();
    5001       r_cleanup_to_cc_send_inst      = r_cleanup_inst.read();
     5003    case CLEANUP_SEND_CLACK:  // acknowledgement to a cleanup command
     5004                              // on the coherence CLACK network.
     5005    {
     5006      if(not p_dspin_clack.read) break;
    50025007
    50035008      r_cleanup_fsm = CLEANUP_IDLE;
     
    50075012std::cout << "  <MEMC " << name()
    50085013          << " CLEANUP_SEND_CLACK> Send the response to a cleanup request:"
    5009           << " srcid = " << std::dec << r_cleanup_srcid.read() << std::endl;
     5014          << " nline = "   << std::hex << r_cleanup_nline.read()
     5015          << " / way = "   << std::dec << r_cleanup_way.read()
     5016          << " / srcid = " << std::dec << r_cleanup_srcid.read()
     5017          << std::endl;
    50105018#endif
    50115019      break;
     
    52425250                !r_cas_to_cc_send_brdcast_req.read())
    52435251        {
    5244           r_cas_fsm = CAS_UPT_LOCK;     // multi update required
     5252          r_cas_fsm = CAS_UPT_LOCK;       // multi update required
    52455253        }
    52465254        else
     
    55075515          {
    55085516            r_cas_trt_index = wok_index;
    5509             r_cas_fsm       = CAS_BC_UPT_LOCK;
     5517            r_cas_fsm       = CAS_BC_IVT_LOCK;
    55105518          }
    55115519          else
     
    55225530    }
    55235531    /////////////////////
    5524     case CAS_BC_UPT_LOCK:  // register a broadcast inval transaction in UPT
     5532    case CAS_BC_IVT_LOCK:  // register a broadcast inval transaction in IVT
    55255533                           // write data in cache in case of successful registration
    55265534    {
    5527       if(r_alloc_upt_fsm.read() == ALLOC_UPT_CAS)
     5535      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS)
    55285536      {
    55295537        bool        wok       = false;
     
    55355543        size_t      nb_copies = r_cas_count.read();
    55365544
    5537         // register a broadcast inval transaction in UPT
    5538         wok = m_upt.set(false,  // it's an inval transaction
    5539                         true,    // it's a broadcast
    5540                         true,    // response required
    5541                         false,   // no acknowledge required
     5545        // register a broadcast inval transaction in IVT
     5546        wok = m_ivt.set(false,  // it's an inval transaction
     5547                        true,   // it's a broadcast
     5548                        true,   // response required
     5549                        false,  // no acknowledge required
    55425550                        srcid,
    55435551                        trdid,
     
    55475555                        index);
    55485556
    5549         if(wok)     // UPT not full
     5557        if(wok)     // IVT not full
    55505558        {
    55515559          // cache update
     
    55735581if(m_debug)
    55745582std::cout << "  <MEMC " << name()
    5575           << " CAS_BC_UPT_LOCK> Register a broadcast inval transaction in UPT"
     5583          << " CAS_BC_IVT_LOCK> Register a broadcast inval transaction in IVT"
    55765584          << " / nline = " << std::hex << nline
    55775585          << " / count = " << std::dec << nb_copies
    5578           << " / upt_index = " << index << std::endl;
    5579 #endif
    5580         }
    5581         else      //  releases the lock protecting UPT
     5586          << " / ivt_index = " << index << std::endl;
     5587#endif
     5588        }
     5589        else      //  releases the lock protecting IVT
    55825590        {
    55835591          r_cas_fsm = CAS_WAIT;
     
    55905598    {
    55915599      if((r_alloc_trt_fsm.read() == ALLOC_TRT_CAS) and
    5592           (r_alloc_upt_fsm.read() == ALLOC_UPT_CAS) and
    5593           (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
     5600         (r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS) and
     5601         (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
    55945602      {
    55955603        // set TRT
     
    58345842  // network, used to update or invalidate cache lines in L1 caches.
    58355843  //
    5836   // This fsm is used also to acknowledge CLEANUP a command after request from
    5837   // the CLEANUP fsm.
    5838   //
    5839   // It implements a round-robin priority between the five possible client FSMs
    5840   //     XRAM_RSP > CAS > CLEANUP > WRITE > CONFIG
     5844  // It implements a round-robin priority between the four possible client FSMs
     5845  //     XRAM_RSP > CAS > WRITE > CONFIG
    58415846  //
    58425847  // Each FSM can request the next services:
     
    58505855  //   r_config_to_cc_send_brdcast_req : broadcast-inval
    58515856  //   
    5852   // - r_cleanup_to_cc_send_req : cleanup acknowledgement
    5853   //
    58545857  // An inval request is a double DSPIN flit command containing:
    58555858  // 1. the index of the line to be invalidated.
     
    58945897          break;
    58955898        }
    5896         // CLEANUP
    5897         if (r_cleanup_to_cc_send_req.read())
    5898         {
    5899           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    5900           break;
    5901         }
    59025899        // WRITE
    59035900        if(m_write_to_cc_send_inst_fifo.rok() or
     
    59735970          break;
    59745971        }
    5975         // CLEANUP
    5976         if (r_cleanup_to_cc_send_req.read())
    5977         {
    5978           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    5979           break;
    5980         }
    59815972        // WRITE
    59825973        if(m_write_to_cc_send_inst_fifo.rok() or
     
    60126003          break;
    60136004        }
    6014         // CLEANUP
    6015         if(r_cleanup_to_cc_send_req.read())
    6016         {
    6017           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6018           break;
    6019         }
    60206005        // WRITE
    60216006        if(m_write_to_cc_send_inst_fifo.rok() or
     
    60656050      case CC_SEND_CAS_IDLE:   // CLEANUP FSM has highest priority
    60666051      {
    6067         if(r_cleanup_to_cc_send_req.read())
    6068         {
    6069           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6070           break;
    6071         }
    60726052        if(m_write_to_cc_send_inst_fifo.rok() or
    60736053            r_write_to_cc_send_multi_req.read())
     
    61246104        break;
    61256105      }
    6126       //////////////////////////
    6127       case CC_SEND_CLEANUP_IDLE:   // WRITE FSM has highest priority
    6128       {
    6129         // WRITE
    6130         if(m_write_to_cc_send_inst_fifo.rok() or
    6131             r_write_to_cc_send_multi_req.read())
    6132         {
    6133           r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6134           m_cpt_update++;
    6135           break;
    6136         }
    6137         if(r_write_to_cc_send_brdcast_req.read())
    6138         {
    6139           r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6140           m_cpt_inval++;
    6141           break;
    6142         }
    6143         // CONFIG
    6144         if(r_config_to_cc_send_multi_req.read())
    6145         {
    6146           r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6147           m_cpt_inval++;
    6148           break;
    6149         }
    6150         if(r_config_to_cc_send_brdcast_req.read())
    6151         {
    6152           r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6153           m_cpt_inval++;
    6154           break;
    6155         }
    6156         // XRAM_RSP
    6157         if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    6158             r_xram_rsp_to_cc_send_multi_req.read())
    6159         {
    6160           r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6161           m_cpt_inval++;
    6162           break;
    6163         }
    6164         if(r_xram_rsp_to_cc_send_brdcast_req.read())
    6165         {
    6166           r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6167           m_cpt_inval++;
    6168           break;
    6169         }
    6170         // CAS
    6171         if(m_cas_to_cc_send_inst_fifo.rok() or
    6172             r_cas_to_cc_send_multi_req.read())
    6173         {
    6174           r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6175           m_cpt_update++;
    6176           break;
    6177         }
    6178         if(r_cas_to_cc_send_brdcast_req.read())
    6179         {
    6180           r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6181           m_cpt_inval++;
    6182           break;
    6183         }
    6184         // CLEANUP
    6185         if(r_cleanup_to_cc_send_req.read())
    6186         {
    6187           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6188           break;
    6189         }
    6190         break;
    6191       }
    61926106      /////////////////////////////////
    61936107      case CC_SEND_CONFIG_INVAL_HEADER:   // send first flit multi-inval (from CONFIG FSM)
     
    61956109        if(m_config_to_cc_send_inst_fifo.rok())
    61966110        {
    6197           if(not p_dspin_out.read) break;
     6111          if(not p_dspin_m2p.read) break;
    61986112          r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    61996113          break;
     
    62066120      case CC_SEND_CONFIG_INVAL_NLINE:    // send second flit multi-inval (from CONFIG FSM)
    62076121      {
    6208         if(not p_dspin_out.read) break;
     6122        if(not p_dspin_m2p.read) break;
    62096123        m_cpt_inval_mult++;
    62106124        config_to_cc_send_fifo_get = true;
     
    62226136      case CC_SEND_CONFIG_BRDCAST_HEADER:   // send first flit BC-inval (from CONFIG FSM)
    62236137      {
    6224         if(not p_dspin_out.read) break;
     6138        if(not p_dspin_m2p.read) break;
    62256139        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_NLINE;
    62266140        break;
     
    62296143      case CC_SEND_CONFIG_BRDCAST_NLINE:    // send second flit BC-inval (from CONFIG FSM)
    62306144      {
    6231         if(not p_dspin_out.read) break;
     6145        if(not p_dspin_m2p.read) break;
    62326146        m_cpt_inval_brdcast++;
    62336147        r_config_to_cc_send_brdcast_req = false;
     
    62426156        break;
    62436157      }
    6244       /////////////////////////
    6245       case CC_SEND_CLEANUP_ACK:   // send one flit for a cleanup acknowledgement
    6246       {
    6247         if(not p_dspin_out.read) break;
    6248 
    6249         r_cleanup_to_cc_send_req = false;
    6250         r_cc_send_fsm = CC_SEND_CLEANUP_IDLE;
    6251 
    6252 #if DEBUG_MEMC_CC_SEND
    6253 if(m_debug)
    6254 std::cout << "  <MEMC " << name()
    6255           << " CC_SEND_CLEANUP_ACK> Cleanup Ack for srcid "
    6256           << std::hex << r_cleanup_to_cc_send_srcid.read() << std::endl;
    6257 #endif
    6258         break;
    6259       }
    62606158      ///////////////////////////////////
    62616159      case CC_SEND_XRAM_RSP_INVAL_HEADER:   // send first flit multi-inval (from XRAM_RSP FSM)
     
    62636161        if(m_xram_rsp_to_cc_send_inst_fifo.rok())
    62646162        {
    6265           if(not p_dspin_out.read) break;
     6163          if(not p_dspin_m2p.read) break;
    62666164          r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    62676165          break;
     
    62746172      case CC_SEND_XRAM_RSP_INVAL_NLINE:   // send second flit multi-inval (from XRAM_RSP FSM)
    62756173      {
    6276         if(not p_dspin_out.read) break;
     6174        if(not p_dspin_m2p.read) break;
    62776175        m_cpt_inval_mult++;
    62786176        xram_rsp_to_cc_send_fifo_get = true;
     
    62826180if(m_debug)
    62836181std::cout << "  <MEMC " << name()
    6284           << " CC_SEND_XRAM_RSP_INVAL_NLINE> BC-Inval for line "
     6182          << " CC_SEND_XRAM_RSP_INVAL_NLINE> Multicast-Inval for line "
    62856183          << std::hex << r_xram_rsp_to_cc_send_nline.read() << std::endl;
    62866184#endif
     
    62906188      case CC_SEND_XRAM_RSP_BRDCAST_HEADER:  // send first flit broadcast-inval (from XRAM_RSP FSM)
    62916189      {
    6292         if(not p_dspin_out.read) break;
     6190        if(not p_dspin_m2p.read) break;
    62936191        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_NLINE;
    62946192        break;
     
    62976195      case CC_SEND_XRAM_RSP_BRDCAST_NLINE:   // send second flit broadcast-inval (from XRAM_RSP FSM)
    62986196      {
    6299         if(not p_dspin_out.read) break;
     6197        if(not p_dspin_m2p.read) break;
    63006198        m_cpt_inval_brdcast++;
    63016199        r_xram_rsp_to_cc_send_brdcast_req = false;
     
    63136211      case CC_SEND_WRITE_BRDCAST_HEADER:   // send first flit broadcast-inval (from WRITE FSM)
    63146212      {
    6315         if(not p_dspin_out.read) break;
     6213        if(not p_dspin_m2p.read) break;
    63166214        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_NLINE;
    63176215        break;
     
    63206218      case CC_SEND_WRITE_BRDCAST_NLINE:   // send second flit broadcast-inval (from WRITE FSM)
    63216219      {
    6322         if(not p_dspin_out.read) break;
     6220        if(not p_dspin_m2p.read) break;
    63236221
    63246222        m_cpt_inval_brdcast++;
     
    63406238        if(m_write_to_cc_send_inst_fifo.rok())
    63416239        {
    6342           if(not p_dspin_out.read) break;
     6240          if(not p_dspin_m2p.read) break;
    63436241
    63446242          r_cc_send_fsm = CC_SEND_WRITE_UPDT_NLINE;
     
    63576255      case CC_SEND_WRITE_UPDT_NLINE:   // send second flit for a multi-update (from WRITE FSM)
    63586256      {
    6359         if(not p_dspin_out.read) break;
     6257        if(not p_dspin_m2p.read) break;
    63606258        m_cpt_update_mult++;
    63616259
     
    63746272      case CC_SEND_WRITE_UPDT_DATA:   // send N data flits for a multi-update (from WRITE FSM)
    63756273      {
    6376         if(not p_dspin_out.read) break;
     6274        if(not p_dspin_m2p.read) break;
    63776275        if(r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1))
    63786276        {
     
    63886286      case CC_SEND_CAS_BRDCAST_HEADER:   // send first flit  broadcast-inval (from CAS FSM)
    63896287      {
    6390         if(not p_dspin_out.read) break;
     6288        if(not p_dspin_m2p.read) break;
    63916289        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_NLINE;
    63926290        break;
     
    63956293      case CC_SEND_CAS_BRDCAST_NLINE:   // send second flit broadcast-inval (from CAS FSM)
    63966294      {
    6397         if(not p_dspin_out.read) break;
     6295        if(not p_dspin_m2p.read) break;
    63986296        m_cpt_inval_brdcast++;
    63996297
     
    64146312        if(m_cas_to_cc_send_inst_fifo.rok())
    64156313        {
    6416           if(not p_dspin_out.read) break;
     6314          if(not p_dspin_m2p.read) break;
    64176315
    64186316          r_cc_send_fsm = CC_SEND_CAS_UPDT_NLINE;
     
    64326330      case CC_SEND_CAS_UPDT_NLINE:   // send second flit for a multi-update (from CAS FSM)
    64336331      {
    6434         if(not p_dspin_out.read) break;
     6332        if(not p_dspin_m2p.read) break;
    64356333
    64366334        m_cpt_update_mult++;
     
    64506348      case CC_SEND_CAS_UPDT_DATA:   // send first data for a multi-update (from CAS FSM)
    64516349      {
    6452         if(not p_dspin_out.read) break;
     6350        if(not p_dspin_m2p.read) break;
    64536351
    64546352        if(r_cas_to_cc_send_is_long.read())
     
    64656363      case CC_SEND_CAS_UPDT_DATA_HIGH:   // send second data for a multi-update (from CAS FSM)
    64666364      {
    6467         if(not p_dspin_out.read) break;
     6365        if(not p_dspin_m2p.read) break;
    64686366        cas_to_cc_send_fifo_get = true;
    64696367        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
     
    64856383    case CC_RECEIVE_IDLE:
    64866384      {
    6487         if(not p_dspin_in.write) break;
     6385        if(not p_dspin_p2m.write) break;
    64886386
    64896387        uint8_t type =
    64906388          DspinDhccpParam::dspin_get(
    6491               p_dspin_in.data.read(),
    6492               DspinDhccpParam::FROM_L1_TYPE);
     6389              p_dspin_p2m.data.read(),
     6390              DspinDhccpParam::P2M_TYPE);
    64936391
    64946392        if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
     
    65166414        // write first CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    65176415
    6518         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     6416        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    65196417          break;
    65206418
    6521         assert(not p_dspin_in.eop.read() and
     6419        assert(not p_dspin_p2m.eop.read() and
    65226420            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65236421            "CLEANUP command must have two flits");
     
    65336431        // write second CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    65346432
    6535         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     6433        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    65366434          break;
    65376435
    6538         assert(p_dspin_in.eop.read() and
     6436        assert(p_dspin_p2m.eop.read() and
    65396437            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65406438            "CLEANUP command must have two flits");
     
    65526450
    65536451        // wait for a WOK in the CC_RECEIVE to MULTI_ACK fifo
    6554         if(not p_dspin_in.write or not m_cc_receive_to_multi_ack_fifo.wok())
     6452        if(not p_dspin_p2m.write or not m_cc_receive_to_multi_ack_fifo.wok())
    65556453          break;
    65566454
    6557         assert(p_dspin_in.eop.read() and
     6455        assert(p_dspin_p2m.eop.read() and
    65586456            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65596457            "MULTI_ACK command must have one flit");
     
    69656863  //    ALLOC_UPT FSM
    69666864  ////////////////////////////////////////////////////////////////////////////////////
    6967   // The ALLOC_UPT FSM allocates the access to the Update/Inval Table (UPT),
    6968   // with a round robin priority between six FSMs, with the following order:
    6969   //  CONFIG > MULTI_ACK > WRITE > XRAM_RSP > CLEANUP > CAS
    6970   // - The CONFIG FSM initiates an inval transaction and sets a new entry in UPT.
     6865  // The ALLOC_UPT FSM allocates the access to the Update Table (UPT),
     6866  // with a round robin priority between three FSMs, with the following order:
     6867  //  WRITE -> CAS -> MULTI_ACK
     6868  // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
     6869  // - The CAS FSM does the same thing as the WRITE FSM.
    69716870  // - The MULTI_ACK FSM complete those trasactions and erase the UPT entry.
    6972   // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
    6973   // - The XRAM_RSP FSM initiates an inval transactions and sets a new entry in UPT.
    6974   // - The CLEANUP  FSM decrement an entry in UPT.
    6975   // - The CAS FSM does the same thing as the WRITE FSM.
    69766871  // The resource is always allocated.
    69776872  /////////////////////////////////////////////////////////////////////////////////////
    6978 
    69796873  switch(r_alloc_upt_fsm.read())
    69806874  {
    6981       //////////////////////
    6982       case ALLOC_UPT_CONFIG:   // allocated to CONFIG FSM
    6983       if (r_config_fsm.read() != CONFIG_DIR_UPT_LOCK)
    6984       {
    6985         if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    6986           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    6987                
    6988         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    6989                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    6990           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    6991 
    6992         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    6993           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    6994 
    6995         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    6996           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    6997 
    6998         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    6999                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7000           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7001       }
    7002       break;
    7003 
    70046875      /////////////////////////
    7005       case ALLOC_UPT_MULTI_ACK:   // allocated to MULTI_ACK FSM
    7006       if( (r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK) and
    7007           (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
    7008       {
    7009         if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7010             (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7011           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7012 
    7013         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7014           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7015 
    7016         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7017           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7018 
    7019         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7020                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7021           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7022 
    7023         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7024           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7025       }
    7026       break;
    7027 
    7028       /////////////////////
    7029       case ALLOC_UPT_WRITE:   // allocated to WRITE FSM
    7030       if((r_write_fsm.read() != WRITE_UPT_LOCK) and
    7031           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
    7032       {
    7033         if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7034           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7035 
    7036         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7037           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7038 
    7039         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7040                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7041           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7042 
    7043         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7044           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7045 
    7046         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7047           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7048       }
    7049       break;
    7050 
    7051       ////////////////////////
    7052       case ALLOC_UPT_XRAM_RSP:
    7053       if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
    7054       {
    7055         if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7056           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7057 
    7058         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7059                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7060           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7061 
    7062         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7063           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7064 
    7065         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7066           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7067 
    7068         else if((r_write_fsm.read() == WRITE_UPT_LOCK)   or
    7069                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7070           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7071       }
    7072       break;
    7073 
     6876      case ALLOC_UPT_WRITE:         // allocated to WRITE FSM
     6877          if (r_write_fsm.read() != WRITE_UPT_LOCK)
     6878          {
     6879              if (r_cas_fsm.read() == CAS_UPT_LOCK)
     6880                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6881
     6882              else if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6883                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     6884          }
     6885          break;
     6886
     6887      /////////////////////////
     6888      case ALLOC_UPT_CAS:           // allocated to CAS FSM
     6889          if (r_cas_fsm.read() != CAS_UPT_LOCK)
     6890          {
     6891              if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6892                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     6893
     6894              else if (r_write_fsm.read() == WRITE_UPT_LOCK)
     6895                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     6896          }
     6897          break;
     6898
     6899      /////////////////////////
     6900      case ALLOC_UPT_MULTI_ACK:     // allocated to MULTI_ACK FSM
     6901          if ((r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK ) and
     6902              (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
     6903          {
     6904              if (r_write_fsm.read() == WRITE_UPT_LOCK)
     6905                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     6906
     6907              else if (r_cas_fsm.read() == CAS_UPT_LOCK)
     6908                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6909          }
     6910          break;
     6911  } // end switch r_alloc_upt_fsm
     6912
     6913  ////////////////////////////////////////////////////////////////////////////////////
     6914  //    ALLOC_IVT FSM
     6915  ////////////////////////////////////////////////////////////////////////////////////
     6916  // The ALLOC_IVT FSM allocates the access to the Invalidate Table (IVT),
     6917  // with a round robin priority between five FSMs, with the following order:
     6918  //  WRITE -> XRAM_RSP -> CLEANUP -> CAS -> CONFIG
     6919  // - The WRITE FSM initiates broadcast invalidate transactions and sets a new entry
     6920  //   in IVT.
     6921  // - The CAS FSM does the same thing as the WRITE FSM.
     6922  // - The XRAM_RSP FSM initiates broadcast/multicast invalidate transaction and sets
     6923  //   a new entry in the IVT
     6924  // - The CONFIG FSM does the same thing as the XRAM_RSP FSM
     6925  // - The CLEANUP FSM complete those trasactions and erase the IVT entry.
     6926  // The resource is always allocated.
     6927  /////////////////////////////////////////////////////////////////////////////////////
     6928  switch(r_alloc_ivt_fsm.read())
     6929  {
    70746930      //////////////////////////
    7075       case ALLOC_UPT_CLEANUP:
    7076       if((r_cleanup_fsm.read() != CLEANUP_UPT_LOCK     ) and
    7077          (r_cleanup_fsm.read() != CLEANUP_UPT_DECREMENT))
    7078       {
    7079         if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7080             (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7081           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7082 
    7083         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7084           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7085 
    7086         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7087           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7088 
    7089         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7090                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7091           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7092 
    7093         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7094           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7095       }
    7096       break;
     6931      case ALLOC_IVT_WRITE:            // allocated to WRITE FSM
     6932          if (r_write_fsm.read() != WRITE_BC_IVT_LOCK)
     6933          {
     6934              if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6935                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     6936
     6937              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     6938                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     6939
     6940              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     6941                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     6942
     6943              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6944                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6945          }
     6946          break;
    70976947
    70986948      //////////////////////////
    7099       case ALLOC_UPT_CAS:
    7100       if((r_cas_fsm.read() != CAS_UPT_LOCK) and
    7101           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
    7102       {
    7103         if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7104           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7105 
    7106         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7107           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7108 
    7109         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7110                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7111           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7112 
    7113         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7114           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7115 
    7116         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7117           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7118       }
    7119       break;
    7120 
    7121   } // end switch r_alloc_upt_fsm
     6949      case ALLOC_IVT_XRAM_RSP:         // allocated to XRAM_RSP FSM
     6950          if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
     6951          {
     6952              if(r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     6953                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     6954
     6955              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     6956                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     6957
     6958              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6959                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6960
     6961              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     6962                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     6963          }
     6964          break;
     6965
     6966      //////////////////////////
     6967      case ALLOC_IVT_CLEANUP:          // allocated to CLEANUP FSM
     6968          if ((r_cleanup_fsm.read() != CLEANUP_IVT_LOCK     ) and
     6969              (r_cleanup_fsm.read() != CLEANUP_IVT_DECREMENT))
     6970          {
     6971              if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     6972                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     6973
     6974              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6975                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6976
     6977              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     6978                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     6979
     6980              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6981                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     6982          }
     6983          break;
     6984
     6985      //////////////////////////
     6986      case ALLOC_IVT_CAS:              // allocated to CAS FSM
     6987          if (r_cas_fsm.read() != CAS_BC_IVT_LOCK)
     6988          {
     6989              if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     6990                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     6991
     6992              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     6993                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     6994
     6995              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6996                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     6997
     6998              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     6999                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7000          }
     7001          break;
     7002
     7003      //////////////////////////
     7004      case ALLOC_IVT_CONFIG:           // allocated to CONFIG FSM
     7005          if (r_config_fsm.read() != CONFIG_DIR_IVT_LOCK)
     7006          {
     7007              if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7008                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7009
     7010              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7011                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7012
     7013              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7014                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7015
     7016              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7017                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7018          }
     7019          break;
     7020
     7021  } // end switch r_alloc_ivt_fsm
    71227022
    71237023  ////////////////////////////////////////////////////////////////////////////////////
     
    71497049    if ( (r_config_fsm.read()    != CONFIG_DIR_REQ) and
    71507050         (r_config_fsm.read()    != CONFIG_DIR_ACCESS) and
    7151          (r_config_fsm.read()    != CONFIG_DIR_UPT_LOCK) )
     7051         (r_config_fsm.read()    != CONFIG_DIR_IVT_LOCK) )
    71527052    {
    71537053        if(r_read_fsm.read() == READ_DIR_REQ)
     
    72027102        (r_write_fsm.read()       != WRITE_DIR_HIT)  and
    72037103        (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  and
    7204         (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  and
     7104        (r_write_fsm.read()       != WRITE_BC_IVT_LOCK)  and
    72057105        (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  and
    72067106        (r_write_fsm.read()       != WRITE_UPT_LOCK)  and
     
    72387138        (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  and
    72397139        (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  and
    7240         (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  and
     7140        (r_cas_fsm.read()         != CAS_BC_IVT_LOCK)  and
    72417141        (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  and
    72427142        (r_cas_fsm.read()         != CAS_UPT_LOCK)  and
     
    73527252      if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
    73537253          (r_write_fsm.read() != WRITE_BC_TRT_LOCK) and
    7354           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
     7254          (r_write_fsm.read() != WRITE_BC_IVT_LOCK))
    73557255      {
    73567256        if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
     
    73757275      if((r_cas_fsm.read() != CAS_MISS_TRT_LOCK) and
    73767276          (r_cas_fsm.read() != CAS_BC_TRT_LOCK) and
    7377           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
     7277          (r_cas_fsm.read() != CAS_BC_IVT_LOCK))
    73787278      {
    73797279        if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     
    76657565  m_cc_receive_to_cleanup_fifo.update( cc_receive_to_cleanup_fifo_get,
    76667566                                       cc_receive_to_cleanup_fifo_put,
    7667                                        p_dspin_in.data.read() );
     7567                                       p_dspin_p2m.data.read() );
    76687568
    76697569  ////////////////////////////////////////////////////////////////////////////////////
     
    76737573  m_cc_receive_to_multi_ack_fifo.update( cc_receive_to_multi_ack_fifo_get,
    76747574                                         cc_receive_to_multi_ack_fifo_put,
    7675                                          p_dspin_in.data.read() );
     7575                                         p_dspin_p2m.data.read() );
    76767576
    76777577  ////////////////////////////////////////////////////////////////////////////////////
     
    80157915
    80167916  ////////////////////////////////////////////////////////////////////
    8017   //  p_dspin_out port (CC_SEND FSM)
     7917  //  p_dspin_m2p port (CC_SEND FSM)
    80187918  ////////////////////////////////////////////////////////////////////
    80197919
    8020   p_dspin_out.write = false;
    8021   p_dspin_out.eop   = false;
    8022   p_dspin_out.data  = 0;
     7920  p_dspin_m2p.write = false;
     7921  p_dspin_m2p.eop   = false;
     7922  p_dspin_m2p.data  = 0;
    80237923
    80247924  switch(r_cc_send_fsm.read())
     
    80297929    case CC_SEND_WRITE_IDLE:
    80307930    case CC_SEND_CAS_IDLE:
    8031     case CC_SEND_CLEANUP_IDLE:
    80327931    {
    80337932        break;
     
    80647963        DspinDhccpParam::dspin_set( flit,
    80657964                                    multi_inval_type,
    8066                                     DspinDhccpParam::FROM_MC_TYPE);
    8067         p_dspin_out.write = true;
    8068         p_dspin_out.data  = flit;
     7965                                    DspinDhccpParam::M2P_TYPE);
     7966        p_dspin_m2p.write = true;
     7967        p_dspin_m2p.data  = flit;
    80697968        break;
    80707969    }
     
    80767975                                    r_config_to_cc_send_nline.read(),
    80777976                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8078         p_dspin_out.eop   = true;
    8079         p_dspin_out.write = true;
    8080         p_dspin_out.data  = flit;
     7977        p_dspin_m2p.eop   = true;
     7978        p_dspin_m2p.write = true;
     7979        p_dspin_m2p.data  = flit;
    80817980        break;
    80827981    }
    8083     ////////////////////////
    8084     case CC_SEND_CLEANUP_ACK:
    8085       {
    8086         uint8_t cleanup_ack_type;
    8087         if(r_cleanup_to_cc_send_inst.read())
    8088         {
    8089           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_INST;
    8090         }
    8091         else
    8092         {
    8093           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_DATA;
    8094         }
    8095 
    8096         uint64_t flit = 0;
    8097         uint64_t dest =
    8098           r_cleanup_to_cc_send_srcid.read() <<
    8099           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8100 
    8101         DspinDhccpParam::dspin_set(
    8102             flit,
    8103             dest,
    8104             DspinDhccpParam::CLEANUP_ACK_DEST);
    8105 
    8106         DspinDhccpParam::dspin_set(
    8107             flit,
    8108             r_cleanup_to_cc_send_set_index.read(),
    8109             DspinDhccpParam::CLEANUP_ACK_SET);
    8110 
    8111         DspinDhccpParam::dspin_set(
    8112             flit,
    8113             r_cleanup_to_cc_send_way_index.read(),
    8114             DspinDhccpParam::CLEANUP_ACK_WAY);
    8115 
    8116         DspinDhccpParam::dspin_set(
    8117             flit,
    8118             cleanup_ack_type,
    8119             DspinDhccpParam::FROM_MC_TYPE);
    8120 
    8121         p_dspin_out.eop   = true;
    8122         p_dspin_out.write = true;
    8123         p_dspin_out.data  = flit;
    8124 
    8125         break;
    8126     }
    8127 
    81287982    ///////////////////////////////////
    81297983    case CC_SEND_XRAM_RSP_INVAL_HEADER:
     
    81598013        DspinDhccpParam::dspin_set( flit,
    81608014                                    multi_inval_type,
    8161                                     DspinDhccpParam::FROM_MC_TYPE);
    8162         p_dspin_out.write = true;
    8163         p_dspin_out.data  = flit;
     8015                                    DspinDhccpParam::M2P_TYPE);
     8016        p_dspin_m2p.write = true;
     8017        p_dspin_m2p.data  = flit;
    81648018        break;
    81658019    }
     
    81738027                                    r_xram_rsp_to_cc_send_nline.read(),
    81748028                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8175         p_dspin_out.eop   = true;
    8176         p_dspin_out.write = true;
    8177         p_dspin_out.data  = flit;
     8029        p_dspin_m2p.eop   = true;
     8030        p_dspin_m2p.write = true;
     8031        p_dspin_m2p.data  = flit;
    81788032        break;
    81798033    }
     
    81978051        DspinDhccpParam::dspin_set( flit,
    81988052                                    1ULL,
    8199                                     DspinDhccpParam::FROM_MC_BC);
    8200         p_dspin_out.write = true;
    8201         p_dspin_out.data  = flit;
     8053                                    DspinDhccpParam::M2P_BC);
     8054        p_dspin_m2p.write = true;
     8055        p_dspin_m2p.data  = flit;
    82028056        break;
    82038057    }
     
    82098063                                    r_xram_rsp_to_cc_send_nline.read(),
    82108064                                    DspinDhccpParam::BROADCAST_NLINE);
    8211         p_dspin_out.write = true;
    8212         p_dspin_out.eop   = true;
    8213         p_dspin_out.data  = flit;
     8065        p_dspin_m2p.write = true;
     8066        p_dspin_m2p.eop   = true;
     8067        p_dspin_m2p.data  = flit;
    82148068        break;
    82158069    }
     
    82218075                                    r_config_to_cc_send_nline.read(),
    82228076                                    DspinDhccpParam::BROADCAST_NLINE);
    8223         p_dspin_out.write = true;
    8224         p_dspin_out.eop   = true;
    8225         p_dspin_out.data  = flit;
     8077        p_dspin_m2p.write = true;
     8078        p_dspin_m2p.eop   = true;
     8079        p_dspin_m2p.data  = flit;
    82268080        break;
    82278081    }
     
    82338087                                    r_write_to_cc_send_nline.read(),
    82348088                                    DspinDhccpParam::BROADCAST_NLINE);
    8235         p_dspin_out.write = true;
    8236         p_dspin_out.eop   = true;
    8237         p_dspin_out.data  = flit;
     8089        p_dspin_m2p.write = true;
     8090        p_dspin_m2p.eop   = true;
     8091        p_dspin_m2p.data  = flit;
    82388092        break;
    82398093    }
     
    82458099                                    r_cas_to_cc_send_nline.read(),
    82468100                                    DspinDhccpParam::BROADCAST_NLINE);
    8247         p_dspin_out.write = true;
    8248         p_dspin_out.eop   = true;
    8249         p_dspin_out.data  = flit;
     8101        p_dspin_m2p.write = true;
     8102        p_dspin_m2p.eop   = true;
     8103        p_dspin_m2p.data  = flit;
    82508104        break;
    82518105    }
     
    82888142            flit,
    82898143            multi_updt_type,
    8290             DspinDhccpParam::FROM_MC_TYPE);
    8291 
    8292         p_dspin_out.write = true;
    8293         p_dspin_out.data  = flit;
     8144            DspinDhccpParam::M2P_TYPE);
     8145
     8146        p_dspin_m2p.write = true;
     8147        p_dspin_m2p.data  = flit;
    82948148
    82958149        break;
     
    83108164            DspinDhccpParam::MULTI_UPDT_NLINE);
    83118165
    8312         p_dspin_out.write = true;
    8313         p_dspin_out.data  = flit;
     8166        p_dspin_m2p.write = true;
     8167        p_dspin_m2p.data  = flit;
    83148168
    83158169        break;
     
    83378191            DspinDhccpParam::MULTI_UPDT_DATA);
    83388192
    8339         p_dspin_out.write = true;
    8340         p_dspin_out.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
    8341         p_dspin_out.data  = flit;
     8193        p_dspin_m2p.write = true;
     8194        p_dspin_m2p.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
     8195        p_dspin_m2p.data  = flit;
    83428196
    83438197        break;
     
    83818235            flit,
    83828236            multi_updt_type,
    8383             DspinDhccpParam::FROM_MC_TYPE);
    8384 
    8385         p_dspin_out.write = true;
    8386         p_dspin_out.data  = flit;
     8237            DspinDhccpParam::M2P_TYPE);
     8238
     8239        p_dspin_m2p.write = true;
     8240        p_dspin_m2p.data  = flit;
    83878241
    83888242        break;
     
    84038257            DspinDhccpParam::MULTI_UPDT_NLINE);
    84048258
    8405         p_dspin_out.write = true;
    8406         p_dspin_out.data  = flit;
     8259        p_dspin_m2p.write = true;
     8260        p_dspin_m2p.data  = flit;
    84078261
    84088262        break;
     
    84238277            DspinDhccpParam::MULTI_UPDT_DATA);
    84248278
    8425         p_dspin_out.write = true;
    8426         p_dspin_out.eop   = not r_cas_to_cc_send_is_long.read();
    8427         p_dspin_out.data  = flit;
     8279        p_dspin_m2p.write = true;
     8280        p_dspin_m2p.eop   = not r_cas_to_cc_send_is_long.read();
     8281        p_dspin_m2p.data  = flit;
    84288282
    84298283        break;
     
    84448298            DspinDhccpParam::MULTI_UPDT_DATA);
    84458299
    8446         p_dspin_out.write = true;
    8447         p_dspin_out.eop   = true;
    8448         p_dspin_out.data  = flit;
     8300        p_dspin_m2p.write = true;
     8301        p_dspin_m2p.eop   = true;
     8302        p_dspin_m2p.data  = flit;
    84498303
    84508304        break;
     
    84528306  }
    84538307
     8308  ////////////////////////////////////////////////////////////////////
     8309  //  p_dspin_clack port (CLEANUP FSM)
     8310  ////////////////////////////////////////////////////////////////////
     8311
     8312  switch(r_cleanup_fsm.read())
     8313  {
     8314    case CLEANUP_IDLE:
     8315    case CLEANUP_GET_NLINE:
     8316    case CLEANUP_DIR_REQ:
     8317    case CLEANUP_DIR_LOCK:
     8318    case CLEANUP_DIR_WRITE:
     8319    case CLEANUP_HEAP_REQ:
     8320    case CLEANUP_HEAP_LOCK:
     8321    case CLEANUP_HEAP_SEARCH:
     8322    case CLEANUP_HEAP_CLEAN:
     8323    case CLEANUP_HEAP_FREE:
     8324    case CLEANUP_IVT_LOCK:
     8325    case CLEANUP_IVT_DECREMENT:
     8326    case CLEANUP_IVT_CLEAR:
     8327    case CLEANUP_WRITE_RSP:
     8328    case CLEANUP_CONFIG_ACK:
     8329      p_dspin_clack.write = false;
     8330      p_dspin_clack.eop   = false;
     8331      p_dspin_clack.data  = 0;
     8332
     8333      break;
     8334
     8335    case CLEANUP_SEND_CLACK:
     8336      {
     8337        uint8_t cleanup_ack_type;
     8338        if(r_cleanup_inst.read())
     8339        {
     8340          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
     8341        }
     8342        else
     8343        {
     8344          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
     8345        }
     8346
     8347        uint64_t flit = 0;
     8348        uint64_t dest =
     8349          r_cleanup_srcid.read() <<
     8350          (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
     8351
     8352        DspinDhccpParam::dspin_set(
     8353            flit,
     8354            dest,
     8355            DspinDhccpParam::CLACK_DEST);
     8356
     8357        DspinDhccpParam::dspin_set(
     8358            flit,
     8359            r_cleanup_nline.read() & 0xFFFF,
     8360            DspinDhccpParam::CLACK_SET);
     8361
     8362        DspinDhccpParam::dspin_set(
     8363            flit,
     8364            r_cleanup_way_index.read(),
     8365            DspinDhccpParam::CLACK_WAY);
     8366
     8367        DspinDhccpParam::dspin_set(
     8368            flit,
     8369            cleanup_ack_type,
     8370            DspinDhccpParam::CLACK_TYPE);
     8371
     8372        p_dspin_clack.eop   = true;
     8373        p_dspin_clack.write = true;
     8374        p_dspin_clack.data  = flit;
     8375      }
     8376      break;
     8377  }
     8378
    84548379  ///////////////////////////////////////////////////////////////////
    8455   //  p_dspin_in port (CC_RECEIVE FSM)
     8380  //  p_dspin_p2m port (CC_RECEIVE FSM)
    84568381  ///////////////////////////////////////////////////////////////////
    8457   p_dspin_in.read = false;
     8382  //
    84588383  switch(r_cc_receive_fsm.read())
    84598384  {
    84608385    case CC_RECEIVE_IDLE:
    84618386      {
     8387        p_dspin_p2m.read = false;
    84628388        break;
    84638389      }
     
    84658391    case CC_RECEIVE_CLEANUP_EOP:
    84668392      {
    8467         p_dspin_in.read = m_cc_receive_to_cleanup_fifo.wok();
     8393        p_dspin_p2m.read = m_cc_receive_to_cleanup_fifo.wok();
    84688394        break;
    84698395      }
    84708396    case CC_RECEIVE_MULTI_ACK:
    84718397      {
    8472         p_dspin_in.read = m_cc_receive_to_multi_ack_fifo.wok();
     8398        p_dspin_p2m.read = m_cc_receive_to_multi_ack_fifo.wok();
    84738399        break;
    84748400      }
  • trunk/platforms/tsar_generic_iob/top.cpp

    r450 r468  
    802802   // Horizontal inter-clusters INT network DSPIN
    803803   DspinSignals<dspin_int_cmd_width>*** signal_dspin_int_cmd_h_inc =
    804       alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_h_inc", XMAX-1, YMAX, 2);
     804      alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_h_inc", XMAX-1, YMAX, 3);
    805805   DspinSignals<dspin_int_cmd_width>*** signal_dspin_int_cmd_h_dec =
    806       alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_h_dec", XMAX-1, YMAX, 2);
     806      alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_h_dec", XMAX-1, YMAX, 3);
    807807   DspinSignals<dspin_int_rsp_width>*** signal_dspin_int_rsp_h_inc =
    808808      alloc_elems<DspinSignals<dspin_int_rsp_width> >("signal_dspin_int_rsp_h_inc", XMAX-1, YMAX, 2);
     
    812812   // Vertical inter-clusters INT network DSPIN
    813813   DspinSignals<dspin_int_cmd_width>*** signal_dspin_int_cmd_v_inc =
    814       alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_v_inc", XMAX, YMAX-1, 2);
     814      alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_v_inc", XMAX, YMAX-1, 3);
    815815   DspinSignals<dspin_int_cmd_width>*** signal_dspin_int_cmd_v_dec =
    816       alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_v_dec", XMAX, YMAX-1, 2);
     816      alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_int_cmd_v_dec", XMAX, YMAX-1, 3);
    817817   DspinSignals<dspin_int_rsp_width>*** signal_dspin_int_rsp_v_inc =
    818818      alloc_elems<DspinSignals<dspin_int_rsp_width> >("signal_dspin_int_rsp_v_inc", XMAX, YMAX-1, 2);
     
    822822   // Mesh boundaries INT network DSPIN
    823823   DspinSignals<dspin_int_cmd_width>**** signal_dspin_false_int_cmd_in =
    824       alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_false_int_cmd_in", XMAX, YMAX, 2, 4);
     824      alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_false_int_cmd_in", XMAX, YMAX, 4, 3);
    825825   DspinSignals<dspin_int_cmd_width>**** signal_dspin_false_int_cmd_out =
    826       alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_false_int_cmd_out", XMAX, YMAX, 2, 4);
     826      alloc_elems<DspinSignals<dspin_int_cmd_width> >("signal_dspin_false_int_cmd_out", XMAX, YMAX, 4, 3);
    827827   DspinSignals<dspin_int_rsp_width>**** signal_dspin_false_int_rsp_in =
    828       alloc_elems<DspinSignals<dspin_int_rsp_width> >("signal_dspin_false_int_rsp_in", XMAX, YMAX, 2, 4);
     828      alloc_elems<DspinSignals<dspin_int_rsp_width> >("signal_dspin_false_int_rsp_in", XMAX, YMAX, 4, 2);
    829829   DspinSignals<dspin_int_rsp_width>**** signal_dspin_false_int_rsp_out =
    830       alloc_elems<DspinSignals<dspin_int_rsp_width> >("signal_dspin_false_int_rsp_out", XMAX, YMAX, 2, 4);
     830      alloc_elems<DspinSignals<dspin_int_rsp_width> >("signal_dspin_false_int_rsp_out", XMAX, YMAX, 4, 2);
    831831
    832832
     
    11521152         for (size_t y = 0; y < YMAX; y++)
    11531153         {
     1154            for (size_t k = 0; k < 3; k++)
     1155            {
     1156               clusters[x][y]->p_dspin_int_cmd_out[EAST][k]      (signal_dspin_int_cmd_h_inc[x][y][k]);
     1157               clusters[x+1][y]->p_dspin_int_cmd_in[WEST][k]     (signal_dspin_int_cmd_h_inc[x][y][k]);
     1158               clusters[x][y]->p_dspin_int_cmd_in[EAST][k]       (signal_dspin_int_cmd_h_dec[x][y][k]);
     1159               clusters[x+1][y]->p_dspin_int_cmd_out[WEST][k]    (signal_dspin_int_cmd_h_dec[x][y][k]);
     1160            }
     1161
    11541162            for (size_t k = 0; k < 2; k++)
    11551163            {
    1156                clusters[x][y]->p_dspin_int_cmd_out[k][EAST]      (signal_dspin_int_cmd_h_inc[x][y][k]);
    1157                clusters[x+1][y]->p_dspin_int_cmd_in[k][WEST]     (signal_dspin_int_cmd_h_inc[x][y][k]);
    1158                clusters[x][y]->p_dspin_int_cmd_in[k][EAST]       (signal_dspin_int_cmd_h_dec[x][y][k]);
    1159                clusters[x+1][y]->p_dspin_int_cmd_out[k][WEST]    (signal_dspin_int_cmd_h_dec[x][y][k]);
    1160                clusters[x][y]->p_dspin_int_rsp_out[k][EAST]      (signal_dspin_int_rsp_h_inc[x][y][k]);
    1161                clusters[x+1][y]->p_dspin_int_rsp_in[k][WEST]     (signal_dspin_int_rsp_h_inc[x][y][k]);
    1162                clusters[x][y]->p_dspin_int_rsp_in[k][EAST]       (signal_dspin_int_rsp_h_dec[x][y][k]);
    1163                clusters[x+1][y]->p_dspin_int_rsp_out[k][WEST]    (signal_dspin_int_rsp_h_dec[x][y][k]);
     1164               clusters[x][y]->p_dspin_int_rsp_out[EAST][k]      (signal_dspin_int_rsp_h_inc[x][y][k]);
     1165               clusters[x+1][y]->p_dspin_int_rsp_in[WEST][k]     (signal_dspin_int_rsp_h_inc[x][y][k]);
     1166               clusters[x][y]->p_dspin_int_rsp_in[EAST][k]       (signal_dspin_int_rsp_h_dec[x][y][k]);
     1167               clusters[x+1][y]->p_dspin_int_rsp_out[WEST][k]    (signal_dspin_int_rsp_h_dec[x][y][k]);
    11641168            }
    11651169
     
    11851189         for (size_t x = 0; x < XMAX; x++)
    11861190         {
     1191            for (size_t k = 0; k < 3; k++)
     1192            {
     1193               clusters[x][y]->p_dspin_int_cmd_out[NORTH][k]     (signal_dspin_int_cmd_v_inc[x][y][k]);
     1194               clusters[x][y+1]->p_dspin_int_cmd_in[SOUTH][k]    (signal_dspin_int_cmd_v_inc[x][y][k]);
     1195               clusters[x][y]->p_dspin_int_cmd_in[NORTH][k]      (signal_dspin_int_cmd_v_dec[x][y][k]);
     1196               clusters[x][y+1]->p_dspin_int_cmd_out[SOUTH][k]   (signal_dspin_int_cmd_v_dec[x][y][k]);
     1197            }
     1198
    11871199            for (size_t k = 0; k < 2; k++)
    11881200            {
    1189                clusters[x][y]->p_dspin_int_cmd_out[k][NORTH]     (signal_dspin_int_cmd_v_inc[x][y][k]);
    1190                clusters[x][y+1]->p_dspin_int_cmd_in[k][SOUTH]    (signal_dspin_int_cmd_v_inc[x][y][k]);
    1191                clusters[x][y]->p_dspin_int_cmd_in[k][NORTH]      (signal_dspin_int_cmd_v_dec[x][y][k]);
    1192                clusters[x][y+1]->p_dspin_int_cmd_out[k][SOUTH]   (signal_dspin_int_cmd_v_dec[x][y][k]);
    1193                clusters[x][y]->p_dspin_int_rsp_out[k][NORTH]     (signal_dspin_int_rsp_v_inc[x][y][k]);
    1194                clusters[x][y+1]->p_dspin_int_rsp_in[k][SOUTH]    (signal_dspin_int_rsp_v_inc[x][y][k]);
    1195                clusters[x][y]->p_dspin_int_rsp_in[k][NORTH]      (signal_dspin_int_rsp_v_dec[x][y][k]);
    1196                clusters[x][y+1]->p_dspin_int_rsp_out[k][SOUTH]   (signal_dspin_int_rsp_v_dec[x][y][k]);
     1201               clusters[x][y]->p_dspin_int_rsp_out[NORTH][k]     (signal_dspin_int_rsp_v_inc[x][y][k]);
     1202               clusters[x][y+1]->p_dspin_int_rsp_in[SOUTH][k]    (signal_dspin_int_rsp_v_inc[x][y][k]);
     1203               clusters[x][y]->p_dspin_int_rsp_in[NORTH][k]      (signal_dspin_int_rsp_v_dec[x][y][k]);
     1204               clusters[x][y+1]->p_dspin_int_rsp_out[SOUTH][k]   (signal_dspin_int_rsp_v_dec[x][y][k]);
    11971205            }
    11981206
     
    12141222   for (size_t y = 0; y < YMAX; y++)
    12151223   {
     1224      for (size_t k = 0; k < 3; k++)
     1225      {
     1226         clusters[0][y]->p_dspin_int_cmd_in[WEST][k]          (signal_dspin_false_int_cmd_in[0][y][WEST][k]);
     1227         clusters[0][y]->p_dspin_int_cmd_out[WEST][k]         (signal_dspin_false_int_cmd_out[0][y][WEST][k]);
     1228         clusters[XMAX-1][y]->p_dspin_int_cmd_in[EAST][k]     (signal_dspin_false_int_cmd_in[XMAX-1][y][EAST][k]);
     1229         clusters[XMAX-1][y]->p_dspin_int_cmd_out[EAST][k]    (signal_dspin_false_int_cmd_out[XMAX-1][y][EAST][k]);
     1230      }
     1231
    12161232      for (size_t k = 0; k < 2; k++)
    12171233      {
    1218          clusters[0][y]->p_dspin_int_cmd_in[k][WEST]          (signal_dspin_false_int_cmd_in[0][y][k][WEST]);
    1219          clusters[0][y]->p_dspin_int_cmd_out[k][WEST]         (signal_dspin_false_int_cmd_out[0][y][k][WEST]);
    1220          clusters[0][y]->p_dspin_int_rsp_in[k][WEST]          (signal_dspin_false_int_rsp_in[0][y][k][WEST]);
    1221          clusters[0][y]->p_dspin_int_rsp_out[k][WEST]         (signal_dspin_false_int_rsp_out[0][y][k][WEST]);
    1222 
    1223          clusters[XMAX-1][y]->p_dspin_int_cmd_in[k][EAST]     (signal_dspin_false_int_cmd_in[XMAX-1][y][k][EAST]);
    1224          clusters[XMAX-1][y]->p_dspin_int_cmd_out[k][EAST]    (signal_dspin_false_int_cmd_out[XMAX-1][y][k][EAST]);
    1225          clusters[XMAX-1][y]->p_dspin_int_rsp_in[k][EAST]     (signal_dspin_false_int_rsp_in[XMAX-1][y][k][EAST]);
    1226          clusters[XMAX-1][y]->p_dspin_int_rsp_out[k][EAST]    (signal_dspin_false_int_rsp_out[XMAX-1][y][k][EAST]);
     1234         clusters[0][y]->p_dspin_int_rsp_in[WEST][k]          (signal_dspin_false_int_rsp_in[0][y][WEST][k]);
     1235         clusters[0][y]->p_dspin_int_rsp_out[WEST][k]         (signal_dspin_false_int_rsp_out[0][y][WEST][k]);
     1236         clusters[XMAX-1][y]->p_dspin_int_rsp_in[EAST][k]     (signal_dspin_false_int_rsp_in[XMAX-1][y][EAST][k]);
     1237         clusters[XMAX-1][y]->p_dspin_int_rsp_out[EAST][k]    (signal_dspin_false_int_rsp_out[XMAX-1][y][EAST][k]);
    12271238      }
    12281239
     
    12431254   for (size_t x = 0; x < XMAX; x++)
    12441255   {
     1256      for (size_t k = 0; k < 3; k++)
     1257      {
     1258         clusters[x][0]->p_dspin_int_cmd_in[SOUTH][k]         (signal_dspin_false_int_cmd_in[x][0][SOUTH][k]);
     1259         clusters[x][0]->p_dspin_int_cmd_out[SOUTH][k]        (signal_dspin_false_int_cmd_out[x][0][SOUTH][k]);
     1260         clusters[x][YMAX-1]->p_dspin_int_cmd_in[NORTH][k]    (signal_dspin_false_int_cmd_in[x][YMAX-1][NORTH][k]);
     1261         clusters[x][YMAX-1]->p_dspin_int_cmd_out[NORTH][k]   (signal_dspin_false_int_cmd_out[x][YMAX-1][NORTH][k]);
     1262      }
     1263
    12451264      for (size_t k = 0; k < 2; k++)
    12461265      {
    1247          clusters[x][0]->p_dspin_int_cmd_in[k][SOUTH]         (signal_dspin_false_int_cmd_in[x][0][k][SOUTH]);
    1248          clusters[x][0]->p_dspin_int_cmd_out[k][SOUTH]        (signal_dspin_false_int_cmd_out[x][0][k][SOUTH]);
    1249          clusters[x][0]->p_dspin_int_rsp_in[k][SOUTH]         (signal_dspin_false_int_rsp_in[x][0][k][SOUTH]);
    1250          clusters[x][0]->p_dspin_int_rsp_out[k][SOUTH]        (signal_dspin_false_int_rsp_out[x][0][k][SOUTH]);
    1251 
    1252          clusters[x][YMAX-1]->p_dspin_int_cmd_in[k][NORTH]    (signal_dspin_false_int_cmd_in[x][YMAX-1][k][NORTH]);
    1253          clusters[x][YMAX-1]->p_dspin_int_cmd_out[k][NORTH]   (signal_dspin_false_int_cmd_out[x][YMAX-1][k][NORTH]);
    1254          clusters[x][YMAX-1]->p_dspin_int_rsp_in[k][NORTH]    (signal_dspin_false_int_rsp_in[x][YMAX-1][k][NORTH]);
    1255          clusters[x][YMAX-1]->p_dspin_int_rsp_out[k][NORTH]   (signal_dspin_false_int_rsp_out[x][YMAX-1][k][NORTH]);
     1266         clusters[x][0]->p_dspin_int_rsp_in[SOUTH][k]         (signal_dspin_false_int_rsp_in[x][0][SOUTH][k]);
     1267         clusters[x][0]->p_dspin_int_rsp_out[SOUTH][k]        (signal_dspin_false_int_rsp_out[x][0][SOUTH][k]);
     1268         clusters[x][YMAX-1]->p_dspin_int_rsp_in[NORTH][k]    (signal_dspin_false_int_rsp_in[x][YMAX-1][NORTH][k]);
     1269         clusters[x][YMAX-1]->p_dspin_int_rsp_out[NORTH][k]   (signal_dspin_false_int_rsp_out[x][YMAX-1][NORTH][k]);
    12561270      }
    12571271
     
    12831297         for (size_t a = 0; a < 4; a++)
    12841298         {
     1299            for (size_t k = 0; k < 3; k++)
     1300            {
     1301               signal_dspin_false_int_cmd_in[x][y][a][k].write = false;
     1302               signal_dspin_false_int_cmd_in[x][y][a][k].read = true;
     1303               signal_dspin_false_int_cmd_out[x][y][a][k].write = false;
     1304               signal_dspin_false_int_cmd_out[x][y][a][k].read = true;
     1305            }
     1306
    12851307            for (size_t k = 0; k < 2; k++)
    12861308            {
    1287                signal_dspin_false_int_cmd_in[x][y][k][a].write = false;
    1288                signal_dspin_false_int_cmd_in[x][y][k][a].read = true;
    1289                signal_dspin_false_int_cmd_out[x][y][k][a].write = false;
    1290                signal_dspin_false_int_cmd_out[x][y][k][a].read = true;
    1291 
    1292                signal_dspin_false_int_rsp_in[x][y][k][a].write = false;
    1293                signal_dspin_false_int_rsp_in[x][y][k][a].read = true;
    1294                signal_dspin_false_int_rsp_out[x][y][k][a].write = false;
    1295                signal_dspin_false_int_rsp_out[x][y][k][a].read = true;
     1309               signal_dspin_false_int_rsp_in[x][y][a][k].write = false;
     1310               signal_dspin_false_int_rsp_in[x][y][a][k].read = true;
     1311               signal_dspin_false_int_rsp_out[x][y][a][k].write = false;
     1312               signal_dspin_false_int_rsp_out[x][y][a][k].read = true;
    12961313            }
    12971314
  • trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/metadata/tsar_iob_cluster.sd

    r450 r468  
    108108                Port('caba:clock_in', 'p_clk', auto = 'clock'),
    109109
    110                 Port('caba:dspin_output', 'p_int_cmd_out', [2, 4],
     110                Port('caba:dspin_output', 'p_int_cmd_out', [4, 3],
    111111              dspin_data_size = parameter.Reference('dspin_int_cmd_width')),
    112                 Port('caba:dspin_input', 'p_int_cmd_in', [2, 4],
     112                Port('caba:dspin_input', 'p_int_cmd_in', [4, 3],
    113113              dspin_data_size = parameter.Reference('dspin_int_cmd_width')),
    114                 Port('caba:dspin_output', 'p_int_rsp_out', [2, 4],
     114                Port('caba:dspin_output', 'p_int_rsp_out', [4, 2],
    115115              dspin_data_size = parameter.Reference('dspin_int_rsp_width')),
    116                 Port('caba:dspin_input', 'p_int_rsp_in', [2, 4],
     116                Port('caba:dspin_input', 'p_int_rsp_in', [4, 2],
    117117              dspin_data_size = parameter.Reference('dspin_int_rsp_width')),
    118118
    119                 Port('caba:dspin_output', 'p_ext_cmd_out', [2, 4],
     119                Port('caba:dspin_output', 'p_ram_cmd_out', [4],
    120120              dspin_data_size = parameter.Reference('dspin_ram_cmd_width')),
    121                 Port('caba:dspin_input', 'p_ext_cmd_in', [2, 4],
     121                Port('caba:dspin_input', 'p_ram_cmd_in', [4],
    122122              dspin_data_size = parameter.Reference('dspin_ram_cmd_width')),
    123                 Port('caba:dspin_output', 'p_ext_rsp_out', [2, 4],
     123                Port('caba:dspin_output', 'p_ram_rsp_out', [4],
    124124              dspin_data_size = parameter.Reference('dspin_ram_rsp_width')),
    125                 Port('caba:dspin_input', 'p_ext_rsp_in', [2, 4],
     125                Port('caba:dspin_input', 'p_ram_rsp_in', [4],
    126126              dspin_data_size = parameter.Reference('dspin_ram_rsp_width')),
    127127                ],
  • trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/source/include/tsar_iob_cluster.h

    r450 r468  
    7777        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_m2p_l2g_c;
    7878        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_m2p_g2l_c;
     79        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_clack_l2g_c;
     80        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_clack_g2l_c;
    7981        DspinSignals<dspin_int_rsp_width>     signal_int_dspin_rsp_l2g_d;
    8082        DspinSignals<dspin_int_rsp_width>     signal_int_dspin_rsp_g2l_d;
     
    111113        // Coherence DSPIN signals between DSPIN local crossbars and CC components
    112114        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_m2p_memc;
     115        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_clack_memc;
    113116        DspinSignals<dspin_int_rsp_width>     signal_int_dspin_p2m_memc;
    114117        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_m2p_proc[8];
     118        DspinSignals<dspin_int_cmd_width>     signal_int_dspin_clack_proc[8];
    115119        DspinSignals<dspin_int_rsp_width>     signal_int_dspin_p2m_proc[8];
    116120
     
    179183    DspinLocalCrossbar<dspin_int_cmd_width>*          int_xbar_m2p_c;
    180184    DspinLocalCrossbar<dspin_int_rsp_width>*          int_xbar_p2m_c;
     185    DspinLocalCrossbar<dspin_int_cmd_width>*          int_xbar_clack_c;
    181186
    182187    VirtualDspinRouter<dspin_int_cmd_width>*          int_router_cmd;
  • trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/source/src/tsar_iob_cluster.cpp

    r450 r468  
    8989
    9090    // Vectors of DSPIN ports for inter-cluster communications
    91     p_dspin_int_cmd_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_cmd_in", 2, 4);
    92     p_dspin_int_cmd_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_cmd_out", 2, 4);
    93     p_dspin_int_rsp_in  = alloc_elems<DspinInput<dspin_int_rsp_width> >("p_int_rsp_in", 2, 4);
    94     p_dspin_int_rsp_out = alloc_elems<DspinOutput<dspin_int_rsp_width> >("p_int_rsp_out", 2, 4);
     91    p_dspin_int_cmd_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_cmd_in", 4, 3);
     92    p_dspin_int_cmd_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_cmd_out", 4, 3);
     93    p_dspin_int_rsp_in  = alloc_elems<DspinInput<dspin_int_rsp_width> >("p_int_rsp_in", 4, 2);
     94    p_dspin_int_rsp_out = alloc_elems<DspinOutput<dspin_int_rsp_width> >("p_int_rsp_out", 4, 2);
    9595
    9696    p_dspin_ram_cmd_in  = alloc_elems<DspinInput<dspin_ram_cmd_width> >("p_ext_cmd_in", 4);
     
    171171                     8,                                  // TRANSACTION TABLE DEPTH
    172172                     8,                                  // UPDATE TABLE DEPTH
     173                     8,                                  // INVALIDATE TABLE DEPTH
    173174                     debug_start_cycle,
    174175                     memc_debug_ok );
     
    303304                     false );                      // no broacast
    304305
     306    std::ostringstream s_int_xbar_clack_c;
     307    s_int_xbar_clack_c << "int_xbar_clack_c_" << x_id << "_" << y_id;
     308    int_xbar_clack_c = new DspinLocalCrossbar<dspin_int_cmd_width>(
     309                     s_int_xbar_clack_c.str().c_str(),
     310                     mt_int,                       // mapping table
     311                     x_id, y_id,                   // cluster coordinates
     312                     x_width, y_width, l_width,
     313                     1,                            // number of local sources
     314                     nb_procs,                     // number of local targets
     315                     1, 1,                         // fifo depths
     316                     true,                         // CMD
     317                     false,                        // don't use local routing table
     318                     false);                       // broadcast
     319
    305320    //////////////  INT ROUTER(S)
    306321    std::ostringstream s_int_router_cmd;
     
    310325                     x_id,y_id,                    // coordinate in the mesh
    311326                     x_width, y_width,             // x & y fields width
     327                     3,                            // nb virtual channels
    312328                     4,4);                         // input & output fifo depths
    313329
     
    318334                     x_id,y_id,                    // coordinates in mesh
    319335                     x_width, y_width,             // x & y fields width
     336                     2,                            // nb virtual channels
    320337                     4,4);                         // input & output fifo depths
    321338
     
    459476    int_router_rsp->p_clk                        (this->p_clk);
    460477    int_router_rsp->p_resetn                     (this->p_resetn);
    461     for (int x = 0; x < 2; x++)
    462     {
    463         for(int y = 0; y < 4; y++)
     478
     479    for (int i = 0; i < 4; i++)
     480    {
     481        for(int k = 0; k < 3; k++)
    464482        {
    465             int_router_cmd->p_out[x][y]          (this->p_dspin_int_cmd_out[x][y]);
    466             int_router_cmd->p_in[x][y]           (this->p_dspin_int_cmd_in[x][y]);
    467             int_router_rsp->p_out[x][y]          (this->p_dspin_int_rsp_out[x][y]);
    468             int_router_rsp->p_in[x][y]           (this->p_dspin_int_rsp_in[x][y]);
     483            int_router_cmd->p_out[i][k]          (this->p_dspin_int_cmd_out[i][k]);
     484            int_router_cmd->p_in[i][k]           (this->p_dspin_int_cmd_in[i][k]);
    469485        }
     486
     487        for(int k = 0; k < 2; k++)
     488        {
     489            int_router_rsp->p_out[i][k]          (this->p_dspin_int_rsp_out[i][k]);
     490            int_router_rsp->p_in[i][k]           (this->p_dspin_int_rsp_in[i][k]);
     491        }
    470492    }
    471493
    472494    // local ports
    473     int_router_cmd->p_out[0][4]                  (signal_int_dspin_cmd_g2l_d);
    474     int_router_cmd->p_out[1][4]                  (signal_int_dspin_m2p_g2l_c);
    475     int_router_cmd->p_in[0][4]                   (signal_int_dspin_cmd_l2g_d);
    476     int_router_cmd->p_in[1][4]                   (signal_int_dspin_m2p_l2g_c);
     495    int_router_cmd->p_out[4][0]                  (signal_int_dspin_cmd_g2l_d);
     496    int_router_cmd->p_out[4][1]                  (signal_int_dspin_m2p_g2l_c);
     497    int_router_cmd->p_out[4][2]                  (signal_int_dspin_clack_g2l_c);
     498    int_router_cmd->p_in[4][0]                   (signal_int_dspin_cmd_l2g_d);
     499    int_router_cmd->p_in[4][1]                   (signal_int_dspin_m2p_l2g_c);
     500    int_router_cmd->p_in[4][2]                   (signal_int_dspin_clack_l2g_c);
    477501   
    478     int_router_rsp->p_out[0][4]                  (signal_int_dspin_rsp_g2l_d);
    479     int_router_rsp->p_out[1][4]                  (signal_int_dspin_p2m_g2l_c);
    480     int_router_rsp->p_in[0][4]                   (signal_int_dspin_rsp_l2g_d);
    481     int_router_rsp->p_in[1][4]                   (signal_int_dspin_p2m_l2g_c);
     502    int_router_rsp->p_out[4][0]                  (signal_int_dspin_rsp_g2l_d);
     503    int_router_rsp->p_out[4][1]                  (signal_int_dspin_p2m_g2l_c);
     504    int_router_rsp->p_in[4][0]                   (signal_int_dspin_rsp_l2g_d);
     505    int_router_rsp->p_in[4][1]                   (signal_int_dspin_p2m_l2g_c);
    482506
    483507    ///////////////////// CMD DSPIN  local crossbar direct
     
    541565        int_xbar_p2m_c->p_local_in[p]            (signal_int_dspin_p2m_proc[p]);
    542566
     567    ////////////////////// CLACK DSPIN local crossbar coherence
     568    int_xbar_clack_c->p_clk                      (this->p_clk);
     569    int_xbar_clack_c->p_resetn                   (this->p_resetn);
     570    int_xbar_clack_c->p_global_out               (signal_int_dspin_clack_l2g_c);
     571    int_xbar_clack_c->p_global_in                (signal_int_dspin_clack_g2l_c);
     572    int_xbar_clack_c->p_local_in[0]              (signal_int_dspin_clack_memc);
     573    for (size_t p = 0; p < nb_procs; p++)
     574        int_xbar_clack_c->p_local_out[p]         (signal_int_dspin_clack_proc[p]);
     575
    543576    //////////////////////////////////// Processors
    544577    for (size_t p = 0; p < nb_procs; p++)
     
    547580        proc[p]->p_resetn                        (this->p_resetn);
    548581        proc[p]->p_vci                           (signal_int_vci_ini_proc[p]);
    549         proc[p]->p_dspin_in                      (signal_int_dspin_m2p_proc[p]);
    550         proc[p]->p_dspin_out                     (signal_int_dspin_p2m_proc[p]);
     582        proc[p]->p_dspin_m2p                     (signal_int_dspin_m2p_proc[p]);
     583        proc[p]->p_dspin_p2m                     (signal_int_dspin_p2m_proc[p]);
     584        proc[p]->p_dspin_clack                   (signal_int_dspin_clack_proc[p]);
    551585        proc[p]->p_irq[0]                        (signal_proc_it[p]);
    552586        for ( size_t j = 1 ; j < 6 ; j++)
     
    563597
    564598    ///////////////////////////////////// XICU
    565     xicu->p_clk                                   (this->p_clk);
    566     xicu->p_resetn                                (this->p_resetn);
    567     xicu->p_vci                                   (signal_int_vci_tgt_xicu);
     599    xicu->p_clk                                  (this->p_clk);
     600    xicu->p_resetn                               (this->p_resetn);
     601    xicu->p_vci                                  (signal_int_vci_tgt_xicu);
    568602    for ( size_t p=0 ; p<nb_procs ; p++)
    569603    {
    570         xicu->p_irq[p]                            (signal_proc_it[p]);
     604        xicu->p_irq[p]                           (signal_proc_it[p]);
    571605    }
    572606    for ( size_t i=0 ; i<4 ; i++)
     
    590624
    591625    ///////////////////////////////////// MEMC
    592     memc->p_clk                                   (this->p_clk);
    593     memc->p_resetn                                (this->p_resetn);
    594     memc->p_vci_ixr                               (signal_ram_vci_ini_memc);
    595     memc->p_vci_tgt                               (signal_int_vci_tgt_memc);
    596     memc->p_dspin_in                             (signal_int_dspin_p2m_memc);
    597     memc->p_dspin_out                           (signal_int_dspin_m2p_memc);
     626    memc->p_clk                                  (this->p_clk);
     627    memc->p_resetn                               (this->p_resetn);
     628    memc->p_vci_ixr                              (signal_ram_vci_ini_memc);
     629    memc->p_vci_tgt                              (signal_int_vci_tgt_memc);
     630    memc->p_dspin_p2m                            (signal_int_dspin_p2m_memc);
     631    memc->p_dspin_m2p                            (signal_int_dspin_m2p_memc);
     632    memc->p_dspin_clack                          (signal_int_dspin_clack_memc);
    598633
    599634    // wrapper to INT network
     
    612647
    613648    //////////////////////////////////// XRAM
    614     xram->p_clk                                   (this->p_clk);
    615     xram->p_resetn                                (this->p_resetn);
    616     xram->p_vci                                         (signal_ram_vci_tgt_xram);
     649    xram->p_clk                                  (this->p_clk);
     650    xram->p_resetn                               (this->p_resetn);
     651    xram->p_vci                                  (signal_ram_vci_tgt_xram);
    617652
    618653    // wrapper to RAM network
     
    624659
    625660    /////////////////////////////////// MDMA
    626     mdma->p_clk                                   (this->p_clk);
     661    mdma->p_clk                                  (this->p_clk);
    627662    mdma->p_resetn                               (this->p_resetn);
    628     mdma->p_vci_target                            (signal_int_vci_tgt_mdma);
    629     mdma->p_vci_initiator                         (signal_int_vci_ini_mdma);
     663    mdma->p_vci_target                           (signal_int_vci_tgt_mdma);
     664    mdma->p_vci_initiator                        (signal_int_vci_ini_mdma);
    630665    for (size_t i=0 ; i<nb_dmas ; i++)
    631666        mdma->p_irq[i]                           (signal_irq_mdma[i]);
  • trunk/platforms/tsar_generic_xbar

  • trunk/platforms/tsar_generic_xbar/Makefile

    r450 r468  
    11simul.x: top.cpp top.desc
    2         soclib-cc -j3 -P -p top.desc -I. -o simul.x
     2        soclib-cc -t mysystemcass -j8 -P -p top.desc -I. -o simul.x
    33
    44clean:
    55        soclib-cc -x -p top.desc -I.
    6         rm -rf *.o *.x tty*
     6        rm -rf *.o *.x term*
  • trunk/platforms/tsar_generic_xbar/soclib.conf

    r379 r468  
     1import os;
    12
    2 config.addDescPath("/Users/alain/soc/tsar-trunk-svn-2013/")
     3desc_path = os.environ['HOME'] + "/Workspace/repo/tsar/trunk"
     4
     5config.mylibsystemcass.cflags += ['-fpermissive']
     6config.addDescPath(desc_path)
     7
     8# vim: filetype=python
  • trunk/platforms/tsar_generic_xbar/top.cpp

    r465 r468  
    151151//////////////////////i/////////////////////////////////////
    152152
    153 
    154153#ifdef USE_ALMOS
    155154#include "almos/hard_config.h"
     
    157156#endif
    158157#ifdef USE_GIET
     158#include "giet_vm/hard_config.h"
    159159#define PREFIX_OS "giet_vm/"
    160 #include "giet_vm/hard_config.h"
    161160#endif
    162161
     
    190189#ifdef USE_GIET
    191190#define BDEV_SECTOR_SIZE      512
    192 #define BDEV_IMAGE_NAME       "giet_vm/display/images.raw"
     191#define BDEV_IMAGE_NAME       PREFIX_OS"display/images.raw"
    193192#endif
    194193#ifdef USE_ALMOS
     
    196195#define BDEV_IMAGE_NAME       PREFIX_OS"hdd-img.bin"
    197196#endif
    198 
    199197
    200198#define NIC_RX_NAME           PREFIX_OS"nic/rx_packets.txt"
     
    212210
    213211#ifdef USE_ALMOS
    214 #define soft_name PREFIX_OS"bootloader.bin",\
    215                   PREFIX_OS"kernel-soclib.bin@0xbfc10000:D",\
    216                   PREFIX_OS"arch-info.bib@0xBFC08000:D"
     212#define soft_name       PREFIX_OS"bootloader.bin",\
     213                        PREFIX_OS"kernel-soclib.bin@0xbfc10000:D",\
     214                        PREFIX_OS"arch-info.bib@0xBFC08000:D"
    217215#endif
    218216#ifdef USE_GIET
    219 #define soft_pathname        PREFIX_OS"soft.elf"
     217#define soft_pathname   PREFIX_OS"soft.elf"
    220218#endif
    221219
     
    285283
    286284#ifdef USE_GIET
    287    char     soft_name[256]   = soft_pathname;          // pathname to binary code
    288 #endif
    289    size_t   ncycles          = 1000000000;         // simulated cycles
     285   char     soft_name[256]   = soft_pathname;      // pathname to binary code
     286#endif
     287   uint64_t ncycles          = 100000000000;       // simulated cycles
    290288   char     disk_name[256]   = BDEV_IMAGE_NAME;    // pathname to the disk image
    291289   char     nic_rx_name[256] = NIC_RX_NAME;        // pathname to the rx packets file
     
    299297   uint32_t frozen_cycles    = MAX_FROZEN_CYCLES;  // monitoring frozen processor
    300298   size_t   cluster_io_id    = 0;                  // index of cluster containing IOs
    301    struct timeval t1,t2;
     299   struct   timeval t1,t2;
    302300   uint64_t ms1,ms2;
    303301
     
    541539   // Horizontal inter-clusters DSPIN signals
    542540   DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_inc =
    543       alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", XMAX-1, YMAX, 2);
     541      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", XMAX-1, YMAX, 3);
    544542   DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_dec =
    545       alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", XMAX-1, YMAX, 2);
     543      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", XMAX-1, YMAX, 3);
    546544   DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_inc =
    547545      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_inc", XMAX-1, YMAX, 2);
     
    551549   // Vertical inter-clusters DSPIN signals
    552550   DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_inc =
    553       alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", XMAX, YMAX-1, 2);
     551      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", XMAX, YMAX-1, 3);
    554552   DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_dec =
    555       alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", XMAX, YMAX-1, 2);
     553      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", XMAX, YMAX-1, 3);
    556554   DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_inc =
    557555      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_inc", XMAX, YMAX-1, 2);
     
    561559   // Mesh boundaries DSPIN signals
    562560   DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_in =
    563       alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_in", XMAX, YMAX, 2, 4);
     561      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_in" , XMAX, YMAX, 4, 3);
    564562   DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_out =
    565       alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_out", XMAX, YMAX, 2, 4);
     563      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_out", XMAX, YMAX, 4, 3);
    566564   DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_in =
    567       alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_in", XMAX, YMAX, 2, 4);
     565      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_in" , XMAX, YMAX, 4, 2);
    568566   DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_out =
    569       alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_out", XMAX, YMAX, 2, 4);
     567      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_out", XMAX, YMAX, 4, 2);
    570568
    571569
     
    680678      for (size_t x = 0; x < (XMAX-1); x++){
    681679         for (size_t y = 0; y < YMAX; y++){
    682             for (size_t k = 0; k < 2; k++){
     680            for (size_t k = 0; k < 3; k++){
    683681               clusters[x][y]->p_cmd_out[EAST][k]      (signal_dspin_h_cmd_inc[x][y][k]);
    684682               clusters[x+1][y]->p_cmd_in[WEST][k]     (signal_dspin_h_cmd_inc[x][y][k]);
    685683               clusters[x][y]->p_cmd_in[EAST][k]       (signal_dspin_h_cmd_dec[x][y][k]);
    686684               clusters[x+1][y]->p_cmd_out[WEST][k]    (signal_dspin_h_cmd_dec[x][y][k]);
     685            }
     686
     687            for (size_t k = 0; k < 2; k++){
    687688               clusters[x][y]->p_rsp_out[EAST][k]      (signal_dspin_h_rsp_inc[x][y][k]);
    688689               clusters[x+1][y]->p_rsp_in[WEST][k]     (signal_dspin_h_rsp_inc[x][y][k]);
     
    699700      for (size_t y = 0; y < (YMAX-1); y++){
    700701         for (size_t x = 0; x < XMAX; x++){
    701             for (size_t k = 0; k < 2; k++){
     702            for (size_t k = 0; k < 3; k++){
    702703               clusters[x][y]->p_cmd_out[NORTH][k]     (signal_dspin_v_cmd_inc[x][y][k]);
    703704               clusters[x][y+1]->p_cmd_in[SOUTH][k]    (signal_dspin_v_cmd_inc[x][y][k]);
    704705               clusters[x][y]->p_cmd_in[NORTH][k]      (signal_dspin_v_cmd_dec[x][y][k]);
    705706               clusters[x][y+1]->p_cmd_out[SOUTH][k]   (signal_dspin_v_cmd_dec[x][y][k]);
     707            }
     708
     709            for (size_t k = 0; k < 2; k++){
    706710               clusters[x][y]->p_rsp_out[NORTH][k]     (signal_dspin_v_rsp_inc[x][y][k]);
    707711               clusters[x][y+1]->p_rsp_in[SOUTH][k]    (signal_dspin_v_rsp_inc[x][y][k]);
     
    717721   for (size_t y = 0; y < YMAX; y++)
    718722   {
     723      for (size_t k = 0; k < 3; k++)
     724      {
     725         clusters[0][y]->p_cmd_in[WEST][k]        (signal_dspin_false_cmd_in[0][y][WEST][k]);
     726         clusters[0][y]->p_cmd_out[WEST][k]       (signal_dspin_false_cmd_out[0][y][WEST][k]);
     727         clusters[XMAX-1][y]->p_cmd_in[EAST][k]   (signal_dspin_false_cmd_in[XMAX-1][y][EAST][k]);
     728         clusters[XMAX-1][y]->p_cmd_out[EAST][k]  (signal_dspin_false_cmd_out[XMAX-1][y][EAST][k]);
     729      }
     730
    719731      for (size_t k = 0; k < 2; k++)
    720732      {
    721          clusters[0][y]->p_cmd_in[WEST][k]             (signal_dspin_false_cmd_in[0][y][k][WEST]);
    722          clusters[0][y]->p_cmd_out[WEST][k]            (signal_dspin_false_cmd_out[0][y][k][WEST]);
    723          clusters[0][y]->p_rsp_in[WEST][k]             (signal_dspin_false_rsp_in[0][y][k][WEST]);
    724          clusters[0][y]->p_rsp_out[WEST][k]            (signal_dspin_false_rsp_out[0][y][k][WEST]);
    725 
    726          clusters[XMAX-1][y]->p_cmd_in[EAST][k]   (signal_dspin_false_cmd_in[XMAX-1][y][k][EAST]);
    727          clusters[XMAX-1][y]->p_cmd_out[EAST][k]  (signal_dspin_false_cmd_out[XMAX-1][y][k][EAST]);
    728          clusters[XMAX-1][y]->p_rsp_in[EAST][k]   (signal_dspin_false_rsp_in[XMAX-1][y][k][EAST]);
    729          clusters[XMAX-1][y]->p_rsp_out[EAST][k]  (signal_dspin_false_rsp_out[XMAX-1][y][k][EAST]);
     733         clusters[0][y]->p_rsp_in[WEST][k]        (signal_dspin_false_rsp_in[0][y][WEST][k]);
     734         clusters[0][y]->p_rsp_out[WEST][k]       (signal_dspin_false_rsp_out[0][y][WEST][k]);
     735         clusters[XMAX-1][y]->p_rsp_in[EAST][k]   (signal_dspin_false_rsp_in[XMAX-1][y][EAST][k]);
     736         clusters[XMAX-1][y]->p_rsp_out[EAST][k]  (signal_dspin_false_rsp_out[XMAX-1][y][EAST][k]);
    730737      }
    731738   }
     
    734741   for (size_t x = 0; x < XMAX; x++)
    735742   {
     743      for (size_t k = 0; k < 3; k++)
     744      {
     745         clusters[x][0]->p_cmd_in[SOUTH][k]       (signal_dspin_false_cmd_in[x][0][SOUTH][k]);
     746         clusters[x][0]->p_cmd_out[SOUTH][k]      (signal_dspin_false_cmd_out[x][0][SOUTH][k]);
     747         clusters[x][YMAX-1]->p_cmd_in[NORTH][k]  (signal_dspin_false_cmd_in[x][YMAX-1][NORTH][k]);
     748         clusters[x][YMAX-1]->p_cmd_out[NORTH][k] (signal_dspin_false_cmd_out[x][YMAX-1][NORTH][k]);
     749      }
     750
    736751      for (size_t k = 0; k < 2; k++)
    737752      {
    738          clusters[x][0]->p_cmd_in[SOUTH][k]            (signal_dspin_false_cmd_in[x][0][k][SOUTH]);
    739          clusters[x][0]->p_cmd_out[SOUTH][k]           (signal_dspin_false_cmd_out[x][0][k][SOUTH]);
    740          clusters[x][0]->p_rsp_in[SOUTH][k]            (signal_dspin_false_rsp_in[x][0][k][SOUTH]);
    741          clusters[x][0]->p_rsp_out[SOUTH][k]           (signal_dspin_false_rsp_out[x][0][k][SOUTH]);
    742 
    743          clusters[x][YMAX-1]->p_cmd_in[NORTH][k]  (signal_dspin_false_cmd_in[x][YMAX-1][k][NORTH]);
    744          clusters[x][YMAX-1]->p_cmd_out[NORTH][k] (signal_dspin_false_cmd_out[x][YMAX-1][k][NORTH]);
    745          clusters[x][YMAX-1]->p_rsp_in[NORTH][k]  (signal_dspin_false_rsp_in[x][YMAX-1][k][NORTH]);
    746          clusters[x][YMAX-1]->p_rsp_out[NORTH][k] (signal_dspin_false_rsp_out[x][YMAX-1][k][NORTH]);
     753         clusters[x][0]->p_rsp_in[SOUTH][k]       (signal_dspin_false_rsp_in[x][0][SOUTH][k]);
     754         clusters[x][0]->p_rsp_out[SOUTH][k]      (signal_dspin_false_rsp_out[x][0][SOUTH][k]);
     755         clusters[x][YMAX-1]->p_rsp_in[NORTH][k]  (signal_dspin_false_rsp_in[x][YMAX-1][NORTH][k]);
     756         clusters[x][YMAX-1]->p_rsp_out[NORTH][k] (signal_dspin_false_rsp_out[x][YMAX-1][NORTH][k]);
    747757      }
    748758   }
     
    761771   for (size_t x = 0; x < XMAX ; x++){
    762772      for (size_t y = 0; y < YMAX ; y++){
    763          for (size_t k = 0; k < 2; k++){
    764             for (size_t a = 0; a < 4; a++){
    765                signal_dspin_false_cmd_in [x][y][k][a].write = false;
    766                signal_dspin_false_cmd_in [x][y][k][a].read  = true;
    767                signal_dspin_false_cmd_out[x][y][k][a].write = false;
    768                signal_dspin_false_cmd_out[x][y][k][a].read  = true;
    769 
    770                signal_dspin_false_rsp_in [x][y][k][a].write = false;
    771                signal_dspin_false_rsp_in [x][y][k][a].read  = true;
    772                signal_dspin_false_rsp_out[x][y][k][a].write = false;
    773                signal_dspin_false_rsp_out[x][y][k][a].read  = true;
     773         for (size_t a = 0; a < 4; a++){
     774            for (size_t k = 0; k < 3; k++){
     775               signal_dspin_false_cmd_in [x][y][a][k].write = false;
     776               signal_dspin_false_cmd_in [x][y][a][k].read  = true;
     777               signal_dspin_false_cmd_out[x][y][a][k].write = false;
     778               signal_dspin_false_cmd_out[x][y][a][k].read  = true;
     779            }
     780
     781            for (size_t k = 0; k < 2; k++){
     782               signal_dspin_false_rsp_in [x][y][a][k].write = false;
     783               signal_dspin_false_rsp_in [x][y][a][k].read  = true;
     784               signal_dspin_false_rsp_out[x][y][a][k].write = false;
     785               signal_dspin_false_rsp_out[x][y][a][k].read  = true;
    774786            }
    775787         }
     
    786798   }
    787799
    788    for (size_t n = 1; n < ncycles; n++)
     800   for (uint64_t n = 1; n < ncycles; n++)
    789801   {
    790802      // Monitor a specific address for L1 & L2 caches
     
    811823         }
    812824      }
    813 
    814825
    815826      if (debug_ok and (n > debug_from) and (n % debug_period == 0))
  • trunk/platforms/tsar_generic_xbar/tsar_xbar_cluster/caba/metadata/tsar_xbar_cluster.sd

    r437 r468  
    5757        Uses('caba:virtual_dspin_router',
    5858              flit_width      = parameter.Reference('dspin_rsp_width')),
    59            
     59
    6060        Uses('caba:vci_multi_tty',
    6161              cell_size       = parameter.Reference('vci_data_width_int')),
     
    8585                Port('caba:bit_in', 'p_resetn', auto = 'resetn'),
    8686                Port('caba:clock_in', 'p_clk', auto = 'clock'),
    87                 Port('caba:dspin_output', 'p_cmd_out', [2, 4],
     87                Port('caba:dspin_output', 'p_cmd_out', [4, 3],
    8888              dspin_data_size = parameter.Reference('dspin_cmd_width')),
    89                 Port('caba:dspin_input', 'p_cmd_in', [2, 4],
     89                Port('caba:dspin_input', 'p_cmd_in', [4, 3],
    9090              dspin_data_size = parameter.Reference('dspin_cmd_width')),
    91                 Port('caba:dspin_output', 'p_rsp_out', [2, 4],
     91                Port('caba:dspin_output', 'p_rsp_out', [4, 2],
    9292              dspin_data_size = parameter.Reference('dspin_rsp_width')),
    93                 Port('caba:dspin_input', 'p_rsp_in', [2, 4],
     93                Port('caba:dspin_input', 'p_rsp_in', [4, 2],
    9494              dspin_data_size = parameter.Reference('dspin_rsp_width')),
    9595                ],
  • trunk/platforms/tsar_generic_xbar/tsar_xbar_cluster/caba/source/include/tsar_xbar_cluster.h

    r436 r468  
    6969    DspinSignals<dspin_cmd_width>   signal_dspin_m2p_l2g_c;
    7070    DspinSignals<dspin_cmd_width>   signal_dspin_m2p_g2l_c;
     71    DspinSignals<dspin_cmd_width>   signal_dspin_clack_l2g_c;
     72    DspinSignals<dspin_cmd_width>   signal_dspin_clack_g2l_c;
    7173    DspinSignals<dspin_rsp_width>   signal_dspin_rsp_l2g_d;
    7274    DspinSignals<dspin_rsp_width>   signal_dspin_rsp_g2l_d;
     
    115117    // Coherence DSPIN signals to local crossbar
    116118    DspinSignals<dspin_cmd_width>     signal_dspin_m2p_memc;
     119    DspinSignals<dspin_cmd_width>     signal_dspin_clack_memc;
    117120    DspinSignals<dspin_rsp_width>     signal_dspin_p2m_memc;
    118121    DspinSignals<dspin_cmd_width>     signal_dspin_m2p_proc[8];
     122    DspinSignals<dspin_cmd_width>     signal_dspin_clack_proc[8];
    119123    DspinSignals<dspin_rsp_width>     signal_dspin_p2m_proc[8];
    120124
     
    198202    DspinLocalCrossbar<dspin_cmd_width>*          xbar_m2p_c;
    199203    DspinLocalCrossbar<dspin_rsp_width>*          xbar_p2m_c;
     204    DspinLocalCrossbar<dspin_cmd_width>*          xbar_clack_c;
    200205
    201206    VirtualDspinRouter<dspin_cmd_width>*          router_cmd;
  • trunk/platforms/tsar_generic_xbar/tsar_xbar_cluster/caba/source/src/tsar_xbar_cluster.cpp

    r465 r468  
    8585{
    8686    // Vectors of ports definition
    87     p_cmd_in        = alloc_elems<DspinInput<dspin_cmd_width> >("p_cmd_in", 4, 2);
    88     p_cmd_out       = alloc_elems<DspinOutput<dspin_cmd_width> >("p_cmd_out", 4, 2);
     87    p_cmd_in        = alloc_elems<DspinInput<dspin_cmd_width> >("p_cmd_in", 4, 3);
     88    p_cmd_out       = alloc_elems<DspinOutput<dspin_cmd_width> >("p_cmd_out", 4, 3);
    8989    p_rsp_in        = alloc_elems<DspinInput<dspin_rsp_width> >("p_rsp_in", 4, 2);
    9090    p_rsp_out       = alloc_elems<DspinOutput<dspin_rsp_width> >("p_rsp_out", 4, 2);
     
    148148                     8,                                  // TRANSACTION TABLE DEPTH
    149149                     8,                                  // UPDATE TABLE DEPTH
     150                     8,                                  // INVALIDATE TABLE DEPTH
    150151                     debug_start_cycle,
    151152                     memc_debug_ok );
     
    269270
    270271    /////////////////////////////////////////////////////////////////////////////
     272    xbar_clack_c = new DspinLocalCrossbar<dspin_cmd_width>(
     273                     "xbar_clack_c",
     274                     mtd,                          // mapping table
     275                     x_id, y_id,                   // cluster coordinates
     276                     x_width, y_width, l_width,
     277                     1,                            // number of local sources
     278                     nb_procs,                     // number of local targets
     279                     1, 1,                         // fifo depths
     280                     true,                         // CMD
     281                     false,                        // don't use local routing table
     282                     false);                       // broadcast
     283
     284    /////////////////////////////////////////////////////////////////////////////
    271285    router_cmd = new VirtualDspinRouter<dspin_cmd_width>(
    272286                     "router_cmd",
    273287                     x_id,y_id,                    // coordinate in the mesh
    274288                     x_width, y_width,             // x & y fields width
    275                      2,                            // nb virtual channels
     289                     3,                            // nb virtual channels
    276290                     4,4);                         // input & output fifo depths
    277291
     
    385399    for(int i = 0; i < 4; i++)
    386400    {
    387         for (int k = 0; k < 2; k++)
     401        for (int k = 0; k < 3; k++)
    388402        {
    389403            router_cmd->p_out[i][k]          (this->p_cmd_out[i][k]);
    390404            router_cmd->p_in[i][k]           (this->p_cmd_in[i][k]);
     405        }
     406
     407        for (int k = 0; k < 2; k++)
     408        {
    391409            router_rsp->p_out[i][k]          (this->p_rsp_out[i][k]);
    392410            router_rsp->p_in[i][k]           (this->p_rsp_in[i][k]);
     
    396414    router_cmd->p_out[4][0]                  (signal_dspin_cmd_g2l_d);
    397415    router_cmd->p_out[4][1]                  (signal_dspin_m2p_g2l_c);
     416    router_cmd->p_out[4][2]                  (signal_dspin_clack_g2l_c);
    398417    router_cmd->p_in[4][0]                   (signal_dspin_cmd_l2g_d);
    399418    router_cmd->p_in[4][1]                   (signal_dspin_m2p_l2g_c);
     419    router_cmd->p_in[4][2]                   (signal_dspin_clack_l2g_c);
    400420
    401421    router_rsp->p_out[4][0]                  (signal_dspin_rsp_g2l_d);
     
    403423    router_rsp->p_in[4][0]                   (signal_dspin_rsp_l2g_d);
    404424    router_rsp->p_in[4][1]                   (signal_dspin_p2m_l2g_c);
     425
    405426
    406427    std::cout << "  - CMD & RSP routers connected" << std::endl;
     
    473494    std::cout << "  - M2P Coherence crossbar connected" << std::endl;
    474495
     496    ////////////////////// CLACK DSPIN local crossbar coherence
     497    xbar_clack_c->p_clk                          (this->p_clk);
     498    xbar_clack_c->p_resetn                       (this->p_resetn);
     499    xbar_clack_c->p_global_out                   (signal_dspin_clack_l2g_c);
     500    xbar_clack_c->p_global_in                    (signal_dspin_clack_g2l_c);
     501    xbar_clack_c->p_local_in[0]                  (signal_dspin_clack_memc);
     502    for (size_t p = 0; p < nb_procs; p++)
     503        xbar_clack_c->p_local_out[p]               (signal_dspin_clack_proc[p]);
     504
     505    std::cout << "  - Clack Coherence crossbar connected" << std::endl;
     506
    475507    ////////////////////////// P2M DSPIN local crossbar coherence
    476508    xbar_p2m_c->p_clk                            (this->p_clk);
     
    491523        proc[p]->p_resetn                   (this->p_resetn);
    492524        proc[p]->p_vci                      (signal_vci_ini_proc[p]);
    493         proc[p]->p_dspin_in                 (signal_dspin_m2p_proc[p]);
    494         proc[p]->p_dspin_out                (signal_dspin_p2m_proc[p]);
     525        proc[p]->p_dspin_m2p                (signal_dspin_m2p_proc[p]);
     526        proc[p]->p_dspin_p2m                (signal_dspin_p2m_proc[p]);
     527        proc[p]->p_dspin_clack              (signal_dspin_clack_proc[p]);
    495528        proc[p]->p_irq[0]                   (signal_proc_it[p]);
    496529        for ( size_t j = 1 ; j < 6 ; j++)
     
    549582    memc->p_vci_ixr                    (signal_vci_xram);
    550583    memc->p_vci_tgt                    (signal_vci_tgt_memc);
    551     memc->p_dspin_in                   (signal_dspin_p2m_memc);
    552     memc->p_dspin_out                  (signal_dspin_m2p_memc);
     584    memc->p_dspin_p2m                  (signal_dspin_p2m_memc);
     585    memc->p_dspin_m2p                  (signal_dspin_m2p_memc);
     586    memc->p_dspin_clack                (signal_dspin_clack_memc);
    553587
    554588    // wrapper MEMC
Note: See TracChangeset for help on using the changeset viewer.