Ignore:
Timestamp:
Jul 17, 2013, 10:54:07 AM (11 years ago)
Author:
cfuguet
Message:

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

Location:
branches/v5/modules/vci_mem_cache/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/v5/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r440 r441  
    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
     
    165166        CONFIG_DIR_REQ,
    166167        CONFIG_DIR_ACCESS,
    167         CONFIG_DIR_UPT_LOCK,
     168        CONFIG_DIR_IVT_LOCK,
    168169        CONFIG_BC_SEND,
    169170        CONFIG_BC_WAIT,
     
    213214        WRITE_MISS_XRAM_REQ,
    214215        WRITE_BC_TRT_LOCK,
    215         WRITE_BC_UPT_LOCK,
     216        WRITE_BC_IVT_LOCK,
    216217        WRITE_BC_DIR_INVAL,
    217218        WRITE_BC_CC_SEND,
     
    276277        CAS_UPT_NEXT,
    277278        CAS_BC_TRT_LOCK,
    278         CAS_BC_UPT_LOCK,
     279        CAS_BC_IVT_LOCK,
    279280        CAS_BC_DIR_INVAL,
    280281        CAS_BC_CC_SEND,
     
    301302        CLEANUP_HEAP_CLEAN,
    302303        CLEANUP_HEAP_FREE,
    303         CLEANUP_UPT_LOCK,
    304         CLEANUP_UPT_DECREMENT,
    305         CLEANUP_UPT_CLEAR,
     304        CLEANUP_IVT_LOCK,
     305        CLEANUP_IVT_DECREMENT,
     306        CLEANUP_IVT_CLEAR,
    306307        CLEANUP_WRITE_RSP,
    307308        CLEANUP_CONFIG_ACK,
     
    334335      enum alloc_upt_fsm_state_e
    335336      {
    336         ALLOC_UPT_CONFIG,
    337337        ALLOC_UPT_WRITE,
    338         ALLOC_UPT_XRAM_RSP,
    339         ALLOC_UPT_MULTI_ACK,
    340         ALLOC_UPT_CLEANUP,
    341         ALLOC_UPT_CAS
     338        ALLOC_UPT_CAS,
     339        ALLOC_UPT_MULTI_ACK
     340      };
     341
     342      /* States of the ALLOC_IVT fsm */
     343      enum alloc_ivt_fsm_state_e
     344      {
     345        ALLOC_IVT_WRITE,
     346        ALLOC_IVT_XRAM_RSP,
     347        ALLOC_IVT_CLEANUP,
     348        ALLOC_IVT_CAS,
     349        ALLOC_IVT_CONFIG
    342350      };
    343351
     
    450458      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
    451459      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
    452       soclib::caba::DspinInput<dspin_in_width>    p_dspin_in;
    453       soclib::caba::DspinOutput<dspin_out_width>  p_dspin_out;
     460      soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
     461      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
     462      soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
    454463
    455464      VciMemCache(
     
    467476          const size_t                       trt_lines=TRT_ENTRIES,
    468477          const size_t                       upt_lines=UPT_ENTRIES,     
     478          const size_t                       ivt_lines=IVT_ENTRIES,     
    469479          const size_t                       debug_start_cycle=0,
    470480          const bool                         debug_ok=false );
     
    501511      TransactionTab                     m_trt;              // xram transaction table
    502512      uint32_t                           m_upt_lines;
    503       UpdateTab                          m_upt;              // pending update & invalidate
     513      UpdateTab                          m_upt;              // pending update
     514      UpdateTab                          m_ivt;              // pending invalidate
    504515      CacheDirectory                     m_cache_directory;  // data cache directory
    505516      CacheData                          m_cache_data;       // data array[set][way][word]
     
    590601      sc_signal<size_t>   r_config_heap_next;      // current pointer to scan HEAP
    591602
    592       sc_signal<size_t>   r_config_upt_index;  // UPT index
     603      sc_signal<size_t>   r_config_ivt_index;      // IVT index
    593604
    594605      // Buffer between CONFIG fsm and TGT_RSP fsm (send a done response to L1 cache)
     
    871882      sc_signal<size_t>   r_xram_rsp_victim_ptr;        // victim line pointer to the heap
    872883      sc_signal<data_t> * r_xram_rsp_victim_data;       // victim line data
    873       sc_signal<size_t>   r_xram_rsp_upt_index;         // UPT entry index
     884      sc_signal<size_t>   r_xram_rsp_ivt_index;         // IVT entry index
    874885      sc_signal<size_t>   r_xram_rsp_next_ptr;          // Next pointer to the heap
    875886
     
    952963
    953964      ////////////////////////////////////////////////////
     965      // Registers controlled by ALLOC_IVT fsm
     966      ////////////////////////////////////////////////////
     967
     968      sc_signal<int>      r_alloc_ivt_fsm;
     969
     970      ////////////////////////////////////////////////////
    954971      // Registers controlled by ALLOC_HEAP fsm
    955972      ////////////////////////////////////////////////////
  • branches/v5/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r440 r441  
    136136  "CONFIG_DIR_REQ",
    137137  "CONFIG_DIR_ACCESS",
    138   "CONFIG_DIR_UPT_LOCK",
     138  "CONFIG_DIR_IVT_LOCK",
    139139  "CONFIG_BC_SEND",
    140140  "CONFIG_BC_WAIT",
     
    180180  "WRITE_MISS_XRAM_REQ",
    181181  "WRITE_BC_TRT_LOCK",
    182   "WRITE_BC_UPT_LOCK",
     182  "WRITE_BC_IVT_LOCK",
    183183  "WRITE_BC_DIR_INVAL",
    184184  "WRITE_BC_CC_SEND",
     
    235235  "CAS_UPT_NEXT",
    236236  "CAS_BC_TRT_LOCK",
    237   "CAS_BC_UPT_LOCK",
     237  "CAS_BC_IVT_LOCK",
    238238  "CAS_BC_DIR_INVAL",
    239239  "CAS_BC_CC_SEND",
     
    258258  "CLEANUP_HEAP_CLEAN",
    259259  "CLEANUP_HEAP_FREE",
    260   "CLEANUP_UPT_LOCK",
    261   "CLEANUP_UPT_DECREMENT",
    262   "CLEANUP_UPT_CLEAR",
     260  "CLEANUP_IVT_LOCK",
     261  "CLEANUP_IVT_DECREMENT",
     262  "CLEANUP_IVT_CLEAR",
    263263  "CLEANUP_WRITE_RSP",
    264264  "CLEANUP_CONFIG_ACK",
     
    328328  const size_t        trt_lines,         // number of TRT entries
    329329  const size_t        upt_lines,         // number of UPT entries
     330  const size_t        ivt_lines,         // number of IVT entries
    330331  const size_t        debug_start_cycle,
    331332  const bool          debug_ok)
     
    337338    p_vci_tgt( "p_vci_tgt" ),
    338339    p_vci_ixr( "p_vci_ixr" ),
    339     p_dspin_in( "p_dspin_in" ),
    340     p_dspin_out( "p_dspin_out" ),
     340    p_dspin_p2m( "p_dspin_p2m" ),
     341    p_dspin_m2p( "p_dspin_m2p" ),
     342    p_dspin_clack( "p_dspin_clack" ),
    341343
    342344    m_seglist( mtp.getSegmentList(tgtid_d) ),
     
    355357    m_upt_lines(upt_lines),
    356358    m_upt(upt_lines),
     359    m_ivt(ivt_lines),
    357360    m_cache_directory(nways, nsets, nwords, vci_param_int::N),
    358361    m_cache_data(nways, nsets, nwords),
     
    446449    r_alloc_trt_fsm("r_alloc_trt_fsm"),
    447450    r_alloc_upt_fsm("r_alloc_upt_fsm"),
     451    r_alloc_ivt_fsm("r_alloc_ivt_fsm"),
    448452    r_alloc_heap_fsm("r_alloc_heap_fsm"),
    449453    r_alloc_heap_reset_cpt("r_alloc_heap_reset_cpt")
     
    678682    r_alloc_trt_fsm  = ALLOC_TRT_READ;
    679683    r_alloc_upt_fsm  = ALLOC_UPT_WRITE;
     684    r_alloc_ivt_fsm  = ALLOC_IVT_XRAM_RSP;
    680685    r_ixr_rsp_fsm    = IXR_RSP_IDLE;
    681686    r_xram_rsp_fsm   = XRAM_RSP_IDLE;
     
    689694    m_trt.init();
    690695    m_upt.init();
     696    m_ivt.init();
    691697    m_llsc_table.init();
    692698
     
    15091515              r_config_dir_next_ptr   = entry.ptr;
    15101516
    1511               r_config_fsm    = CONFIG_DIR_UPT_LOCK;
     1517              r_config_fsm    = CONFIG_DIR_IVT_LOCK;
    15121518          }
    15131519          else if ( entry.valid and                       // hit & sync command
     
    15381544      }
    15391545      /////////////////////////
    1540       case CONFIG_DIR_UPT_LOCK:  // enter this state in case of INVAL command
    1541                                  // Try to get both DIR & UPT locks, and return
    1542                                  // to LOOP state if UPT full.
    1543                                  // Register inval in UPT, and invalidate the
    1544                                  // directory if UPT not full.
    1545       {
    1546           if ( r_alloc_upt_fsm.read() == ALLOC_UPT_CONFIG )
     1546      case CONFIG_DIR_IVT_LOCK:  // enter this state in case of INVAL command
     1547                                 // Try to get both DIR & IVT locks, and return
     1548                                 // to LOOP state if IVT full.
     1549                                 // Register inval in IVT, and invalidate the
     1550                                 // directory if IVT not full.
     1551      {
     1552          if ( r_alloc_ivt_fsm.read() == ALLOC_IVT_CONFIG )
    15471553          {
    15481554              size_t set        = m_y[(addr_t)(r_config_address.read())];
     
    15581564#if DEBUG_MEMC_CONFIG
    15591565if(m_debug)
    1560 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
     1566std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
    15611567          << " No copies in L1 : inval DIR entry"  << std::endl;
    15621568#endif
    15631569              }
    1564               else    // try to register inval in UPT
     1570              else    // try to register inval in IVT
    15651571              {
    15661572                  bool        wok       = false;
     
    15731579                  size_t      nb_copies = r_config_dir_count.read();
    15741580
    1575                   wok = m_upt.set(false,       // it's an inval transaction
     1581                  wok = m_ivt.set(false,       // it's an inval transaction
    15761582                                  broadcast,   
    15771583                                  false,       // no response required
     
    15831589                                  nb_copies,
    15841590                                  index);
    1585                   if ( wok )  // UPT success => inval DIR slot
     1591                  if ( wok )  // IVT success => inval DIR slot
    15861592                  {
    15871593                      m_cache_directory.inval( way, set );
    1588                       r_config_upt_index = index;
     1594                      r_config_ivt_index = index;
    15891595                      if ( broadcast )  r_config_fsm = CONFIG_BC_SEND;
    15901596                      else              r_config_fsm = CONFIG_INV_SEND;
     
    15921598#if DEBUG_MEMC_CONFIG
    15931599if(m_debug)
    1594 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1595           << " Inval DIR entry and register inval in UPT"
     1600std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1601          << " Inval DIR entry and register inval in IVT"
    15961602          << " : index = " << std::dec << index
    15971603          << " / broadcast = " << broadcast << std::endl;
    15981604#endif
    15991605                  }
    1600                   else       // UPT full => release both DIR and UPT locks
     1606                  else       // IVT full => release both DIR and IVT locks
    16011607                  {
    16021608                      r_config_fsm = CONFIG_LOOP;
     
    16041610#if DEBUG_MEMC_CONFIG
    16051611if(m_debug)
    1606 std::cout << "  <MEMC " << name() << " CONFIG_DIR_UPT_LOCK>"
    1607           << " UPT full : release DIR & UPT locks and retry" << std::endl;
     1612std::cout << "  <MEMC " << name() << " CONFIG_DIR_IVT_LOCK>"
     1613          << " IVT full : release DIR & IVT locks and retry" << std::endl;
    16081614#endif
    16091615                  }
     
    16201626              r_config_to_cc_send_multi_req   = false;
    16211627              r_config_to_cc_send_brdcast_req = true;
    1622               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1628              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    16231629              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    16241630              r_cleanup_to_config_ack         = false;
     
    16601666              r_config_to_cc_send_multi_req   = true;
    16611667              r_config_to_cc_send_brdcast_req = false;
    1662               r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1668              r_config_to_cc_send_trdid       = r_config_ivt_index.read();
    16631669              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
    16641670              r_multi_ack_to_config_ack       = false;
     
    27442750
    27452751        wok = m_upt.set(true,  // it's an update transaction
    2746                         false,    // it's not a broadcast
    2747                         true,     // response required
    2748                         false,    // no acknowledge required
     2752                        false, // it's not a broadcast
     2753                        true,  // response required
     2754                        false, // no acknowledge required
    27492755                        srcid,   
    27502756                        trdid,
     
    29002906          entry.owner.inst)             // put the next srcid in the fifo
    29012907      {
    2902         dec_upt_counter                 = false;
     2908        dec_upt_counter                = false;
    29032909        write_to_cc_send_fifo_put      = true;
    29042910        write_to_cc_send_fifo_inst     = entry.owner.inst;
     
    29532959      {
    29542960        r_write_to_cc_send_multi_req = true;
    2955         if(r_write_to_dec.read() or dec_upt_counter)   r_write_fsm = WRITE_UPT_DEC;
     2961        if(r_write_to_dec.read() or dec_upt_counter)  r_write_fsm = WRITE_UPT_DEC;
    29562962        else                                          r_write_fsm = WRITE_IDLE;
    29572963      }
     
    31963202        {
    31973203          r_write_trt_index = wok_index;
    3198           r_write_fsm       = WRITE_BC_UPT_LOCK;
     3204          r_write_fsm       = WRITE_BC_IVT_LOCK;
    31993205        }
    32003206        else  // wait an empty entry in TRT
     
    32133219
    32143220    //////////////////////
    3215     case WRITE_BC_UPT_LOCK:      // register BC transaction in UPT
    3216     {
    3217       if(r_alloc_upt_fsm.read() == ALLOC_UPT_WRITE)
     3221    case WRITE_BC_IVT_LOCK:      // register BC transaction in IVT
     3222    {
     3223      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_WRITE)
    32183224      {
    32193225        bool        wok       = false;
     
    32253231        size_t      nb_copies = r_write_count.read();
    32263232
    3227         wok = m_upt.set(false,  // it's an inval transaction
    3228                         true,     // it's a broadcast
    3229                         true,     // response required
    3230                         false,    // no acknowledge required
     3233        wok = m_ivt.set(false,  // it's an inval transaction
     3234                        true,   // it's a broadcast
     3235                        true,   // response required
     3236                        false,  // no acknowledge required
    32313237                        srcid,
    32323238                        trdid,
     
    32383244#if DEBUG_MEMC_WRITE
    32393245if( m_debug and wok )
    3240 std::cout << "  <MEMC " << name() << " WRITE_BC_UPT_LOCK> Register broadcast inval in UPT"
     3246std::cout << "  <MEMC " << name() << " WRITE_BC_IVT_LOCK> Register broadcast inval in IVT"
    32413247          << " / nb_copies = " << r_write_count.read() << std::endl;
    32423248#endif
     
    32443250
    32453251        if(wok) r_write_fsm = WRITE_BC_DIR_INVAL;
    3246         else       r_write_fsm = WRITE_WAIT;
     3252        else    r_write_fsm = WRITE_WAIT;
    32473253      }
    32483254      break;
     
    32553261      // and invalidate the line in directory
    32563262      if((r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE) or
    3257           (r_alloc_upt_fsm.read() != ALLOC_UPT_WRITE) or
    3258           (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
     3263         (r_alloc_ivt_fsm.read() != ALLOC_IVT_WRITE) or
     3264         (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
    32593265      {
    32603266        std::cout << "VCI_MEM_CACHE ERROR " << name() << " WRITE_BC_DIR_INVAL state" << std::endl;
    3261         std::cout << "bad TRT, DIR, or UPT allocation" << std::endl;
     3267        std::cout << "bad TRT, DIR, or IVT allocation" << std::endl;
    32623268        exit(0);
    32633269      }
     
    37873793    }
    37883794    /////////////////////////
    3789     case XRAM_RSP_INVAL_LOCK: // Take the UPT lock to check a possible pending inval
    3790     {
    3791       if(r_alloc_upt_fsm == ALLOC_UPT_XRAM_RSP)
     3795    case XRAM_RSP_INVAL_LOCK: // Take the IVT lock to check a possible pending inval
     3796    {
     3797      if(r_alloc_ivt_fsm == ALLOC_IVT_XRAM_RSP)
    37923798      {
    37933799        size_t index = 0;
    3794         if(m_upt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
     3800        if(m_ivt.search_inval(r_xram_rsp_trt_buf.nline, index))  // pending inval
    37953801        {
    37963802          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    37993805if(m_debug)
    38003806std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3801           << " Get acces to UPT, but line invalidation registered"
     3807          << " Get acces to IVT, but line invalidation registered"
    38023808          << " / nline = " << std::hex << r_xram_rsp_trt_buf.nline
    38033809          << " / index = " << std::dec << index << std::endl;
     
    38053811
    38063812        }
    3807         else if(m_upt.is_full() and r_xram_rsp_victim_inval.read()) // UPT full
     3813        else if(m_ivt.is_full() and r_xram_rsp_victim_inval.read()) // IVT full
    38083814        {
    38093815          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
     
    38123818if(m_debug)
    38133819std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3814           << " Get acces to UPT, but inval required and UPT full" << std::endl;
     3820          << " Get acces to IVT, but inval required and IVT full" << std::endl;
    38153821#endif
    38163822        }
     
    38223828if(m_debug)
    38233829std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    3824           << " Get acces to UPT" << std::endl;
     3830          << " Get acces to IVT" << std::endl;
    38253831#endif
    38263832        }
     
    38423848    ///////////////////////
    38433849    case XRAM_RSP_DIR_UPDT:   // updates the cache (both data & directory)
    3844                               // and possibly set an inval request in UPT
     3850                              // and possibly set an inval request in IVT
    38453851    {
    38463852      // check if this is an instruction read, this means pktid is either
     
    39003906      m_cache_directory.write(set, way, entry);
    39013907
    3902       // request an invalidattion request in UPT for victim line
     3908      // request an invalidattion request in IVT for victim line
    39033909      if(r_xram_rsp_victim_inval.read())
    39043910      {
     
    39073913        size_t count_copies = r_xram_rsp_victim_count.read();
    39083914
    3909         bool   wok = m_upt.set(false,      // it's an inval transaction
     3915        bool   wok = m_ivt.set(false,      // it's an inval transaction
    39103916                               broadcast,  // set broadcast bit
    39113917                               false,      // no response required
     
    39183924                               index);
    39193925
    3920         r_xram_rsp_upt_index = index;
     3926        r_xram_rsp_ivt_index = index;
    39213927
    39223928        if(!wok)
    39233929        {
    39243930          std::cout << "VCI_MEM_CACHE ERROR " << name() << " XRAM_RSP_DIR_UPDT"
    3925                     << " update_tab entry free but write unsuccessful" << std::endl;
     3931                    << " invalidate_tab entry free but write unsuccessful" << std::endl;
    39263932          exit(0);
    39273933        }
     
    40324038        r_xram_rsp_to_cc_send_brdcast_req  = r_xram_rsp_victim_is_cnt.read();
    40334039        r_xram_rsp_to_cc_send_nline        = r_xram_rsp_victim_nline.read();
    4034         r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_upt_index;
     4040        r_xram_rsp_to_cc_send_trdid        = r_xram_rsp_ivt_index;
    40354041        xram_rsp_to_cc_send_fifo_srcid     = r_xram_rsp_victim_copy.read();
    40364042        xram_rsp_to_cc_send_fifo_inst      = r_xram_rsp_victim_copy_inst.read();
     
    43774383      else                // miss : check UPT for a pending invalidation transaction
    43784384      {
    4379         r_cleanup_fsm = CLEANUP_UPT_LOCK;
     4385        r_cleanup_fsm = CLEANUP_IVT_LOCK;
    43804386      }
    43814387
     
    48354841    }
    48364842    //////////////////////
    4837     case CLEANUP_UPT_LOCK:   // get the lock protecting the UPT to search a pending
     4843    case CLEANUP_IVT_LOCK:   // get the lock protecting the IVT to search a pending
    48384844                             // invalidate transaction matching the cleanup
    48394845    {
    4840       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP) break;
     4846      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP) break;
    48414847
    48424848      size_t index = 0;
    48434849      bool   match_inval;
    48444850
    4845       match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
     4851      match_inval = m_ivt.search_inval(r_cleanup_nline.read(), index);
    48464852
    48474853      if ( not match_inval )     // no pending inval
     
    48524858if(m_debug)
    48534859std::cout << "  <MEMC " << name()
    4854           << " CLEANUP_UPT_LOCK> Unexpected cleanup"
    4855           << " with no corresponding UPT entry:"
     4860          << " CLEANUP_IVT_LOCK> Unexpected cleanup"
     4861          << " with no corresponding IVT entry:"
    48564862          << " address = " << std::hex
    48574863          << (r_cleanup_nline.read() *4*m_words)
     
    48624868
    48634869      // pending inval
    4864       r_cleanup_write_srcid = m_upt.srcid(index);
    4865       r_cleanup_write_trdid = m_upt.trdid(index);
    4866       r_cleanup_write_pktid = m_upt.pktid(index);
    4867       r_cleanup_need_rsp    = m_upt.need_rsp(index);
    4868       r_cleanup_need_ack    = m_upt.need_ack(index);
     4870      r_cleanup_write_srcid = m_ivt.srcid(index);
     4871      r_cleanup_write_trdid = m_ivt.trdid(index);
     4872      r_cleanup_write_pktid = m_ivt.pktid(index);
     4873      r_cleanup_need_rsp    = m_ivt.need_rsp(index);
     4874      r_cleanup_need_ack    = m_ivt.need_ack(index);
    48694875      r_cleanup_index       = index;
    48704876
    4871       r_cleanup_fsm         = CLEANUP_UPT_DECREMENT;
     4877      r_cleanup_fsm         = CLEANUP_IVT_DECREMENT;
    48724878
    48734879#if DEBUG_MEMC_CLEANUP
    48744880if(m_debug)
    48754881std::cout << "  <MEMC " << name()
    4876           << " CLEANUP_UPT_LOCK> Cleanup matching pending"
    4877           << " invalidate transaction on UPT:"
     4882          << " CLEANUP_IVT_LOCK> Cleanup matching pending"
     4883          << " invalidate transaction on IVT:"
    48784884          << " address = " << std::hex << r_cleanup_nline.read() * m_words * 4
    4879           << " / upt_entry = " << index << std::endl;
     4885          << " / ivt_entry = " << index << std::endl;
    48804886#endif
    48814887      break;
    48824888    }
    48834889    ///////////////////////////
    4884     case CLEANUP_UPT_DECREMENT:   // decrement response counter in UPT matching entry
    4885     {
    4886       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     4890    case CLEANUP_IVT_DECREMENT: // decrement response counter in IVT matching entry
     4891    {
     4892      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    48874893      {
    48884894        std::cout
    48894895            << "VCI_MEM_CACHE ERROR "         << name()
    4890             << " CLEANUP_UPT_DECREMENT state" << std::endl
    4891             << "Bad UPT allocation"
     4896            << " CLEANUP_IVT_DECREMENT state" << std::endl
     4897            << "Bad IVT allocation"
    48924898            << std::endl;
    48934899
     
    48964902
    48974903      size_t count = 0;
    4898       m_upt.decrement(r_cleanup_index.read(), count);
     4904      m_ivt.decrement(r_cleanup_index.read(), count);
    48994905
    49004906      if(count == 0)   // multi inval transaction completed
    49014907      {
    4902         r_cleanup_fsm = CLEANUP_UPT_CLEAR;
     4908        r_cleanup_fsm = CLEANUP_IVT_CLEAR;
    49034909      }
    49044910      else             // multi inval transaction not completed
     
    49094915#if DEBUG_MEMC_CLEANUP
    49104916if(m_debug)
    4911 std::cout << "  <MEMC " << name() << " CLEANUP_UPT_DECREMENT>"
    4912           << " Decrement response counter in UPT:"
    4913             << " UPT_index = " << r_cleanup_index.read()
     4917std::cout << "  <MEMC " << name() << " CLEANUP_IVT_DECREMENT>"
     4918          << " Decrement response counter in IVT:"
     4919            << " IVT_index = " << r_cleanup_index.read()
    49144920            << " / rsp_count = " << count << std::endl;
    49154921#endif
     
    49174923    }
    49184924    ///////////////////////
    4919     case CLEANUP_UPT_CLEAR:    // Clear UPT entry
    4920     {
    4921       if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
     4925    case CLEANUP_IVT_CLEAR:    // Clear IVT entry
     4926    {
     4927      if(r_alloc_ivt_fsm.read() != ALLOC_IVT_CLEANUP)
    49224928      {
    49234929        std::cout
    49244930            << "VCI_MEM_CACHE ERROR "     << name()
    4925             << " CLEANUP_UPT_CLEAR state" << std::endl
    4926             << "Bad UPT allocation"
     4931            << " CLEANUP_IVT_CLEAR state" << std::endl
     4932            << "Bad IVT allocation"
    49274933            << std::endl;
    49284934
     
    49304936      }
    49314937
    4932       m_upt.clear(r_cleanup_index.read());
     4938      m_ivt.clear(r_cleanup_index.read());
    49334939
    49344940      if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
     
    49394945if(m_debug)
    49404946std::cout << "  <MEMC "      << name()
    4941           << " CLEANUP_UPT_CLEAR> Clear entry in UPT:"
    4942           << " UPT_index = " << r_cleanup_index.read() << std::endl;
     4947          << " CLEANUP_IVT_CLEAR> Clear entry in IVT:"
     4948          << " IVT_index = " << r_cleanup_index.read() << std::endl;
    49434949#endif
    49444950      break;
     
    49854991    }
    49864992    ////////////////////////
    4987     case CLEANUP_SEND_CLACK:    // acknowledgement to a cleanup command
     4993    case CLEANUP_SEND_CLACK:  // acknowledgement to a cleanup command
    49884994                              // on the coherence network (request to the CC_SEND FSM).
    49894995                              // wait if pending request to the CC_SEND FSM
     
    52385244                !r_cas_to_cc_send_brdcast_req.read())
    52395245        {
    5240           r_cas_fsm = CAS_UPT_LOCK;     // multi update required
     5246          r_cas_fsm = CAS_UPT_LOCK;       // multi update required
    52415247        }
    52425248        else
     
    55095515          {
    55105516            r_cas_trt_index = wok_index;
    5511             r_cas_fsm       = CAS_BC_UPT_LOCK;
     5517            r_cas_fsm       = CAS_BC_IVT_LOCK;
    55125518          }
    55135519          else
     
    55245530    }
    55255531    /////////////////////
    5526     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
    55275533                           // write data in cache in case of successful registration
    55285534    {
    5529       if(r_alloc_upt_fsm.read() == ALLOC_UPT_CAS)
     5535      if(r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS)
    55305536      {
    55315537        bool        wok       = false;
     
    55375543        size_t      nb_copies = r_cas_count.read();
    55385544
    5539         // register a broadcast inval transaction in UPT
    5540         wok = m_upt.set(false,  // it's an inval transaction
    5541                         true,    // it's a broadcast
    5542                         true,    // response required
    5543                         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
    55445550                        srcid,
    55455551                        trdid,
     
    55495555                        index);
    55505556
    5551         if(wok)     // UPT not full
     5557        if(wok)     // IVT not full
    55525558        {
    55535559          // cache update
     
    55775583if(m_debug)
    55785584std::cout << "  <MEMC " << name()
    5579           << " CAS_BC_UPT_LOCK> Register a broadcast inval transaction in UPT"
     5585          << " CAS_BC_IVT_LOCK> Register a broadcast inval transaction in IVT"
    55805586          << " / nline = " << std::hex << nline
    55815587          << " / count = " << std::dec << nb_copies
    5582           << " / upt_index = " << index << std::endl;
    5583 #endif
    5584         }
    5585         else      //  releases the lock protecting UPT
     5588          << " / ivt_index = " << index << std::endl;
     5589#endif
     5590        }
     5591        else      //  releases the lock protecting IVT
    55865592        {
    55875593          r_cas_fsm = CAS_WAIT;
     
    55945600    {
    55955601      if((r_alloc_trt_fsm.read() == ALLOC_TRT_CAS) and
    5596           (r_alloc_upt_fsm.read() == ALLOC_UPT_CAS) and
    5597           (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
     5602         (r_alloc_ivt_fsm.read() == ALLOC_IVT_CAS) and
     5603         (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
    55985604      {
    55995605        // set TRT
     
    61996205        if(m_config_to_cc_send_inst_fifo.rok())
    62006206        {
    6201           if(not p_dspin_out.read) break;
     6207          if(not p_dspin_m2p.read) break;
    62026208          r_cc_send_fsm = CC_SEND_CONFIG_INVAL_NLINE;
    62036209          break;
     
    62106216      case CC_SEND_CONFIG_INVAL_NLINE:    // send second flit multi-inval (from CONFIG FSM)
    62116217      {
    6212         if(not p_dspin_out.read) break;
     6218        if(not p_dspin_m2p.read) break;
    62136219        m_cpt_inval_mult++;
    62146220        config_to_cc_send_fifo_get = true;
     
    62266232      case CC_SEND_CONFIG_BRDCAST_HEADER:   // send first flit BC-inval (from CONFIG FSM)
    62276233      {
    6228         if(not p_dspin_out.read) break;
     6234        if(not p_dspin_m2p.read) break;
    62296235        r_cc_send_fsm = CC_SEND_CONFIG_BRDCAST_NLINE;
    62306236        break;
     
    62336239      case CC_SEND_CONFIG_BRDCAST_NLINE:    // send second flit BC-inval (from CONFIG FSM)
    62346240      {
    6235         if(not p_dspin_out.read) break;
     6241        if(not p_dspin_m2p.read) break;
    62366242        m_cpt_inval_brdcast++;
    62376243        r_config_to_cc_send_brdcast_req = false;
     
    62496255      case CC_SEND_CLEANUP_ACK:   // send one flit for a cleanup acknowledgement
    62506256      {
    6251         if(not p_dspin_out.read) break;
     6257        if(not p_dspin_m2p.read) break;
    62526258
    62536259        r_cleanup_to_cc_send_req = false;
     
    62676273        if(m_xram_rsp_to_cc_send_inst_fifo.rok())
    62686274        {
    6269           if(not p_dspin_out.read) break;
     6275          if(not p_dspin_m2p.read) break;
    62706276          r_cc_send_fsm = CC_SEND_XRAM_RSP_INVAL_NLINE;
    62716277          break;
     
    62786284      case CC_SEND_XRAM_RSP_INVAL_NLINE:   // send second flit multi-inval (from XRAM_RSP FSM)
    62796285      {
    6280         if(not p_dspin_out.read) break;
     6286        if(not p_dspin_m2p.read) break;
    62816287        m_cpt_inval_mult++;
    62826288        xram_rsp_to_cc_send_fifo_get = true;
     
    62946300      case CC_SEND_XRAM_RSP_BRDCAST_HEADER:  // send first flit broadcast-inval (from XRAM_RSP FSM)
    62956301      {
    6296         if(not p_dspin_out.read) break;
     6302        if(not p_dspin_m2p.read) break;
    62976303        r_cc_send_fsm = CC_SEND_XRAM_RSP_BRDCAST_NLINE;
    62986304        break;
     
    63016307      case CC_SEND_XRAM_RSP_BRDCAST_NLINE:   // send second flit broadcast-inval (from XRAM_RSP FSM)
    63026308      {
    6303         if(not p_dspin_out.read) break;
     6309        if(not p_dspin_m2p.read) break;
    63046310        m_cpt_inval_brdcast++;
    63056311        r_xram_rsp_to_cc_send_brdcast_req = false;
     
    63176323      case CC_SEND_WRITE_BRDCAST_HEADER:   // send first flit broadcast-inval (from WRITE FSM)
    63186324      {
    6319         if(not p_dspin_out.read) break;
     6325        if(not p_dspin_m2p.read) break;
    63206326        r_cc_send_fsm = CC_SEND_WRITE_BRDCAST_NLINE;
    63216327        break;
     
    63246330      case CC_SEND_WRITE_BRDCAST_NLINE:   // send second flit broadcast-inval (from WRITE FSM)
    63256331      {
    6326         if(not p_dspin_out.read) break;
     6332        if(not p_dspin_m2p.read) break;
    63276333
    63286334        m_cpt_inval_brdcast++;
     
    63446350        if(m_write_to_cc_send_inst_fifo.rok())
    63456351        {
    6346           if(not p_dspin_out.read) break;
     6352          if(not p_dspin_m2p.read) break;
    63476353
    63486354          r_cc_send_fsm = CC_SEND_WRITE_UPDT_NLINE;
     
    63616367      case CC_SEND_WRITE_UPDT_NLINE:   // send second flit for a multi-update (from WRITE FSM)
    63626368      {
    6363         if(not p_dspin_out.read) break;
     6369        if(not p_dspin_m2p.read) break;
    63646370        m_cpt_update_mult++;
    63656371
     
    63786384      case CC_SEND_WRITE_UPDT_DATA:   // send N data flits for a multi-update (from WRITE FSM)
    63796385      {
    6380         if(not p_dspin_out.read) break;
     6386        if(not p_dspin_m2p.read) break;
    63816387        if(r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1))
    63826388        {
     
    63926398      case CC_SEND_CAS_BRDCAST_HEADER:   // send first flit  broadcast-inval (from CAS FSM)
    63936399      {
    6394         if(not p_dspin_out.read) break;
     6400        if(not p_dspin_m2p.read) break;
    63956401        r_cc_send_fsm = CC_SEND_CAS_BRDCAST_NLINE;
    63966402        break;
     
    63996405      case CC_SEND_CAS_BRDCAST_NLINE:   // send second flit broadcast-inval (from CAS FSM)
    64006406      {
    6401         if(not p_dspin_out.read) break;
     6407        if(not p_dspin_m2p.read) break;
    64026408        m_cpt_inval_brdcast++;
    64036409
     
    64186424        if(m_cas_to_cc_send_inst_fifo.rok())
    64196425        {
    6420           if(not p_dspin_out.read) break;
     6426          if(not p_dspin_m2p.read) break;
    64216427
    64226428          r_cc_send_fsm = CC_SEND_CAS_UPDT_NLINE;
     
    64366442      case CC_SEND_CAS_UPDT_NLINE:   // send second flit for a multi-update (from CAS FSM)
    64376443      {
    6438         if(not p_dspin_out.read) break;
     6444        if(not p_dspin_m2p.read) break;
    64396445
    64406446        m_cpt_update_mult++;
     
    64546460      case CC_SEND_CAS_UPDT_DATA:   // send first data for a multi-update (from CAS FSM)
    64556461      {
    6456         if(not p_dspin_out.read) break;
     6462        if(not p_dspin_m2p.read) break;
    64576463
    64586464        if(r_cas_to_cc_send_is_long.read())
     
    64696475      case CC_SEND_CAS_UPDT_DATA_HIGH:   // send second data for a multi-update (from CAS FSM)
    64706476      {
    6471         if(not p_dspin_out.read) break;
     6477        if(not p_dspin_m2p.read) break;
    64726478        cas_to_cc_send_fifo_get = true;
    64736479        r_cc_send_fsm = CC_SEND_CAS_UPDT_HEADER;
     
    64896495    case CC_RECEIVE_IDLE:
    64906496      {
    6491         if(not p_dspin_in.write) break;
     6497        if(not p_dspin_p2m.write) break;
    64926498
    64936499        uint8_t type =
    64946500          DspinDhccpParam::dspin_get(
    6495               p_dspin_in.data.read(),
     6501              p_dspin_p2m.data.read(),
    64966502              DspinDhccpParam::FROM_L1_TYPE);
    64976503
     
    65206526        // write first CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    65216527
    6522         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     6528        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    65236529          break;
    65246530
    6525         assert(not p_dspin_in.eop.read() and
     6531        assert(not p_dspin_p2m.eop.read() and
    65266532            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65276533            "CLEANUP command must have two flits");
     
    65376543        // write second CLEANUP flit in CC_RECEIVE to CLEANUP fifo
    65386544
    6539         if(not p_dspin_in.write or not m_cc_receive_to_cleanup_fifo.wok())
     6545        if(not p_dspin_p2m.write or not m_cc_receive_to_cleanup_fifo.wok())
    65406546          break;
    65416547
    6542         assert(p_dspin_in.eop.read() and
     6548        assert(p_dspin_p2m.eop.read() and
    65436549            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65446550            "CLEANUP command must have two flits");
     
    65566562
    65576563        // wait for a WOK in the CC_RECEIVE to MULTI_ACK fifo
    6558         if(not p_dspin_in.write or not m_cc_receive_to_multi_ack_fifo.wok())
     6564        if(not p_dspin_p2m.write or not m_cc_receive_to_multi_ack_fifo.wok())
    65596565          break;
    65606566
    6561         assert(p_dspin_in.eop.read() and
     6567        assert(p_dspin_p2m.eop.read() and
    65626568            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    65636569            "MULTI_ACK command must have one flit");
     
    69696975  //    ALLOC_UPT FSM
    69706976  ////////////////////////////////////////////////////////////////////////////////////
    6971   // The ALLOC_UPT FSM allocates the access to the Update/Inval Table (UPT),
    6972   // with a round robin priority between six FSMs, with the following order:
    6973   //  CONFIG > MULTI_ACK > WRITE > XRAM_RSP > CLEANUP > CAS
    6974   // - The CONFIG FSM initiates an inval transaction and sets a new entry in UPT.
     6977  // The ALLOC_UPT FSM allocates the access to the Update Table (UPT),
     6978  // with a round robin priority between three FSMs, with the following order:
     6979  //  WRITE -> CAS -> MULTI_ACK
     6980  // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
     6981  // - The CAS FSM does the same thing as the WRITE FSM.
    69756982  // - The MULTI_ACK FSM complete those trasactions and erase the UPT entry.
    6976   // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
    6977   // - The XRAM_RSP FSM initiates an inval transactions and sets a new entry in UPT.
    6978   // - The CLEANUP  FSM decrement an entry in UPT.
    6979   // - The CAS FSM does the same thing as the WRITE FSM.
    69806983  // The resource is always allocated.
    69816984  /////////////////////////////////////////////////////////////////////////////////////
    6982 
    69836985  switch(r_alloc_upt_fsm.read())
    69846986  {
    6985       //////////////////////
    6986       case ALLOC_UPT_CONFIG:   // allocated to CONFIG FSM
    6987       if (r_config_fsm.read() != CONFIG_DIR_UPT_LOCK)
    6988       {
    6989         if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    6990           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    6991                
    6992         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    6993                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    6994           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    6995 
    6996         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    6997           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    6998 
    6999         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7000           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7001 
    7002         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7003                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7004           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7005       }
    7006       break;
    7007 
    70086987      /////////////////////////
    7009       case ALLOC_UPT_MULTI_ACK:   // allocated to MULTI_ACK FSM
    7010       if( (r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK) and
    7011           (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
    7012       {
    7013         if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7014             (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7015           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7016 
    7017         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7018           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7019 
    7020         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7021           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7022 
    7023         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7024                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7025           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7026 
    7027         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7028           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7029       }
    7030       break;
    7031 
    7032       /////////////////////
    7033       case ALLOC_UPT_WRITE:   // allocated to WRITE FSM
    7034       if((r_write_fsm.read() != WRITE_UPT_LOCK) and
    7035           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
    7036       {
    7037         if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7038           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7039 
    7040         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7041           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7042 
    7043         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7044                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7045           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7046 
    7047         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7048           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7049 
    7050         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7051           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7052       }
    7053       break;
    7054 
    7055       ////////////////////////
    7056       case ALLOC_UPT_XRAM_RSP:
    7057       if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
    7058       {
    7059         if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7060           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7061 
    7062         else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7063                 (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7064           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7065 
    7066         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7067           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7068 
    7069         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7070           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7071 
    7072         else if((r_write_fsm.read() == WRITE_UPT_LOCK)   or
    7073                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7074           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7075       }
    7076       break;
    7077 
     6988      case ALLOC_UPT_WRITE:         // allocated to WRITE FSM
     6989          if (r_write_fsm.read() != WRITE_UPT_LOCK)
     6990          {
     6991              if (r_cas_fsm.read() == CAS_UPT_LOCK)
     6992                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6993
     6994              else if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6995                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     6996          }
     6997          break;
     6998
     6999      /////////////////////////
     7000      case ALLOC_UPT_CAS:           // allocated to CAS FSM
     7001          if (r_cas_fsm.read() != CAS_UPT_LOCK)
     7002          {
     7003              if (r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     7004                  r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     7005
     7006              else if (r_write_fsm.read() == WRITE_UPT_LOCK)
     7007                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     7008          }
     7009          break;
     7010
     7011      /////////////////////////
     7012      case ALLOC_UPT_MULTI_ACK:     // allocated to MULTI_ACK FSM
     7013          if ((r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK ) and
     7014              (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
     7015          {
     7016              if (r_write_fsm.read() == WRITE_UPT_LOCK)
     7017                  r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     7018
     7019              else if (r_cas_fsm.read() == CAS_UPT_LOCK)
     7020                  r_alloc_upt_fsm = ALLOC_UPT_CAS;
     7021          }
     7022          break;
     7023  } // end switch r_alloc_upt_fsm
     7024
     7025  ////////////////////////////////////////////////////////////////////////////////////
     7026  //    ALLOC_IVT FSM
     7027  ////////////////////////////////////////////////////////////////////////////////////
     7028  // The ALLOC_IVT FSM allocates the access to the Invalidate Table (IVT),
     7029  // with a round robin priority between five FSMs, with the following order:
     7030  //  WRITE -> XRAM_RSP -> CLEANUP -> CAS -> CONFIG
     7031  // - The WRITE FSM initiates broadcast invalidate transactions and sets a new entry
     7032  //   in IVT.
     7033  // - The CAS FSM does the same thing as the WRITE FSM.
     7034  // - The XRAM_RSP FSM initiates broadcast/multicast invalidate transaction and sets
     7035  //   a new entry in the IVT
     7036  // - The CONFIG FSM does the same thing as the XRAM_RSP FSM
     7037  // - The CLEANUP FSM complete those trasactions and erase the IVT entry.
     7038  // The resource is always allocated.
     7039  /////////////////////////////////////////////////////////////////////////////////////
     7040  switch(r_alloc_ivt_fsm.read())
     7041  {
    70787042      //////////////////////////
    7079       case ALLOC_UPT_CLEANUP:
    7080       if((r_cleanup_fsm.read() != CLEANUP_UPT_LOCK     ) and
    7081          (r_cleanup_fsm.read() != CLEANUP_UPT_DECREMENT))
    7082       {
    7083         if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    7084             (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    7085           r_alloc_upt_fsm = ALLOC_UPT_CAS;
    7086 
    7087         else if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7088           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7089 
    7090         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7091           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7092 
    7093         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7094                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7095           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7096 
    7097         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7098           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7099       }
    7100       break;
     7043      case ALLOC_IVT_WRITE:            // allocated to WRITE FSM
     7044          if (r_write_fsm.read() != WRITE_BC_IVT_LOCK)
     7045          {
     7046              if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7047                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7048
     7049              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7050                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7051
     7052              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7053                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7054
     7055              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7056                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7057          }
     7058          break;
    71017059
    71027060      //////////////////////////
    7103       case ALLOC_UPT_CAS:
    7104       if((r_cas_fsm.read() != CAS_UPT_LOCK) and
    7105           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
    7106       {
    7107         if(r_config_fsm.read() == CONFIG_DIR_UPT_LOCK)
    7108           r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    7109 
    7110         else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    7111           r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    7112 
    7113         else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    7114                 (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    7115           r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    7116 
    7117         else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
    7118           r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
    7119 
    7120         else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
    7121           r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    7122       }
    7123       break;
    7124 
    7125   } // end switch r_alloc_upt_fsm
     7061      case ALLOC_IVT_XRAM_RSP:         // allocated to XRAM_RSP FSM
     7062          if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
     7063          {
     7064              if(r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7065                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7066
     7067              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7068                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7069
     7070              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7071                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7072
     7073              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7074                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7075          }
     7076          break;
     7077
     7078      //////////////////////////
     7079      case ALLOC_IVT_CLEANUP:          // allocated to CLEANUP FSM
     7080          if ((r_cleanup_fsm.read() != CLEANUP_IVT_LOCK     ) and
     7081              (r_cleanup_fsm.read() != CLEANUP_IVT_DECREMENT))
     7082          {
     7083              if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7084                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7085
     7086              else if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7087                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7088
     7089              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7090                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7091
     7092              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7093                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7094          }
     7095          break;
     7096
     7097      //////////////////////////
     7098      case ALLOC_IVT_CAS:              // allocated to CAS FSM
     7099          if (r_cas_fsm.read() != CAS_BC_IVT_LOCK)
     7100          {
     7101              if (r_config_fsm.read() == CONFIG_DIR_IVT_LOCK)
     7102                  r_alloc_ivt_fsm = ALLOC_IVT_CONFIG;
     7103
     7104              else if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7105                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7106
     7107              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7108                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7109
     7110              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7111                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7112          }
     7113          break;
     7114
     7115      //////////////////////////
     7116      case ALLOC_IVT_CONFIG:           // allocated to CONFIG FSM
     7117          if (r_config_fsm.read() != CONFIG_DIR_IVT_LOCK)
     7118          {
     7119              if (r_write_fsm.read() == WRITE_BC_IVT_LOCK)
     7120                  r_alloc_ivt_fsm = ALLOC_IVT_WRITE;
     7121
     7122              else if (r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     7123                  r_alloc_ivt_fsm = ALLOC_IVT_XRAM_RSP;
     7124
     7125              else if (r_cleanup_fsm.read() == CLEANUP_IVT_LOCK)
     7126                  r_alloc_ivt_fsm = ALLOC_IVT_CLEANUP;
     7127
     7128              else if (r_cas_fsm.read() == CAS_BC_IVT_LOCK)
     7129                  r_alloc_ivt_fsm = ALLOC_IVT_CAS;
     7130          }
     7131          break;
     7132
     7133  } // end switch r_alloc_ivt_fsm
    71267134
    71277135  ////////////////////////////////////////////////////////////////////////////////////
     
    71537161    if ( (r_config_fsm.read()    != CONFIG_DIR_REQ) and
    71547162         (r_config_fsm.read()    != CONFIG_DIR_ACCESS) and
    7155          (r_config_fsm.read()    != CONFIG_DIR_UPT_LOCK) )
     7163         (r_config_fsm.read()    != CONFIG_DIR_IVT_LOCK) )
    71567164    {
    71577165        if(r_read_fsm.read() == READ_DIR_REQ)
     
    72067214        (r_write_fsm.read()       != WRITE_DIR_HIT)  and
    72077215        (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  and
    7208         (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  and
     7216        (r_write_fsm.read()       != WRITE_BC_IVT_LOCK)  and
    72097217        (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  and
    72107218        (r_write_fsm.read()       != WRITE_UPT_LOCK)  and
     
    72427250        (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  and
    72437251        (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  and
    7244         (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  and
     7252        (r_cas_fsm.read()         != CAS_BC_IVT_LOCK)  and
    72457253        (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  and
    72467254        (r_cas_fsm.read()         != CAS_UPT_LOCK)  and
     
    73567364      if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
    73577365          (r_write_fsm.read() != WRITE_BC_TRT_LOCK) and
    7358           (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
     7366          (r_write_fsm.read() != WRITE_BC_IVT_LOCK))
    73597367      {
    73607368        if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
     
    73797387      if((r_cas_fsm.read() != CAS_MISS_TRT_LOCK) and
    73807388          (r_cas_fsm.read() != CAS_BC_TRT_LOCK) and
    7381           (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
     7389          (r_cas_fsm.read() != CAS_BC_IVT_LOCK))
    73827390      {
    73837391        if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
     
    76697677  m_cc_receive_to_cleanup_fifo.update( cc_receive_to_cleanup_fifo_get,
    76707678                                       cc_receive_to_cleanup_fifo_put,
    7671                                        p_dspin_in.data.read() );
     7679                                       p_dspin_p2m.data.read() );
    76727680
    76737681  ////////////////////////////////////////////////////////////////////////////////////
     
    76777685  m_cc_receive_to_multi_ack_fifo.update( cc_receive_to_multi_ack_fifo_get,
    76787686                                         cc_receive_to_multi_ack_fifo_put,
    7679                                          p_dspin_in.data.read() );
     7687                                         p_dspin_p2m.data.read() );
    76807688
    76817689  ////////////////////////////////////////////////////////////////////////////////////
     
    80198027
    80208028  ////////////////////////////////////////////////////////////////////
    8021   //  p_dspin_out port (CC_SEND FSM)
     8029  //  p_dspin_m2p port (CC_SEND FSM)
    80228030  ////////////////////////////////////////////////////////////////////
    80238031
    8024   p_dspin_out.write = false;
    8025   p_dspin_out.eop   = false;
    8026   p_dspin_out.data  = 0;
     8032  p_dspin_m2p.write = false;
     8033  p_dspin_m2p.eop   = false;
     8034  p_dspin_m2p.data  = 0;
    80278035
    80288036  switch(r_cc_send_fsm.read())
     
    80698077                                    multi_inval_type,
    80708078                                    DspinDhccpParam::FROM_MC_TYPE);
    8071         p_dspin_out.write = true;
    8072         p_dspin_out.data  = flit;
     8079        p_dspin_m2p.write = true;
     8080        p_dspin_m2p.data  = flit;
    80738081        break;
    80748082    }
     
    80808088                                    r_config_to_cc_send_nline.read(),
    80818089                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8082         p_dspin_out.eop   = true;
    8083         p_dspin_out.write = true;
    8084         p_dspin_out.data  = flit;
     8090        p_dspin_m2p.eop   = true;
     8091        p_dspin_m2p.write = true;
     8092        p_dspin_m2p.data  = flit;
    80858093        break;
    80868094    }
     
    81238131            DspinDhccpParam::FROM_MC_TYPE);
    81248132
    8125         p_dspin_out.eop   = true;
    8126         p_dspin_out.write = true;
    8127         p_dspin_out.data  = flit;
     8133        p_dspin_m2p.eop   = true;
     8134        p_dspin_m2p.write = true;
     8135        p_dspin_m2p.data  = flit;
    81288136
    81298137        break;
     
    81648172                                    multi_inval_type,
    81658173                                    DspinDhccpParam::FROM_MC_TYPE);
    8166         p_dspin_out.write = true;
    8167         p_dspin_out.data  = flit;
     8174        p_dspin_m2p.write = true;
     8175        p_dspin_m2p.data  = flit;
    81688176        break;
    81698177    }
     
    81778185                                    r_xram_rsp_to_cc_send_nline.read(),
    81788186                                    DspinDhccpParam::MULTI_INVAL_NLINE);
    8179         p_dspin_out.eop   = true;
    8180         p_dspin_out.write = true;
    8181         p_dspin_out.data  = flit;
     8187        p_dspin_m2p.eop   = true;
     8188        p_dspin_m2p.write = true;
     8189        p_dspin_m2p.data  = flit;
    81828190        break;
    81838191    }
     
    82028210                                    1ULL,
    82038211                                    DspinDhccpParam::FROM_MC_BC);
    8204         p_dspin_out.write = true;
    8205         p_dspin_out.data  = flit;
     8212        p_dspin_m2p.write = true;
     8213        p_dspin_m2p.data  = flit;
    82068214        break;
    82078215    }
     
    82138221                                    r_xram_rsp_to_cc_send_nline.read(),
    82148222                                    DspinDhccpParam::BROADCAST_NLINE);
    8215         p_dspin_out.write = true;
    8216         p_dspin_out.eop   = true;
    8217         p_dspin_out.data  = flit;
     8223        p_dspin_m2p.write = true;
     8224        p_dspin_m2p.eop   = true;
     8225        p_dspin_m2p.data  = flit;
    82188226        break;
    82198227    }
     
    82258233                                    r_config_to_cc_send_nline.read(),
    82268234                                    DspinDhccpParam::BROADCAST_NLINE);
    8227         p_dspin_out.write = true;
    8228         p_dspin_out.eop   = true;
    8229         p_dspin_out.data  = flit;
     8235        p_dspin_m2p.write = true;
     8236        p_dspin_m2p.eop   = true;
     8237        p_dspin_m2p.data  = flit;
    82308238        break;
    82318239    }
     
    82378245                                    r_write_to_cc_send_nline.read(),
    82388246                                    DspinDhccpParam::BROADCAST_NLINE);
    8239         p_dspin_out.write = true;
    8240         p_dspin_out.eop   = true;
    8241         p_dspin_out.data  = flit;
     8247        p_dspin_m2p.write = true;
     8248        p_dspin_m2p.eop   = true;
     8249        p_dspin_m2p.data  = flit;
    82428250        break;
    82438251    }
     
    82498257                                    r_cas_to_cc_send_nline.read(),
    82508258                                    DspinDhccpParam::BROADCAST_NLINE);
    8251         p_dspin_out.write = true;
    8252         p_dspin_out.eop   = true;
    8253         p_dspin_out.data  = flit;
     8259        p_dspin_m2p.write = true;
     8260        p_dspin_m2p.eop   = true;
     8261        p_dspin_m2p.data  = flit;
    82548262        break;
    82558263    }
     
    82948302            DspinDhccpParam::FROM_MC_TYPE);
    82958303
    8296         p_dspin_out.write = true;
    8297         p_dspin_out.data  = flit;
     8304        p_dspin_m2p.write = true;
     8305        p_dspin_m2p.data  = flit;
    82988306
    82998307        break;
     
    83148322            DspinDhccpParam::MULTI_UPDT_NLINE);
    83158323
    8316         p_dspin_out.write = true;
    8317         p_dspin_out.data  = flit;
     8324        p_dspin_m2p.write = true;
     8325        p_dspin_m2p.data  = flit;
    83188326
    83198327        break;
     
    83418349            DspinDhccpParam::MULTI_UPDT_DATA);
    83428350
    8343         p_dspin_out.write = true;
    8344         p_dspin_out.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
    8345         p_dspin_out.data  = flit;
     8351        p_dspin_m2p.write = true;
     8352        p_dspin_m2p.eop   = (r_cc_send_cpt.read() == (r_write_to_cc_send_count.read()-1));
     8353        p_dspin_m2p.data  = flit;
    83468354
    83478355        break;
     
    83878395            DspinDhccpParam::FROM_MC_TYPE);
    83888396
    8389         p_dspin_out.write = true;
    8390         p_dspin_out.data  = flit;
     8397        p_dspin_m2p.write = true;
     8398        p_dspin_m2p.data  = flit;
    83918399
    83928400        break;
     
    84078415            DspinDhccpParam::MULTI_UPDT_NLINE);
    84088416
    8409         p_dspin_out.write = true;
    8410         p_dspin_out.data  = flit;
     8417        p_dspin_m2p.write = true;
     8418        p_dspin_m2p.data  = flit;
    84118419
    84128420        break;
     
    84278435            DspinDhccpParam::MULTI_UPDT_DATA);
    84288436
    8429         p_dspin_out.write = true;
    8430         p_dspin_out.eop   = not r_cas_to_cc_send_is_long.read();
    8431         p_dspin_out.data  = flit;
     8437        p_dspin_m2p.write = true;
     8438        p_dspin_m2p.eop   = not r_cas_to_cc_send_is_long.read();
     8439        p_dspin_m2p.data  = flit;
    84328440
    84338441        break;
     
    84488456            DspinDhccpParam::MULTI_UPDT_DATA);
    84498457
    8450         p_dspin_out.write = true;
    8451         p_dspin_out.eop   = true;
    8452         p_dspin_out.data  = flit;
     8458        p_dspin_m2p.write = true;
     8459        p_dspin_m2p.eop   = true;
     8460        p_dspin_m2p.data  = flit;
    84538461
    84548462        break;
     
    84578465
    84588466  ///////////////////////////////////////////////////////////////////
    8459   //  p_dspin_in port (CC_RECEIVE FSM)
     8467  //  p_dspin_p2m port (CC_RECEIVE FSM)
    84608468  ///////////////////////////////////////////////////////////////////
    8461   p_dspin_in.read = false;
     8469  p_dspin_p2m.read = false;
    84628470  switch(r_cc_receive_fsm.read())
    84638471  {
     
    84698477    case CC_RECEIVE_CLEANUP_EOP:
    84708478      {
    8471         p_dspin_in.read = m_cc_receive_to_cleanup_fifo.wok();
     8479        p_dspin_p2m.read = m_cc_receive_to_cleanup_fifo.wok();
    84728480        break;
    84738481      }
    84748482    case CC_RECEIVE_MULTI_ACK:
    84758483      {
    8476         p_dspin_in.read = m_cc_receive_to_multi_ack_fifo.wok();
     8484        p_dspin_p2m.read = m_cc_receive_to_multi_ack_fifo.wok();
    84778485        break;
    84788486      }
Note: See TracChangeset for help on using the changeset viewer.