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/modules/vci_mem_cache/caba
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • 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.