Changeset 442 for branches


Ignore:
Timestamp:
Jul 17, 2013, 12:13:51 PM (11 years ago)
Author:
cfuguet
Message:

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

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
Location:
branches/v5
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/v5/communication/dspin_dhccp_param

  • branches/v5/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h

    r356 r442  
    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);

  • branches/v5/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd

    r441 r442  
    55__version__ = "$Revision: 295 $"
    66
    7 Module('caba:vci_mem_cache_branch',
     7Module('caba:vci_mem_cache',
    88        classname = 'soclib::caba::VciMemCache',
    99
    … …  
    4848            Port('caba:vci_target'   , 'p_vci_tgt'),
    4949            Port('caba:vci_initiator', 'p_vci_ixr'),
    50             Port('caba:dspin_p2m',
     50            Port('caba:dspin_input',
    5151                'p_dspin_p2m',
    5252                dspin_data_size = parameter.Reference('dspin_in_width')
    5353            ),
    54             Port('caba:dspin_m2p',
     54            Port('caba:dspin_output',
    5555                'p_dspin_m2p',
    5656                dspin_data_size = parameter.Reference('dspin_out_width')
    5757            ),
    58             Port('caba:dspin_clack',
     58            Port('caba:dspin_output',
    5959                'p_dspin_clack',
    6060                dspin_data_size = parameter.Reference('dspin_out_width')

  • branches/v5/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r441 r442  
    125125        CC_SEND_WRITE_IDLE,
    126126        CC_SEND_CAS_IDLE,
    127         CC_SEND_CLEANUP_IDLE,
    128127        CC_SEND_CONFIG_INVAL_HEADER,
    129128        CC_SEND_CONFIG_INVAL_NLINE,
    130129        CC_SEND_CONFIG_BRDCAST_HEADER,
    131130        CC_SEND_CONFIG_BRDCAST_NLINE,
    132         CC_SEND_CLEANUP_ACK,
    133131        CC_SEND_XRAM_RSP_BRDCAST_HEADER,
    134132        CC_SEND_XRAM_RSP_BRDCAST_NLINE,
    … …  
    790788      sc_signal<size_t>   r_cleanup_to_tgt_rsp_pktid; // transaction pktid
    791789
    792       // Buffer between CLEANUP fsm and CC_SEND fsm (acknowledge a cleanup command from L1)
    793       sc_signal<bool>     r_cleanup_to_cc_send_req;       // valid request
    794       sc_signal<size_t>   r_cleanup_to_cc_send_srcid;     // L1 srcid
    795       sc_signal<size_t>   r_cleanup_to_cc_send_set_index; // L1 set index
    796       sc_signal<size_t>   r_cleanup_to_cc_send_way_index; // L1 way index
    797       sc_signal<bool>     r_cleanup_to_cc_send_inst;      // Instruction Cleanup Ack
    798 
    799790      ///////////////////////////////////////////////////////
    800791      // Registers controlled by CAS fsm

  • branches/v5/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r441 r442  
    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",
    … …  
    42544252        DspinDhccpParam::dspin_get(
    42554253            flit,
    4256             DspinDhccpParam::FROM_L1_TYPE);
     4254            DspinDhccpParam::P2M_TYPE);
    42574255
    42584256      r_cleanup_way_index =
    … …  
    49924990    ////////////////////////
    49934991    case CLEANUP_SEND_CLACK:  // acknowledgement to a cleanup command
    4994                               // on the coherence network (request to the CC_SEND FSM).
    4995                               // wait if pending request to the CC_SEND FSM
    4996     {
    4997       if(r_cleanup_to_cc_send_req.read()) break;
    4998 
    4999       r_cleanup_to_cc_send_req       = true;
    5000       r_cleanup_to_cc_send_set_index = r_cleanup_nline.read() & 0xFFFF;
    5001       r_cleanup_to_cc_send_way_index = r_cleanup_way_index.read();
    5002       r_cleanup_to_cc_send_srcid     = r_cleanup_srcid.read();
    5003       r_cleanup_to_cc_send_inst      = r_cleanup_inst.read();
     4992                              // on the coherence CLACK network.
     4993    {
     4994      if(not p_dspin_clack.read) break;
    50044995
    50054996      r_cleanup_fsm = CLEANUP_IDLE;
    … …  
    58445835  // network, used to update or invalidate cache lines in L1 caches.
    58455836  //
    5846   // This fsm is used also to acknowledge CLEANUP a command after request from
    5847   // the CLEANUP fsm.
    5848   //
    5849   // It implements a round-robin priority between the five possible client FSMs
    5850   //     XRAM_RSP > CAS > CLEANUP > WRITE > CONFIG
     5837  // It implements a round-robin priority between the four possible client FSMs
     5838  //     XRAM_RSP > CAS > WRITE > CONFIG
    58515839  //
    58525840  // Each FSM can request the next services:
    … …  
    58605848  //   r_config_to_cc_send_brdcast_req : broadcast-inval
    58615849  //   
    5862   // - r_cleanup_to_cc_send_req : cleanup acknowledgement
    5863   //
    58645850  // An inval request is a double DSPIN flit command containing:
    58655851  // 1. the index of the line to be invalidated.
    … …  
    59045890          break;
    59055891        }
    5906         // CLEANUP
    5907         if (r_cleanup_to_cc_send_req.read())
    5908         {
    5909           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    5910           break;
    5911         }
    59125892        // WRITE
    59135893        if(m_write_to_cc_send_inst_fifo.rok() or
    … …  
    59835963          break;
    59845964        }
    5985         // CLEANUP
    5986         if (r_cleanup_to_cc_send_req.read())
    5987         {
    5988           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    5989           break;
    5990         }
    59915965        // WRITE
    59925966        if(m_write_to_cc_send_inst_fifo.rok() or
    … …  
    60225996          break;
    60235997        }
    6024         // CLEANUP
    6025         if(r_cleanup_to_cc_send_req.read())
    6026         {
    6027           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6028           break;
    6029         }
    60305998        // WRITE
    60315999        if(m_write_to_cc_send_inst_fifo.rok() or
    … …  
    60756043      case CC_SEND_CAS_IDLE:   // CLEANUP FSM has highest priority
    60766044      {
    6077         if(r_cleanup_to_cc_send_req.read())
    6078         {
    6079           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    6080           break;
    6081         }
    60826045        if(m_write_to_cc_send_inst_fifo.rok() or
    60836046            r_write_to_cc_send_multi_req.read())
    … …  
    61306093          r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    61316094          m_cpt_inval++;
    6132           break;
    6133         }
    6134         break;
    6135       }
    6136       //////////////////////////
    6137       case CC_SEND_CLEANUP_IDLE:   // WRITE FSM has highest priority
    6138       {
    6139         // WRITE
    6140         if(m_write_to_cc_send_inst_fifo.rok() or
    6141             r_write_to_cc_send_multi_req.read())
    6142         {
    6143           r_cc_send_fsm = CC_SEND_WRITE_UPDT_HEADER;
    6144           m_cpt_update++;
    6145           break;
    6146         }
    6147         if(r_write_to_cc_send_brdcast_req.read())
    6148         {
    6149           r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_HEADER;
    6150           m_cpt_inval++;
    6151           break;
    6152         }
    6153         // CONFIG
    6154         if(r_config_to_cc_send_multi_req.read())
    6155         {
    6156           r_cc_send_fsm = CC_SEND_CONFIG_INVAL_HEADER;
    6157           m_cpt_inval++;
    6158           break;
    6159         }
    6160         if(r_config_to_cc_send_brdcast_req.read())
    6161         {
    6162           r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_HEADER;
    6163           m_cpt_inval++;
    6164           break;
    6165         }
    6166         // XRAM_RSP
    6167         if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    6168             r_xram_rsp_to_cc_send_multi_req.read())
    6169         {
    6170           r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_HEADER;
    6171           m_cpt_inval++;
    6172           break;
    6173         }
    6174         if(r_xram_rsp_to_cc_send_brdcast_req.read())
    6175         {
    6176           r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_HEADER;
    6177           m_cpt_inval++;
    6178           break;
    6179         }
    6180         // CAS
    6181         if(m_cas_to_cc_send_inst_fifo.rok() or
    6182             r_cas_to_cc_send_multi_req.read())
    6183         {
    6184           r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
    6185           m_cpt_update++;
    6186           break;
    6187         }
    6188         if(r_cas_to_cc_send_brdcast_req.read())
    6189         {
    6190           r_cc_send_fsm = CC_SEND_CAS_BRDCAST_HEADER;
    6191           m_cpt_inval++;
    6192           break;
    6193         }
    6194         // CLEANUP
    6195         if(r_cleanup_to_cc_send_req.read())
    6196         {
    6197           r_cc_send_fsm = CC_SEND_CLEANUP_ACK;
    61986095          break;
    61996096        }
    … …  
    62496146          << " CC_SEND_CONFIG_BRDCAST_NLINE> BC-Inval for line "
    62506147          << std::hex << r_config_to_cc_send_nline.read() << std::endl;
    6251 #endif
    6252         break;
    6253       }
    6254       /////////////////////////
    6255       case CC_SEND_CLEANUP_ACK:   // send one flit for a cleanup acknowledgement
    6256       {
    6257         if(not p_dspin_m2p.read) break;
    6258 
    6259         r_cleanup_to_cc_send_req = false;
    6260         r_cc_send_fsm = CC_SEND_CLEANUP_IDLE;
    6261 
    6262 #if DEBUG_MEMC_CC_SEND
    6263 if(m_debug)
    6264 std::cout << "  <MEMC " << name()
    6265           << " CC_SEND_CLEANUP_ACK> Cleanup Ack for srcid "
    6266           << std::hex << r_cleanup_to_cc_send_srcid.read() << std::endl;
    62676148#endif
    62686149        break;
    … …  
    65006381          DspinDhccpParam::dspin_get(
    65016382              p_dspin_p2m.data.read(),
    6502               DspinDhccpParam::FROM_L1_TYPE);
     6383              DspinDhccpParam::P2M_TYPE);
    65036384
    65046385        if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
    … …  
    80417922    case CC_SEND_WRITE_IDLE:
    80427923    case CC_SEND_CAS_IDLE:
    8043     case CC_SEND_CLEANUP_IDLE:
    80447924    {
    80457925        break;
    … …  
    80767956        DspinDhccpParam::dspin_set( flit,
    80777957                                    multi_inval_type,
    8078                                     DspinDhccpParam::FROM_MC_TYPE);
     7958                                    DspinDhccpParam::M2P_TYPE);
    80797959        p_dspin_m2p.write = true;
    80807960        p_dspin_m2p.data  = flit;
    … …  
    80937973        break;
    80947974    }
    8095     ////////////////////////
    8096     case CC_SEND_CLEANUP_ACK:
    8097       {
    8098         uint8_t cleanup_ack_type;
    8099         if(r_cleanup_to_cc_send_inst.read())
    8100         {
    8101           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_INST;
    8102         }
    8103         else
    8104         {
    8105           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_DATA;
    8106         }
    8107 
    8108         uint64_t flit = 0;
    8109         uint64_t dest =
    8110           r_cleanup_to_cc_send_srcid.read() <<
    8111           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8112 
    8113         DspinDhccpParam::dspin_set(
    8114             flit,
    8115             dest,
    8116             DspinDhccpParam::CLEANUP_ACK_DEST);
    8117 
    8118         DspinDhccpParam::dspin_set(
    8119             flit,
    8120             r_cleanup_to_cc_send_set_index.read(),
    8121             DspinDhccpParam::CLEANUP_ACK_SET);
    8122 
    8123         DspinDhccpParam::dspin_set(
    8124             flit,
    8125             r_cleanup_to_cc_send_way_index.read(),
    8126             DspinDhccpParam::CLEANUP_ACK_WAY);
    8127 
    8128         DspinDhccpParam::dspin_set(
    8129             flit,
    8130             cleanup_ack_type,
    8131             DspinDhccpParam::FROM_MC_TYPE);
    8132 
    8133         p_dspin_m2p.eop   = true;
    8134         p_dspin_m2p.write = true;
    8135         p_dspin_m2p.data  = flit;
    8136 
    8137         break;
    8138     }
    8139 
    81407975    ///////////////////////////////////
    81417976    case CC_SEND_XRAM_RSP_INVAL_HEADER:
    … …  
    81718006        DspinDhccpParam::dspin_set( flit,
    81728007                                    multi_inval_type,
    8173                                     DspinDhccpParam::FROM_MC_TYPE);
     8008                                    DspinDhccpParam::M2P_TYPE);
    81748009        p_dspin_m2p.write = true;
    81758010        p_dspin_m2p.data  = flit;
    … …  
    82098044        DspinDhccpParam::dspin_set( flit,
    82108045                                    1ULL,
    8211                                     DspinDhccpParam::FROM_MC_BC);
     8046                                    DspinDhccpParam::M2P_BC);
    82128047        p_dspin_m2p.write = true;
    82138048        p_dspin_m2p.data  = flit;
    … …  
    83008135            flit,
    83018136            multi_updt_type,
    8302             DspinDhccpParam::FROM_MC_TYPE);
     8137            DspinDhccpParam::M2P_TYPE);
    83038138
    83048139        p_dspin_m2p.write = true;
    … …  
    83938228            flit,
    83948229            multi_updt_type,
    8395             DspinDhccpParam::FROM_MC_TYPE);
     8230            DspinDhccpParam::M2P_TYPE);
    83968231
    83978232        p_dspin_m2p.write = true;
    … …  
    84648299  }
    84658300
     8301  ////////////////////////////////////////////////////////////////////
     8302  //  p_dspin_clack port (CLEANUP FSM)
     8303  ////////////////////////////////////////////////////////////////////
     8304
     8305  switch(r_cleanup_fsm.read())
     8306  {
     8307    case CLEANUP_IDLE:
     8308    case CLEANUP_GET_NLINE:
     8309    case CLEANUP_DIR_REQ:
     8310    case CLEANUP_DIR_LOCK:
     8311    case CLEANUP_DIR_WRITE:
     8312    case CLEANUP_HEAP_REQ:
     8313    case CLEANUP_HEAP_LOCK:
     8314    case CLEANUP_HEAP_SEARCH:
     8315    case CLEANUP_HEAP_CLEAN:
     8316    case CLEANUP_HEAP_FREE:
     8317    case CLEANUP_IVT_LOCK:
     8318    case CLEANUP_IVT_DECREMENT:
     8319    case CLEANUP_IVT_CLEAR:
     8320    case CLEANUP_WRITE_RSP:
     8321    case CLEANUP_CONFIG_ACK:
     8322      p_dspin_clack.write = false;
     8323      p_dspin_clack.eop   = false;
     8324      p_dspin_clack.data  = 0;
     8325
     8326      break;
     8327
     8328    case CLEANUP_SEND_CLACK:
     8329      {
     8330        uint8_t cleanup_ack_type;
     8331        if(r_cleanup_inst.read())
     8332        {
     8333          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_INST;
     8334        }
     8335        else
     8336        {
     8337          cleanup_ack_type = DspinDhccpParam::TYPE_CLACK_DATA;
     8338        }
     8339
     8340        uint64_t flit = 0;
     8341        uint64_t dest =
     8342          r_cleanup_srcid.read() <<
     8343          (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
     8344
     8345        DspinDhccpParam::dspin_set(
     8346            flit,
     8347            dest,
     8348            DspinDhccpParam::CLACK_DEST);
     8349
     8350        DspinDhccpParam::dspin_set(
     8351            flit,
     8352            r_cleanup_nline.read() & 0xFFFF,
     8353            DspinDhccpParam::CLACK_SET);
     8354
     8355        DspinDhccpParam::dspin_set(
     8356            flit,
     8357            r_cleanup_way_index.read(),
     8358            DspinDhccpParam::CLACK_WAY);
     8359
     8360        DspinDhccpParam::dspin_set(
     8361            flit,
     8362            cleanup_ack_type,
     8363            DspinDhccpParam::CLACK_TYPE);
     8364
     8365        p_dspin_clack.eop   = true;
     8366        p_dspin_clack.write = true;
     8367        p_dspin_clack.data  = flit;
     8368      }
     8369      break;
     8370  }
     8371
    84668372  ///////////////////////////////////////////////////////////////////
    84678373  //  p_dspin_p2m port (CC_RECEIVE FSM)
    84688374  ///////////////////////////////////////////////////////////////////
    8469   p_dspin_p2m.read = false;
     8375  //
    84708376  switch(r_cc_receive_fsm.read())
    84718377  {
    84728378    case CC_RECEIVE_IDLE:
    84738379      {
     8380        p_dspin_p2m.read = false;
    84748381        break;
    84758382      }
Note: See TracChangeset for help on using the changeset viewer.