Ignore:
Timestamp:
Jul 12, 2013, 12:16:30 PM (11 years ago)
Author:
alain
Message:

Introducing a preliminary configuration interface in vci_mem_cache.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r431 r434  
    3434#include "../include/vci_mem_cache.h"
    3535
    36 //////   debug services   ///////////////////////////////////////////////////////
     36//////   debug services   /////////////////////////////////////////////////////////////
    3737// All debug messages are conditionned by two variables:
    3838// - compile time   : DEBUG_MEMC_*** : defined below
    39 // - execution time : m_debug_***    : defined by constructor arguments
    40 //    m_debug_* = (m_debug_ok) and (m_cpt_cycle > m_debug_start_cycle)
    41 /////////////////////////////////////////////////////////////////////////////////
     39// - execution time : m_debug  = (m_debug_ok) and (m_cpt_cycle > m_debug_start_cycle)
     40///////////////////////////////////////////////////////////////////////////////////////
    4241
    4342#define DEBUG_MEMC_GLOBAL    0 // synthetic trace of all FSMs
     43#define DEBUG_MEMC_CONFIG    1 // detailed trace of CONFIG FSM
    4444#define DEBUG_MEMC_READ      1 // detailed trace of READ FSM
    4545#define DEBUG_MEMC_WRITE     1 // detailed trace of WRITE FSM
    … …  
    6464  "TGT_CMD_READ",
    6565  "TGT_CMD_WRITE",
    66   "TGT_CMD_CAS"
     66  "TGT_CMD_CAS",
     67  "TGT_CMD_CONFIG"
    6768};
    6869const char *tgt_rsp_fsm_str[] =
    … …  
    118119  "MULTI_ACK_UPT_LOCK",
    119120  "MULTI_ACK_UPT_CLEAR",
    120   "MULTI_ACK_WRITE_RSP"
     121  "MULTI_ACK_WRITE_RSP",
     122  "MULTI_ACK_CONFIG_ACK"
    121123};
    122124const char *read_fsm_str[] =
    … …  
    237239  "CLEANUP_UPT_CLEAR",
    238240  "CLEANUP_WRITE_RSP",
    239   "CLEANUP_SEND_ACK"
     241  "CLEANUP_CONFIG_ACK",
     242  "CLEANUP_SEND_CLACK"
    240243};
    241244const char *alloc_dir_fsm_str[] =
    … …  
    457460    for(seg = m_seglist.begin() ; seg != m_seglist.end() ; seg++)
    458461    {
     462        if ( seg->special() ) m_seg_config = i;
    459463        m_seg[i] = & (*seg);
    460464        i++;
    … …  
    631635    // Initializing FSMs
    632636    r_tgt_cmd_fsm    = TGT_CMD_IDLE;
     637    r_config_fsm     = CONFIG_IDLE;
    633638    r_tgt_rsp_fsm    = TGT_RSP_TGT_CMD_IDLE;
    634639    r_cc_send_fsm    = CC_SEND_XRAM_RSP_IDLE;
    … …  
    647652    r_ixr_cmd_fsm    = IXR_CMD_READ_IDLE;
    648653
    649     m_debug_global         = false;
    650     m_debug_tgt_cmd_fsm    = false;
    651     m_debug_tgt_rsp_fsm    = false;
    652     m_debug_cc_send_fsm    = false;
    653     m_debug_cc_receive_fsm = false;
    654     m_debug_multi_ack_fsm  = false;
    655     m_debug_read_fsm       = false;
    656     m_debug_write_fsm      = false;
    657     m_debug_cas_fsm        = false;
    658     m_debug_cleanup_fsm    = false;
    659     m_debug_ixr_cmd_fsm    = false;
    660     m_debug_ixr_rsp_fsm    = false;
    661     m_debug_xram_rsp_fsm   = false;
     654    m_debug                = false;
    662655    m_debug_previous_hit   = false;
    663656    m_debug_previous_count = 0;
    … …  
    690683    m_cmd_cas_eop_fifo.init()   ;
    691684
     685    r_config_cmd  = MEMC_CMD_NOP;
     686    r_config_lock = false;
     687
    692688    r_tgt_cmd_to_tgt_rsp_req = false;
    693689
    … …  
    697693    r_write_to_tgt_rsp_req          = false;
    698694    r_write_to_ixr_cmd_req          = false;
    699     r_write_to_cc_send_multi_req   = false;
    700     r_write_to_cc_send_brdcast_req = false;
     695    r_write_to_cc_send_multi_req    = false;
     696    r_write_to_cc_send_brdcast_req  = false;
    701697    r_write_to_multi_ack_req        = false;
    702698
    … …  
    816812#endif
    817813
    818   m_debug_global         = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    819   m_debug_tgt_cmd_fsm    = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    820   m_debug_tgt_rsp_fsm    = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    821   m_debug_cc_send_fsm    = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    822   m_debug_cc_receive_fsm = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    823   m_debug_multi_ack_fsm  = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    824   m_debug_read_fsm       = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    825   m_debug_write_fsm      = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    826   m_debug_cas_fsm        = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    827   m_debug_cleanup_fsm    = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    828   m_debug_ixr_cmd_fsm    = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    829   m_debug_ixr_rsp_fsm    = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    830   m_debug_xram_rsp_fsm   = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
     814  m_debug = (m_cpt_cycles > m_debug_start_cycle) and m_debug_ok;
    831815
    832816#if DEBUG_MEMC_GLOBAL
    833   if(m_debug_global)
    834   {
     817if(m_debug)
     818{
    835819    std::cout
    836820        << "---------------------------------------------"           << std::dec << std::endl
    … …  
    853837        << " - ALLOC_UPT FSM  = "  << alloc_upt_fsm_str[r_alloc_upt_fsm.read()]   << std::endl
    854838        << " - ALLOC_HEAP FSM = "  << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
    855   }
     839}
    856840#endif
    857841
    … …  
    859843  //    TGT_CMD FSM
    860844  ////////////////////////////////////////////////////////////////////////////////////
    861   // The TGT_CMD_FSM controls the incoming VCI command pakets from the processors
     845  // The TGT_CMD_FSM controls the incoming VCI command pakets from the processors,
     846  // and dispatch these commands to the proper FSM through dedicated FIFOs.
    862847  //
    863   // There are 5 types of accepted commands :
    864   // - READ   : A READ request has a length of 1 VCI cell. It can be a single word
    865   //            or an entire cache line, depending on the PLEN value.
    866   // - WRITE  : A WRITE request has a maximum length of 16 cells, and can only
    867   //            concern words in a same line.
    868   // - CAS    : A CAS request has a length of 2 cells or 4 cells.
    869   // - LL     : An LL request has a length of 1 cell.
    870   // - SC     : An SC request has a length of 2 cells. First cell contains the
    871   //            acces key, second cell the data to write in case of success.
     848  // There are 5 types of commands accepted in the XRAM segment:
     849  // - READ   : A READ request has a length of 1 VCI flit. It can be a single word
     850  //            or an entire cache line, depending on the PLEN value => READ FSM
     851  // - WRITE  : A WRITE request has a maximum length of 16 flits, and can only
     852  //            concern words in a same line => WRITE FSM
     853  // - CAS    : A CAS request has a length of 2 flits or 4 flits => CAS FSM
     854  // - LL     : An LL request has a length of 1 flit => READ FSM
     855  // - SC     : An SC request has a length of 2 flits. First flit contains the
     856  //            acces key, second flit the data to write => WRITE FSM.
     857  //
     858  // The READ/WRITE commands accepted in the configuration segment are targeting,
     859  // configuration or status registers. They must contain one single flit.
     860  // - For almost all addressable registers, the response is returned immediately.
     861  // - For MEMC_CMD_TYPE, the response is delayed until the operation is completed.
    872862  ////////////////////////////////////////////////////////////////////////////////////
    873863
    874864  switch(r_tgt_cmd_fsm.read())
    875865  {
    876       //////////////////
    877     case TGT_CMD_IDLE:
    878       if(p_vci_tgt.cmdval)
    879       {
     866    //////////////////
     867    case TGT_CMD_IDLE:     // waiting a VCI command (RAM or CONFIG)
     868    if(p_vci_tgt.cmdval)
     869    {
    880870
    881871#if DEBUG_MEMC_TGT_CMD
    882         if(m_debug_tgt_cmd_fsm)
    883         {
    884           std::cout
    885               << "  <MEMC " << name()
    886               << " TGT_CMD_IDLE> Receive command from srcid "
    887               << std::dec << p_vci_tgt.srcid.read()
    888               << " / for address "
    889               << std::hex << p_vci_tgt.address.read()
    890               << std::endl;
    891         }
     872if(m_debug)
     873std::cout << "  <MEMC " << name()
     874          << " TGT_CMD_IDLE> Receive command from srcid "
     875          << std::dec << p_vci_tgt.srcid.read()
     876          << " / address " << std::hex << p_vci_tgt.address.read() << std::endl;
    892877#endif
    893878        // checking segmentation violation
    894         addr_t  address = p_vci_tgt.address.read();
    895         uint32_t    plen    = p_vci_tgt.plen.read();
    896         bool found = false;
    897         for(size_t seg_id = 0 ; seg_id < m_nseg ; seg_id++)
    898         {
    899           if(m_seg[seg_id]->contains(address) &&
    900               m_seg[seg_id]->contains(address + plen - vci_param_int::B))
    901           {
    902             found = true;
    903           }
    904         }
    905 
    906         if(not found)
    907         {
    908           r_tgt_cmd_fsm = TGT_CMD_ERROR;
    909         }
    910         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)
    911         {
    912           // check that the pktid is either :
    913           // TYPE_READ_DATA_UNC
    914           // TYPE_READ_DATA_MISS
    915           // TYPE_READ_INS_UNC
    916           // TYPE_READ_INS_MISS
    917           // ==> bit2 must be zero with the TSAR encoding
    918           // ==> mask = 0b0100 = 0x4
    919           assert(((p_vci_tgt.pktid.read() & 0x4) == 0x0) &&
    920                  "The type specified in the pktid field is incompatible with the READ CMD");
    921           r_tgt_cmd_fsm = TGT_CMD_READ;
    922         }
    923         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
    924         {
    925           // check that the pktid is TYPE_WRITE
    926           // ==> TYPE_WRITE = X100 with the TSAR encoding
    927           // ==> mask = 0b0111 = 0x7
    928           assert(((p_vci_tgt.pktid.read() & 0x7) == 0x4) &&
    929                  "The type specified in the pktid field is incompatible with the WRITE CMD");
    930           r_tgt_cmd_fsm = TGT_CMD_WRITE;
    931         }
    932         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
    933         {
    934           // check that the pktid is TYPE_LL
    935           // ==> TYPE_LL = X110 with the TSAR encoding
    936           // ==> mask = 0b0111 = 0x7
    937           assert(((p_vci_tgt.pktid.read() & 0x7) == 0x6) &&
    938                  "The type specified in the pktid field is incompatible with the LL CMD");
    939           r_tgt_cmd_fsm = TGT_CMD_READ;
    940         }
    941         else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP)
    942         {
    943           // check that the pktid is either :
    944           // TYPE_CAS
    945           // TYPE_SC
    946           // ==> TYPE_CAS = X101 with the TSAR encoding
    947           // ==> TYPE_SC  = X111 with the TSAR encoding
    948           // ==> mask = 0b0101 = 0x5
    949           assert(((p_vci_tgt.pktid.read() & 0x5) == 0x5) &&
    950                  "The type specified in the pktid field is incompatible with the NOP CMD");
    951 
    952           if((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS)
    953             r_tgt_cmd_fsm = TGT_CMD_CAS;
    954           else // TYPE_SC
    955             r_tgt_cmd_fsm = TGT_CMD_WRITE;
    956         }
    957         else
    958         {
    959           std::cout << "VCI_MEM_CACHE ERROR " << name()
    960                     << " TGT_CMD_IDLE state" << std::endl;
    961           std::cout << " illegal VCI command type" << std::endl;
    962           exit(0);
    963         }
    964       }
    965       break;
    966 
    967     case TGT_CMD_ERROR:
    968       // A segmentation violation has been detected, thus a response with error
    969       // must be sent
    970 
    971       // wait if pending TGT_CMD request to TGT_RSP FSM
    972       if(r_tgt_cmd_to_tgt_rsp_req.read()) break;
    973 
    974       // consume all the command packet flits and set new request to the
    975       // TGT_RSP FSM
    976       if(p_vci_tgt.cmdval and p_vci_tgt.eop)
    977       {
    978         r_tgt_cmd_to_tgt_rsp_req   = true;
     879        addr_t      address  = p_vci_tgt.address.read();
     880        uint32_t    plen     = p_vci_tgt.plen.read();
     881        bool        found    = false;
     882        bool        config   = false;
     883
     884        // register arguments for response (segmentation violation or config)
    979885        r_tgt_cmd_to_tgt_rsp_srcid = p_vci_tgt.srcid.read();
    980886        r_tgt_cmd_to_tgt_rsp_trdid = p_vci_tgt.trdid.read();
    981887        r_tgt_cmd_to_tgt_rsp_pktid = p_vci_tgt.pktid.read();
    982888
    983         r_tgt_cmd_fsm = TGT_CMD_IDLE;
     889        for(size_t seg_id = 0 ; (seg_id < m_nseg) and not found ; seg_id++)
     890        {
     891            if( m_seg[seg_id]->contains(address) and
     892                m_seg[seg_id]->contains(address + plen - vci_param_int::B) )
     893            {
     894                found = true;
     895                if ( m_seg[seg_id]->special() ) config = true;
     896            }
     897        }
     898
     899        if ( not found )                /////////// out of segment error
     900        {
     901            r_tgt_cmd_fsm   = TGT_CMD_ERROR;
     902        }
     903        else if ( config )              /////////// configuration command
     904        {
     905            if ( not p_vci_tgt.eop.read() ) r_tgt_cmd_fsm = TGT_CMD_ERROR;
     906            else                            r_tgt_cmd_fsm = TGT_CMD_CONFIG;
     907        }
     908        else                            //////////// memory access
     909        {
     910            if ( p_vci_tgt.cmd.read() == vci_param_int::CMD_READ )
     911            {
     912                // check that the pktid is either :
     913                // TYPE_READ_DATA_UNC
     914                // TYPE_READ_DATA_MISS
     915                // TYPE_READ_INS_UNC
     916                // TYPE_READ_INS_MISS
     917                // ==> bit2 must be zero with the TSAR encoding
     918                // ==> mask = 0b0100 = 0x4
     919                assert( ((p_vci_tgt.pktid.read() & 0x4) == 0x0) and
     920                "The type specified in the pktid field is incompatible with the READ CMD");
     921                r_tgt_cmd_fsm = TGT_CMD_READ;
     922            }
     923            else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)
     924            {
     925                // check that the pktid is TYPE_WRITE
     926                // ==> TYPE_WRITE = X100 with the TSAR encoding
     927                // ==> mask = 0b0111 = 0x7
     928                assert(((p_vci_tgt.pktid.read() & 0x7) == 0x4) and
     929                "The type specified in the pktid field is incompatible with the WRITE CMD");
     930                r_tgt_cmd_fsm = TGT_CMD_WRITE;
     931            }
     932            else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
     933            {
     934                // check that the pktid is TYPE_LL
     935                // ==> TYPE_LL = X110 with the TSAR encoding
     936                // ==> mask = 0b0111 = 0x7
     937                assert(((p_vci_tgt.pktid.read() & 0x7) == 0x6) and
     938                "The type specified in the pktid field is incompatible with the LL CMD");
     939                r_tgt_cmd_fsm = TGT_CMD_READ;
     940            }
     941            else if(p_vci_tgt.cmd.read() == vci_param_int::CMD_NOP)
     942            {
     943                // check that the pktid is either :
     944                // TYPE_CAS
     945                // TYPE_SC
     946                // ==> TYPE_CAS = X101 with the TSAR encoding
     947                // ==> TYPE_SC  = X111 with the TSAR encoding
     948                // ==> mask = 0b0101 = 0x5
     949                assert(((p_vci_tgt.pktid.read() & 0x5) == 0x5) and
     950                "The type specified in the pktid field is incompatible with the NOP CMD");
     951
     952                if((p_vci_tgt.pktid.read() & 0x7) == TYPE_CAS) r_tgt_cmd_fsm = TGT_CMD_CAS;
     953                else                                           r_tgt_cmd_fsm = TGT_CMD_WRITE;
     954            }
     955            else
     956            {
     957                r_tgt_cmd_fsm = TGT_CMD_ERROR;
     958            }
     959        }
     960    }
     961    break;
     962
     963    ///////////////////
     964    case TGT_CMD_ERROR:  // response error must be sent
     965
     966    // wait if pending TGT_CMD request to TGT_RSP FSM
     967    if(r_tgt_cmd_to_tgt_rsp_req.read()) break;
     968
     969    // consume all the command packet flits before sending response error
     970    if ( p_vci_tgt.cmdval and p_vci_tgt.eop )
     971    {
     972        r_tgt_cmd_to_tgt_rsp_req   = true;
     973        r_tgt_cmd_to_tgt_rsp_error = 1;
     974        r_tgt_cmd_fsm              = TGT_CMD_IDLE;
    984975
    985976#if DEBUG_MEMC_TGT_CMD
    986 if(m_debug_tgt_cmd_fsm)
     977if(m_debug)
    987978  std::cout << "  <MEMC " << name()
    988979    << " TGT_CMD_ERROR> Segmentation violation:"
    … …  
    993984    << " / plen = " << std::dec << p_vci_tgt.plen.read() << std::endl;
    994985#endif
    995       }
    996 
    997       break;
    998 
    999       //////////////////
    1000     case TGT_CMD_READ:
    1001       // This test checks that the read does not cross a cache line limit.
    1002       // It must not be taken into account when dealing with an LL CMD.
    1003       if(((m_x[(addr_t) p_vci_tgt.address.read()]+ (p_vci_tgt.plen.read() >>2)) > 16) &&
     986
     987    }
     988    break;
     989
     990    ////////////////////
     991    case TGT_CMD_CONFIG:    // execute config request and return response
     992    {
     993        if ( r_tgt_cmd_to_tgt_rsp_req.read() ) break;
     994
     995        addr_t   seg_base = m_seg[m_seg_config]->baseAddress();
     996        addr_t   address  = p_vci_tgt.address.read();
     997        size_t   cell     = (address - seg_base)/vci_param_int::B;
     998        bool     need_rsp = true;  // default value
     999        size_t   error    = 0;     // default value
     1000        uint32_t rdata    = 0;     // default value
     1001
     1002        if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_READ)         // get lock
     1003             and (cell == MEMC_LOCK) )
     1004        {
     1005            rdata         = (uint32_t)r_config_lock.read();
     1006            r_config_lock = true;
     1007        }
     1008        else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)  // release lock
     1009                   and (cell == MEMC_LOCK) )
     1010        {
     1011            r_config_lock = false;
     1012        }
     1013        else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set cmd type
     1014                   and (cell == MEMC_CMD_TYPE) )
     1015        {
     1016            r_config_cmd = p_vci_tgt.wdata.read();
     1017            need_rsp     = false;
     1018        }
     1019        else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_lo
     1020                   and (cell == MEMC_ADDR_LO) )
     1021        {
     1022            r_config_address = (r_config_address.read() & 0xFFFFFFFF00000000LL) |
     1023                               (addr_t)p_vci_tgt.wdata.read();
     1024        }
     1025        else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set addr_hi
     1026                   and (cell == MEMC_ADDR_HI) )
     1027        {
     1028            r_config_address = (r_config_address.read() & 0x00000000FFFFFFFFLL) |
     1029                               ((addr_t)p_vci_tgt.wdata.read())<<32;
     1030        }
     1031        else if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_WRITE)   // set buf_lines
     1032                   and (cell == MEMC_BUF_LENGTH) )
     1033        {
     1034            size_t lines = (size_t)(p_vci_tgt.wdata.read()/(m_words*vci_param_int::B));
     1035            if ( r_config_address.read()/(m_words*vci_param_int::B) ) lines++;
     1036            r_config_nlines = lines;
     1037        }
     1038        else
     1039        {
     1040            error = 1;
     1041        }
     1042
     1043        if ( need_rsp )
     1044        {
     1045            // blocked if previous pending request to TGT_RSP FSM
     1046            if ( r_tgt_cmd_to_tgt_rsp_req.read() ) break;
     1047
     1048            r_tgt_cmd_to_tgt_rsp_req   = true;
     1049            r_tgt_cmd_to_tgt_rsp_error = error;
     1050            r_tgt_cmd_to_tgt_rsp_rdata = rdata;
     1051            r_tgt_cmd_fsm              = TGT_CMD_IDLE;
     1052        }
     1053        else
     1054        {
     1055            r_tgt_cmd_fsm              = TGT_CMD_IDLE;
     1056        }
     1057
     1058#if DEBUG_MEMC_TGT_CMD
     1059if(m_debug)
     1060std::cout << "  <MEMC " << name() << " TGT_CMD_CONFIG> Configuration request:"
     1061          << " address = " << std::hex << p_vci_tgt.address.read()
     1062          << " / wdata = " << p_vci_tgt.wdata.read()
     1063          << " / error = " << error << std::endl;
     1064#endif
     1065        break;
     1066    }
     1067    //////////////////
     1068    case TGT_CMD_READ:    // Push a read request into read fifo
     1069
     1070    // check that the read does not cross a cache line limit.
     1071    if ( ((m_x[(addr_t) p_vci_tgt.address.read()]+ (p_vci_tgt.plen.read() >>2)) > 16) and
    10041072          (p_vci_tgt.cmd.read() != vci_param_int::CMD_LOCKED_READ))
    1005       {
    1006         std::cout
    1007             << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
    1008             << std::endl;
    1009         std::cout
    1010             << " illegal address/plen combination for VCI read command" << std::endl;
     1073    {
     1074        std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
     1075                  << " illegal address/plen for VCI read command" << std::endl;
    10111076        exit(0);
    1012       }
    1013       if(!p_vci_tgt.eop.read())
    1014       {
    1015         std::cout
    1016             << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
    1017             << std::endl;
    1018         std::cout
    1019             << " read or ll command packets must contain one single flit"
    1020             << std::endl;
     1077    }
     1078    // check single flit
     1079    if(!p_vci_tgt.eop.read())
     1080    {
     1081        std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
     1082                  << " read command packet must contain one single flit" << std::endl;
    10211083        exit(0);
    1022       }
    1023       if((p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) && (p_vci_tgt.plen.read() != 8))
    1024       {
    1025         std::cout
    1026             << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
    1027             << std::endl;
    1028         std::cout
    1029             << " ll command packets must have a plen of 8"
    1030             << std::endl;
     1084    }
     1085    // check plen for LL
     1086    if ( (p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) and
     1087         (p_vci_tgt.plen.read() != 8) )
     1088    {
     1089        std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_READ state"
     1090                  << " ll command packets must have a plen of 8" << std::endl;
    10311091        exit(0);
    1032       }
    1033 
    1034       if(p_vci_tgt.cmdval && m_cmd_read_addr_fifo.wok())
    1035       {
     1092    }
     1093
     1094    if ( p_vci_tgt.cmdval and m_cmd_read_addr_fifo.wok() )
     1095    {
    10361096
    10371097#if DEBUG_MEMC_TGT_CMD
    1038 if(m_debug_tgt_cmd_fsm)
     1098if(m_debug)
    10391099std::cout << "  <MEMC " << name() << " TGT_CMD_READ> Push into read_fifo:"
    10401100          << " address = " << std::hex << p_vci_tgt.address.read()
    … …  
    10451105#endif
    10461106        cmd_read_fifo_put = true;
    1047         if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ)
    1048           m_cpt_ll++;
    1049         else
    1050           m_cpt_read++;
     1107        if(p_vci_tgt.cmd.read() == vci_param_int::CMD_LOCKED_READ) m_cpt_ll++;
     1108        else                                                       m_cpt_read++;
    10511109        r_tgt_cmd_fsm = TGT_CMD_IDLE;
    1052       }
    1053       break;
    1054 
    1055       ///////////////////
     1110    }
     1111    break;
     1112
     1113    ///////////////////
    10561114    case TGT_CMD_WRITE:
    1057       if(p_vci_tgt.cmdval && m_cmd_write_addr_fifo.wok())
    1058       {
     1115    if(p_vci_tgt.cmdval and m_cmd_write_addr_fifo.wok())
     1116    {
    10591117
    10601118#if DEBUG_MEMC_TGT_CMD
    1061 if(m_debug_tgt_cmd_fsm)
     1119if(m_debug)
    10621120std::cout << "  <MEMC " << name() << " TGT_CMD_WRITE> Push into write_fifo:"
    10631121          << " address = " << std::hex << p_vci_tgt.address.read()
    … …  
    10711129        cmd_write_fifo_put = true;
    10721130        if(p_vci_tgt.eop)  r_tgt_cmd_fsm = TGT_CMD_IDLE;
    1073       }
    1074       break;
    1075 
    1076       ////////////////////
     1131    }
     1132    break;
     1133
     1134    /////////////////
    10771135    case TGT_CMD_CAS:
    1078       if((p_vci_tgt.plen.read() != 8) && (p_vci_tgt.plen.read() != 16))
    1079       {
    1080         std::cout
    1081             << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_CAS state"
    1082             << std::endl
    1083             << "illegal format for CAS command " << std::endl;
    1084 
     1136    if((p_vci_tgt.plen.read() != 8) and (p_vci_tgt.plen.read() != 16))
     1137    {
     1138        std::cout << "VCI_MEM_CACHE ERROR " << name() << " TGT_CMD_CAS state"
     1139                  << "illegal format for CAS command " << std::endl;
    10851140        exit(0);
    1086       }
    1087 
    1088       if(p_vci_tgt.cmdval && m_cmd_cas_addr_fifo.wok())
    1089       {
     1141    }
     1142
     1143    if(p_vci_tgt.cmdval and m_cmd_cas_addr_fifo.wok())
     1144    {
    10901145
    10911146#if DEBUG_MEMC_TGT_CMD
    1092 if(m_debug_tgt_cmd_fsm)
     1147if(m_debug)
    10931148std::cout << "  <MEMC " << name() << " TGT_CMD_CAS> Pushing command into cmd_cas_fifo:"
    10941149          << " address = " << std::hex << p_vci_tgt.address.read()
    … …  
    11021157        cmd_cas_fifo_put = true;
    11031158        if(p_vci_tgt.eop) r_tgt_cmd_fsm = TGT_CMD_IDLE;
    1104       }
    1105       break;
     1159    }
     1160    break;
    11061161  } // end switch tgt_cmd_fsm
    11071162
    … …  
    11151170  // It can be update or inval requests initiated by the WRITE or CAS FSM,
    11161171  // or inval requests initiated by the XRAM_RSP FSM.
    1117   // It can also be a direct request from the WRITE FSM.
    11181172  //
    11191173  // The FSM decrements the proper entry in UPT.
    … …  
    11291183  switch(r_multi_ack_fsm.read())
    11301184  {
    1131     ///////////////////
     1185    ////////////////////
    11321186    case MULTI_ACK_IDLE:
    1133       {
     1187    {
    11341188        bool multi_ack_fifo_rok = m_cc_receive_to_multi_ack_fifo.rok();
    11351189
    … …  
    11651219
    11661220#if DEBUG_MEMC_MULTI_ACK
    1167         if(m_debug_multi_ack_fsm)
    1168         {
    1169           if (multi_ack_fifo_rok)
    1170           {
    1171             std::cout
    1172               << "  <MEMC " << name()
    1173               << " MULTI_ACK_IDLE> Response for UPT entry "
    1174               << updt_index
    1175               << std::endl;
    1176           }
    1177           else
    1178           {
    1179             std::cout
    1180               << "  <MEMC " << name()
    1181               << " MULTI_ACK_IDLE> Write FSM request to decrement UPT entry "
    1182               << updt_index
    1183               << std::endl;
    1184           }
    1185         }
     1221if(m_debug)
     1222{
     1223    if (multi_ack_fifo_rok)
     1224    {
     1225        std::cout << "  <MEMC " << name()
     1226                  << " MULTI_ACK_IDLE> Response for UPT entry "
     1227                  << updt_index << std::endl;
     1228    }
     1229    else
     1230    {
     1231        std::cout << "  <MEMC " << name()
     1232                  << " MULTI_ACK_IDLE> Write FSM request to decrement UPT entry "
     1233                  << updt_index << std::endl;
     1234    }
     1235}
    11861236#endif
    11871237        break;
    … …  
    11901240    ////////////////////////
    11911241    case MULTI_ACK_UPT_LOCK:
    1192       {
     1242    {
    11931243        // get lock to the UPDATE table
    11941244        if(r_alloc_upt_fsm.read() != ALLOC_UPT_MULTI_ACK) break;
    … …  
    12001250        if(not valid)
    12011251        {
    1202           std::cout
    1203             << "VCI_MEM_CACHE ERROR " << name()
    1204             << " MULTI_ACK_UPT_LOCK state" << std::endl
    1205             << "unsuccessful access to decrement the UPT"
    1206             << std::endl;
    1207 
    1208           exit(0);
     1252            std::cout << "VCI_MEM_CACHE ERROR " << name()
     1253                      << " MULTI_ACK_UPT_LOCK state" << std::endl
     1254                      << "unsuccessful access to decrement the UPT" << std::endl;
     1255            exit(0);
    12091256        }
    12101257
    … …  
    12191266
    12201267#if DEBUG_MEMC_MULTI_ACK
    1221         if(m_debug_multi_ack_fsm)
    1222         {
    1223           std::cout
    1224             << "  <MEMC " << name()
    1225             << " MULTI_ACK_UPT_LOCK> Decrement the responses counter for UPT:"
    1226             << " entry = "       << r_multi_ack_upt_index.read()
    1227             << " / rsp_count = " << std::dec << count
    1228             << std::endl;
    1229         }
     1268if(m_debug)
     1269std::cout << "  <MEMC " << name()
     1270          << " MULTI_ACK_UPT_LOCK> Decrement the responses counter for UPT:"
     1271          << " entry = "       << r_multi_ack_upt_index.read()
     1272          << " / rsp_count = " << std::dec << count << std::endl;
    12301273#endif
    12311274        break;
    1232       }
     1275    }
    12331276
    12341277    /////////////////////////
    1235     case MULTI_ACK_UPT_CLEAR:
    1236       {
     1278    case MULTI_ACK_UPT_CLEAR:   // Clear UPT entry / Test if rsp or ack required
     1279    {
    12371280        if(r_alloc_upt_fsm.read() != ALLOC_UPT_MULTI_ACK)
    12381281        {
    1239           std::cout
    1240             << "VCI_MEM_CACHE ERROR " << name()
    1241             << " MULTI_ACK_UPT_CLEAR state"
    1242             << " bad UPT allocation"
    1243             << std::endl;
    1244 
    1245           exit(0);
     1282            std::cout << "VCI_MEM_CACHE ERROR " << name()
     1283                      << " MULTI_ACK_UPT_CLEAR state"
     1284                      << " bad UPT allocation" << std::endl;
     1285            exit(0);
    12461286        }
    12471287
    … …  
    12511291        r_multi_ack_nline = m_upt.nline(r_multi_ack_upt_index.read());
    12521292        bool need_rsp     = m_upt.need_rsp(r_multi_ack_upt_index.read());
     1293        bool need_ack     = m_upt.need_ack(r_multi_ack_upt_index.read());
    12531294
    12541295        // clear the UPT entry
    12551296        m_upt.clear(r_multi_ack_upt_index.read());
    12561297
    1257         if(need_rsp)
    1258         {
    1259           r_multi_ack_fsm = MULTI_ACK_WRITE_RSP;
    1260         }
    1261         else
    1262         {
    1263           r_multi_ack_fsm = MULTI_ACK_IDLE;
    1264         }
     1298        if      ( need_rsp ) r_multi_ack_fsm = MULTI_ACK_WRITE_RSP;
     1299        else if ( need_ack ) r_multi_ack_fsm = MULTI_ACK_CONFIG_ACK;
     1300        else                 r_multi_ack_fsm = MULTI_ACK_IDLE;
    12651301
    12661302#if DEBUG_MEMC_MULTI_ACK
    1267         if(m_debug_multi_ack_fsm)
    1268         {
    1269           std::cout
    1270             <<  "  <MEMC " << name()
    1271             << " MULTI_ACK_UPT_CLEAR> Clear UPT entry "
    1272             << r_multi_ack_upt_index.read()
    1273             << std::endl;
    1274         }
     1303if(m_debug)
     1304std::cout <<  "  <MEMC " << name()
     1305          << " MULTI_ACK_UPT_CLEAR> Clear UPT entry "
     1306          << std::dec << r_multi_ack_upt_index.read() << std::endl;
    12751307#endif
    12761308        break;
    1277       }
    1278 
     1309    }
    12791310    /////////////////////////
    1280     case MULTI_ACK_WRITE_RSP:
    1281       {
    1282         // Post a request to TGT_RSP FSM
    1283         // Wait if pending request to the TGT_RSP FSM
    1284         if(r_multi_ack_to_tgt_rsp_req.read()) break;
     1311    case MULTI_ACK_WRITE_RSP:     // Post a response request to TGT_RSP FSM
     1312                                  // Wait if pending request
     1313    {
     1314        if ( r_multi_ack_to_tgt_rsp_req.read() ) break;
    12851315
    12861316        r_multi_ack_to_tgt_rsp_req   = true;
    … …  
    12911321
    12921322#if DEBUG_MEMC_MULTI_ACK
    1293         if(m_debug_multi_ack_fsm)
    1294         {
    1295           std::cout
    1296             << "  <MEMC " << name()
    1297             << " MULTI_ACK_WRITE_RSP> Request TGT_RSP FSM to send a response to srcid "
    1298             << r_multi_ack_srcid.read()
    1299             << std::endl;
    1300         }
     1323if(m_debug)
     1324std::cout << "  <MEMC " << name() << " MULTI_ACK_WRITE_RSP>"
     1325          << " Request TGT_RSP FSM to send a response to srcid "
     1326          << std::hex << r_multi_ack_srcid.read() << std::endl;
    13011327#endif
    13021328        break;
    1303       }
     1329    }
     1330    //////////////////////////
     1331    case MULTI_ACK_CONFIG_ACK:    // Signals multi-inval completion to CONFIG FSM
     1332                                  // Wait if pending request
     1333    {
     1334        if ( r_multi_ack_to_config_ack.read() ) break;
     1335
     1336        r_multi_ack_to_config_ack   = true;
     1337        r_multi_ack_fsm              = MULTI_ACK_IDLE;
     1338
     1339#if DEBUG_MEMC_MULTI_ACK
     1340if(m_debug)
     1341std::cout << "  <MEMC " << name() << " MULTI_ACK_CONFIG_ACK>"
     1342          << " Signals inval completion to CONFIG FSM" << std::endl;
     1343#endif
     1344        break;
     1345    }
    13041346  } // end switch r_multi_ack_fsm
     1347
     1348  ////////////////////////////////////////////////////////////////////////////////////
     1349  //    CONFIG FSM
     1350  ////////////////////////////////////////////////////////////////////////////////////
     1351  // The CONFIG FSM handles the VCI configuration requests (INVAL & SYNC).
     1352  // The target buffer can have any size, and there is one single command for
     1353  // all cache lines covered by the target buffer.
     1354  // An INVAL or SYNC configuration request is defined by the followinf registers:
     1355  // - bool      r_config_cmd        : INVAL / SYNC / NOP)
     1356  // - uint64_t  r_config_address    : buffer base address
     1357  // - uint32_t  r_config_nlines     : number of lines covering buffer
     1358  //
     1359  // For both INVAL and SYNC commands, the CONFIG FSM contains the loop handling
     1360  // all cache lines covered by the target buffer.
     1361  //
     1362  // - INVAL request:
     1363  //   For each line, it access to the DIR array.
     1364  //   In case of miss, it does nothing, and a response is requested to TGT_RSP FSM.
     1365  //   In case of hit, with no copies in L1 caches, the line is invalidated and
     1366  //   a response is requested to TGT_RSP FSM.
     1367  //   If there is copies, a multi-inval, or a broadcast-inval coherence transaction
     1368  //   is launched and registered in UPT. The multi-inval transaction is signaled
     1369  //   by the r_multi_ack_to config_ack or r_cleanup_to_config_ack flip-flops.
     1370  //   The config inval response is sent only when the last line has been invalidated.
     1371  //
     1372  // - SYNC request: Not implemented yet
     1373  //
     1374  // From the software point of view, a configuration request is a sequence
     1375  // of 6 atomic accesses:
     1376  // - Read  MEMC_LOCK       : Get the lock
     1377  // - Write MEMC_ADDR_LO    : Set the buffer address LSB
     1378  // - Write MEMC_ADDR_HI    : Set the buffer address MSB
     1379  // - Write MEMC_BUF_LENGTH : set buffer length (bytes)
     1380  // - Write MEMC_CMD_TYPE   : launch the actual operation
     1381  // - WRITE MEMC_LOCK       : release the lock
     1382  ////////////////////////////////////////////////////////////////////////////////////
     1383
     1384  switch( r_config_fsm.read() )
     1385  {
     1386      /////////////////
     1387      case CONFIG_IDLE:  // waiting a config request
     1388      {
     1389          if ( r_config_cmd.read() != MEMC_CMD_NOP ) 
     1390          {
     1391              r_config_fsm    = CONFIG_LOOP;
     1392          }
     1393
     1394#if DEBUG_MEMC_CONFIG
     1395if(m_debug)
     1396std::cout << "  <MEMC " << name() << " CONFIG_IDLE> Config Request received"
     1397          << " address = " << std::hex << r_config_address.read()
     1398          << " / nlines = " << std::dec << r_config_nlines.read()
     1399          << " / type = " << r_config_cmd.read() << std::endl;
     1400#endif
     1401          break;
     1402      }
     1403      /////////////////
     1404      case CONFIG_LOOP:   // test last line
     1405      {
     1406          if ( r_config_nlines.read() == 0 )
     1407          {
     1408              r_config_cmd = MEMC_CMD_NOP;
     1409              r_config_fsm = CONFIG_RSP;
     1410          }
     1411          else
     1412          {
     1413              r_config_fsm = CONFIG_DIR_REQ;
     1414          }
     1415
     1416#if DEBUG_MEMC_CONFIG
     1417if(m_debug)
     1418std::cout << "  <MEMC " << name() << " CONFIG_SYNC_LOOP>"
     1419          << " address = " << std::hex << r_config_address.read()   
     1420          << " / nlines = " << std::dec << r_config_nlines.read()
     1421          << " / type = " << r_config_cmd.read() << std::endl;
     1422#endif
     1423          break;
     1424      }
     1425      ////////////////////
     1426      case CONFIG_DIR_REQ:  // Request directory lock
     1427      {
     1428          if ( r_alloc_dir_fsm.read() == ALLOC_DIR_CONFIG )
     1429          {
     1430              r_config_fsm = CONFIG_DIR_ACCESS;
     1431          }
     1432
     1433#if DEBUG_MEMC_CONFIG
     1434if(m_debug)
     1435std::cout << "  <MEMC " << name() << " CONFIG_INVAL_DIR_REQ>"
     1436          << " Request DIR access" << std::endl;
     1437#endif
     1438          break;
     1439      }
     1440      ///////////////////////
     1441      case CONFIG_DIR_ACCESS:   // Access directory and decode cmd
     1442      {
     1443          size_t way = 0;
     1444          DirectoryEntry entry = m_cache_directory.read(r_config_address.read(), way);
     1445
     1446          if ( entry.valid and                            // hit & inval command
     1447               (r_config_cmd.read() == MEMC_CMD_INVAL) )
     1448          {
     1449              r_config_way    = way;
     1450              r_config_is_cnt = entry.is_cnt;
     1451              r_config_count  = entry.count;
     1452              r_config_fsm    = CONFIG_DIR_INVAL;
     1453          }
     1454          else if ( entry.valid and                       // hit & sync command
     1455                    entry.dirty and
     1456                    (r_config_cmd.read() == MEMC_CMD_SYNC) )
     1457          {
     1458              std::cout << "VCI_MEM_CACHE ERROR: "
     1459                        << "SYNC config request not implemented yet" << std::endl;
     1460              exit(0);
     1461          }
     1462          else                                            // nothing to do : return to LOOP
     1463          {
     1464              r_config_nlines  = r_config_nlines.read() - 1;
     1465              r_config_address = r_config_address.read() + (m_words*vci_param_int::B);
     1466              r_config_fsm     = CONFIG_LOOP;
     1467          }
     1468
     1469#if DEBUG_MEMC_CONFIG
     1470if(m_debug)
     1471std::cout << "  <MEMC " << name() << " CONFIG_DIR_ACCESS> Accessing directory: "
     1472          << " address = " << std::hex << m_cmd_read_addr_fifo.read()
     1473          << " / hit = " << std::dec << entry.valid
     1474          << " / dirty = " <<std::dec << entry.dirty
     1475          << " / count = " <<std::dec << entry.count
     1476          << " / is_cnt = " << entry.is_cnt << std::endl;
     1477#endif
     1478          break;
     1479      }
     1480      //////////////////////
     1481      case CONFIG_DIR_INVAL:  // Invalidate the directory entry
     1482      {
     1483          size_t set        = m_y[(addr_t)(r_config_address.read())];
     1484          size_t way        = r_config_way.read();
     1485
     1486          m_cache_directory.inval( way, set );
     1487
     1488          if ( r_config_count.read() == 0 )     // return to LOOP
     1489          {
     1490              r_config_nlines  = r_config_nlines.read() - 1;
     1491              r_config_address = r_config_address.read() + (m_words*vci_param_int::B);
     1492              r_config_fsm     = CONFIG_LOOP;
     1493          }
     1494          else if ( r_config_is_cnt.read() )    // broacast required
     1495          {
     1496              r_config_fsm = CONFIG_BC_UPT_LOCK;
     1497          }
     1498          else
     1499          {
     1500              r_config_fsm = CONFIG_UPT_LOCK;
     1501          }
     1502
     1503#if DEBUG_MEMC_CONFIG
     1504if(m_debug)
     1505std::cout << "  <MEMC " << name() << " CONFIG_DIR_INVAL> Inval directory entry" << std::endl;
     1506#endif
     1507          break;
     1508      }
     1509      ////////////////////////
     1510      case CONFIG_BC_UPT_LOCK:  // try to register BC transaction in UPT
     1511      {
     1512          if ( r_alloc_upt_fsm.read() == ALLOC_UPT_CONFIG )
     1513          {
     1514              bool        wok       = false;
     1515              size_t      index     = 0;
     1516              size_t      srcid     = r_config_srcid.read();
     1517              size_t      trdid     = r_config_trdid.read();
     1518              size_t      pktid     = r_config_pktid.read();
     1519              addr_t      nline     = m_nline[(addr_t)(r_config_address.read())];
     1520              size_t      nb_copies = r_config_count.read();
     1521
     1522              wok = m_upt.set(false,    // it's an inval transaction
     1523                              true,     // it's a broadcast
     1524                              false,    // no response required
     1525                              true,     // acknowledge required
     1526                              srcid,
     1527                              trdid,
     1528                              pktid,
     1529                              nline,
     1530                              nb_copies,
     1531                              index);
     1532              if ( wok )
     1533              {
     1534                  r_config_fsm       = CONFIG_BC_SEND;
     1535                  r_config_upt_index = index;
     1536
     1537#if DEBUG_MEMC_CONFIG
     1538if( m_debug )
     1539std::cout << "  <MEMC " << name()
     1540          << " CONFIG_BC_UPT_LOCK> Register broadcast inval in UPT" << std::endl;
     1541#endif
     1542              }
     1543              else
     1544              {
     1545                  r_config_fsm       = CONFIG_UPT_WAIT;
     1546         
     1547#if DEBUG_MEMC_CONFIG
     1548if( m_debug )
     1549std::cout << "  <MEMC " << name() << " CONFIG_BC_UPT_LOCK>"
     1550          << " UPT full" << std::endl;
     1551#endif
     1552              }
     1553          }
     1554          break;
     1555      }
     1556      ////////////////////
     1557      case CONFIG_BC_SEND:    // Post a broadcast inval request to CC_SEND FSM
     1558      {
     1559          if( not r_config_to_cc_send_multi_req.read() and
     1560              not r_config_to_cc_send_brdcast_req.read() )
     1561          {
     1562              r_config_to_cc_send_multi_req   = false;
     1563              r_config_to_cc_send_brdcast_req = true;
     1564              r_config_to_cc_send_trdid       = r_config_upt_index.read();
     1565              r_config_to_cc_send_nline       = m_nline[(addr_t)(r_config_address.read())];
     1566
     1567              r_cleanup_to_config_ack         = false;
     1568
     1569              r_config_fsm                    = CONFIG_BC_WAIT;
     1570
     1571#if DEBUG_MEMC_CONFIG
     1572if(m_debug)
     1573std::cout << "  <MEMC " << name() << " CONFIG_BC_SEND>"
     1574          << " Post a broadcast inval request to CC_SEND FSM"
     1575          << " / address = " << r_config_address.read() <<std::endl;
     1576#endif
     1577          }
     1578          break;
     1579      }
     1580      ////////////////////
     1581      case CONFIG_BC_WAIT:      // wait broadcast completion to return to LOOP
     1582      {
     1583          if ( r_cleanup_to_config_ack.read() ) r_config_fsm = CONFIG_LOOP;
     1584
     1585#if DEBUG_MEMC_CONFIG
     1586if(m_debug)
     1587std::cout << "  <MEMC " << name() << " CONFIG_BC_WAIT>"
     1588          << " Waiting broadcast inval completion" << std::endl;
     1589#endif
     1590          break;
     1591      }
     1592      /////////////////////
     1593      case CONFIG_UPT_LOCK:  // Try to register multi-update in UPT
     1594      {
     1595          if ( r_alloc_upt_fsm.read() == ALLOC_UPT_CONFIG )
     1596          {
     1597              bool        wok       = false;
     1598              size_t      index     = 0;
     1599              size_t      srcid     = r_config_srcid.read();
     1600              size_t      trdid     = r_config_trdid.read();
     1601              size_t      pktid     = r_config_pktid.read();
     1602              addr_t      nline     = m_nline[(addr_t)(r_config_address.read())];
     1603              size_t      nb_copies = r_config_count.read();
     1604
     1605              wok = m_upt.set(false,    // it's an inval transaction
     1606                              false,    // not a broadcast
     1607                              false,    // no response required
     1608                              true,     // acknowledge required
     1609                              srcid,
     1610                              trdid,
     1611                              pktid,
     1612                              nline,
     1613                              nb_copies,
     1614                              index);
     1615              if ( wok )
     1616              {
     1617                  r_config_fsm       = CONFIG_BC_SEND;
     1618                  r_config_upt_index = index;
     1619
     1620#if DEBUG_MEMC_CONFIG
     1621if( m_debug )
     1622std::cout << "  <MEMC " << name()
     1623          << " CONFIG_BC_UPT_LOCK> Register broadcast inval in UPT" << std::endl;
     1624#endif
     1625              }
     1626              else
     1627              {
     1628                  r_config_fsm       = CONFIG_UPT_WAIT;
     1629         
     1630#if DEBUG_MEMC_CONFIG
     1631if( m_debug )
     1632std::cout << "  <MEMC " << name() << " CONFIG_BC_UPT_LOCK>"
     1633          << " UPT full" << std::endl;
     1634#endif
     1635              }
     1636
     1637#if DEBUG_MEMC_CONFIG
     1638if(m_debug)
     1639std::cout << "  <MEMC " << name() << " CONFIG_UPT_LOCK> Request access to UPT" << std::endl;
     1640#endif
     1641          }
     1642          break;
     1643      }
     1644      /////////////////////
     1645      case CONFIG_HEAP_REQ:  // request access to the heap
     1646      {
     1647          break;
     1648      }
     1649
     1650      ////////////////
     1651      case CONFIG_RSP:  // request TGT_RSP FSM to return response
     1652      {
     1653          if ( not r_config_to_tgt_rsp_req )
     1654          {
     1655              r_config_to_tgt_rsp_srcid  = r_config_srcid.read();
     1656              r_config_to_tgt_rsp_trdid  = r_config_trdid.read();
     1657              r_config_to_tgt_rsp_pktid  = r_config_pktid.read();
     1658              r_config_to_tgt_rsp_error  = false;
     1659              r_config_to_tgt_rsp_req    = true;
     1660              r_config_fsm               = CONFIG_IDLE;
     1661
     1662#if DEBUG_MEMC_CONFIG
     1663if(m_debug)
     1664std::cout << "  <MEMC " << name() << " CONFIG_RSP> Request TGT_RSP FSM to return response:"
     1665          << " error = " << r_config_to_tgt_rsp_error.read()
     1666          << " / rsrcid = " << std::hex << m_cmd_read_srcid_fifo.read() << std::endl;
     1667#endif
     1668          }
     1669          break;
     1670
     1671      }
     1672      /////////////////////
     1673      case CONFIG_UPT_WAIT:    // release the lock on UPT for one cycle, and retry
     1674      {
     1675          if ( r_config_is_cnt.read() ) r_config_fsm = CONFIG_BC_UPT_LOCK;
     1676          else                          r_config_fsm = CONFIG_UPT_LOCK;
     1677
     1678#if DEBUG_MEMC_CONFIG
     1679if(m_debug)
     1680std::cout << "  <MEMC " << name() << " CONFIG_UPT_WAIT>"
     1681          << " Release UPT lock" << std::endl;
     1682#endif
     1683          break;
     1684      }
     1685  }  // end switch r_config_fsm
    13051686
    13061687  ////////////////////////////////////////////////////////////////////////////////////
    … …  
    13291710  switch(r_read_fsm.read())
    13301711  {
    1331     ///////////////
    1332     case READ_IDLE:
    1333       // waiting a read request
    1334     {
     1712      ///////////////
     1713      case READ_IDLE:  // waiting a read request
     1714      {
    13351715      if(m_cmd_read_addr_fifo.rok())
    13361716      {
    13371717
    13381718#if DEBUG_MEMC_READ
    1339 if(m_debug_read_fsm)
     1719if(m_debug)
    13401720std::cout << "  <MEMC " << name() << " READ_IDLE> Read request"
    13411721          << " : address = " << std::hex << m_cmd_read_addr_fifo.read()
    … …  
    13501730    }
    13511731
     1732    //////////////////
     1733    case READ_DIR_REQ:  // Get the lock to the directory
     1734    {
     1735      if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
     1736      {
     1737        r_read_fsm = READ_DIR_LOCK;
     1738      }
     1739
     1740#if DEBUG_MEMC_READ
     1741if(m_debug)
     1742std::cout << "  <MEMC " << name() << " READ_DIR_REQ> Requesting DIR lock " << std::endl;
     1743#endif
     1744      break;
     1745    }
     1746
    13521747    ///////////////////
    1353     case READ_DIR_REQ:
    1354       // Get the lock to the directory
    1355     {
    1356       if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    1357       {
    1358         r_read_fsm = READ_DIR_LOCK;
    1359       }
    1360 
    1361 #if DEBUG_MEMC_READ
    1362 if(m_debug_read_fsm)
    1363 std::cout << "  <MEMC " << name() << " READ_DIR_REQ> Requesting DIR lock " << std::endl;
    1364 #endif
    1365       break;
    1366     }
    1367 
    1368     ///////////////////
    1369     case READ_DIR_LOCK:
    1370       // check directory for hit / miss
     1748    case READ_DIR_LOCK:  // check directory for hit / miss
    13711749    {
    13721750      if(r_alloc_dir_fsm.read() == ALLOC_DIR_READ)
    … …  
    14001778        {
    14011779          // test if we need to register a new copy in the heap
    1402           if(entry.is_cnt || (entry.count == 0) || !cached_read)
     1780          if(entry.is_cnt or (entry.count == 0) or !cached_read)
    14031781          {
    14041782            r_read_fsm = READ_DIR_HIT;
    … …  
    14151793
    14161794#if DEBUG_MEMC_READ
    1417 if(m_debug_read_fsm)
     1795if(m_debug)
    14181796{
    14191797std::cout << "  <MEMC " << name() << " READ_DIR_LOCK> Accessing directory: "
    … …  
    15031881
    15041882#if DEBUG_MEMC_READ
    1505 if(m_debug_read_fsm)
     1883if(m_debug)
    15061884std::cout << "  <MEMC " << name() << " READ_DIR_HIT> Update directory entry:"
    15071885          << " addr = " << std::hex << m_cmd_read_addr_fifo.read()
    … …  
    15391917
    15401918#if DEBUG_MEMC_READ
    1541 if(m_debug_read_fsm)
     1919if(m_debug)
    15421920std::cout << "  <MEMC " << name() << " READ_HEAP_REQ>"
    15431921          << " Requesting HEAP lock " << std::endl;
    … …  
    15531931      {
    15541932        // enter counter mode when we reach the limit of copies or the heap is full
    1555         bool go_cnt = (r_read_count.read() >= m_max_copies) || m_heap.is_full();
     1933        bool go_cnt = (r_read_count.read() >= m_max_copies) or m_heap.is_full();
    15561934
    15571935        // read data in the cache
    … …  
    16262004
    16272005#if DEBUG_MEMC_READ
    1628 if(m_debug_read_fsm)
     2006if(m_debug)
    16292007std::cout << "  <MEMC " << name() << " READ_HEAP_LOCK> Update directory:"
    16302008          << " tag = " << std::hex << entry.tag
    … …  
    16702048
    16712049#if DEBUG_MEMC_READ
    1672 if(m_debug_read_fsm)
     2050if(m_debug)
    16732051std::cout << "  <MEMC " << name() << " READ_HEAP_WRITE> Add an entry in the heap:"
    16742052          << " owner_id = " << std::hex << heap_entry.owner.srcid
    … …  
    17582136
    17592137#if DEBUG_MEMC_READ
    1760 if(m_debug_read_fsm)
     2138if(m_debug)
    17612139std::cout << "  <MEMC " << name() << " READ_RSP> Request TGT_RSP FSM to return data:"
    17622140          << " rsrcid = " << std::hex << m_cmd_read_srcid_fifo.read()
    … …  
    17782156        bool        wok       = !m_trt.full(index);
    17792157
    1780         if(hit_read || !wok || hit_write)    // missing line already requested or no space
     2158        if(hit_read or !wok or hit_write)    // missing line already requested or no space
    17812159        {
    17822160          if(!wok)      m_cpt_trt_full++;
    1783           if(hit_read || hit_write)   m_cpt_trt_rb++;
     2161          if(hit_read or hit_write)   m_cpt_trt_rb++;
    17842162          r_read_fsm = READ_IDLE;
    17852163        }
    … …  
    17922170
    17932171#if DEBUG_MEMC_READ
    1794 if(m_debug_read_fsm)
     2172if(m_debug)
    17952173std::cout << "  <MEMC " << name() << " READ_TRT_LOCK> Check TRT:"
    17962174          << " hit_read = " << hit_read
    … …  
    18202198                              r_read_ll_key.read());
    18212199#if DEBUG_MEMC_READ
    1822 if(m_debug_read_fsm)
     2200if(m_debug)
    18232201std::cout << "  <MEMC " << name() << " READ_TRT_SET> Write in Transaction Table:"
    18242202          << " address = " << std::hex << m_cmd_read_addr_fifo.read()
    1825           << " / srcid = " << std::dec << m_cmd_read_srcid_fifo.read() << std::endl;
     2203          << " / srcid = " << std::hex << m_cmd_read_srcid_fifo.read() << std::endl;
    18262204#endif
    18272205        r_read_fsm = READ_TRT_REQ;
    … …  
    18422220
    18432221#if DEBUG_MEMC_READ
    1844 if(m_debug_read_fsm)
     2222if(m_debug)
    18452223std::cout << "  <MEMC " << name() << " READ_TRT_REQ> Request GET transaction for address "
    18462224          << std::hex << m_cmd_read_addr_fifo.read() << std::endl;
    … …  
    18842262  switch(r_write_fsm.read())
    18852263  {
    1886       ////////////////
     2264    ////////////////
    18872265    case WRITE_IDLE:  // copy first word of a write burst in local buffer
    18882266    {
    … …  
    19172295        }
    19182296
    1919         if (m_cmd_write_eop_fifo.read() || ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC))
     2297        if (m_cmd_write_eop_fifo.read() or ((m_cmd_write_pktid_fifo.read() & 0x7) == TYPE_SC))
    19202298        {
    19212299          r_write_fsm = WRITE_DIR_REQ;
    … …  
    19272305
    19282306#if DEBUG_MEMC_WRITE
    1929         if(m_debug_write_fsm)
     2307        if(m_debug)
    19302308        {
    19312309          std::cout << "  <MEMC " << name() << " WRITE_IDLE> Write request "
    … …  
    19462324
    19472325#if DEBUG_MEMC_WRITE
    1948         if(m_debug_write_fsm)
     2326        if(m_debug)
    19492327        {
    19502328          std::cout << "  <MEMC " << name()
    … …  
    19992377          if(not m_cmd_write_addr_fifo.rok()) break;
    20002378
    2001           assert(m_cmd_write_eop_fifo.read() &&
     2379          assert(m_cmd_write_eop_fifo.read() and
    20022380                 "Error in VCI_MEM_CACHE : "
    20032381                 "invalid packet format for SC command");
    … …  
    20302408
    20312409#if DEBUG_MEMC_WRITE
    2032       if(m_debug_write_fsm)
     2410      if(m_debug)
    20332411      {
    20342412        std::cout
    … …  
    20652443          r_write_way        = way;
    20662444
    2067           if(entry.is_cnt && entry.count)
     2445          if(entry.is_cnt and entry.count)
    20682446          {
    20692447            r_write_fsm = WRITE_DIR_READ;
    … …  
    20802458
    20812459#if DEBUG_MEMC_WRITE
    2082         if(m_debug_write_fsm)
     2460        if(m_debug)
    20832461        {
    20842462          std::cout << "  <MEMC " << name() << " WRITE_DIR_LOCK> Check the directory: "
    … …  
    21302508
    21312509#if DEBUG_MEMC_WRITE
    2132       if(m_debug_write_fsm)
     2510      if(m_debug)
    21332511      {
    21342512        std::cout << "  <MEMC " << name() << " WRITE_DIR_READ> Read the cache to complete local buffer" << std::endl;
    … …  
    21722550      // no_update is true when there is no need for coherence transaction
    21732551      // (tests for sc requests)
    2174       bool no_update = ((r_write_count.read() ==0) || (owner && (r_write_count.read() ==1) && (r_write_pktid.read() != TYPE_SC)));
     2552      bool no_update = ( (r_write_count.read() == 0) or
     2553                         (owner and (r_write_count.read() ==1) and (r_write_pktid.read() != TYPE_SC)));
    21752554
    21762555      // write data in the cache if no coherence transaction
    … …  
    22052584      // coherence update required
    22062585      {
    2207         if(!r_write_to_cc_send_multi_req.read() &&
     2586        if(!r_write_to_cc_send_multi_req.read() and
    22082587           !r_write_to_cc_send_brdcast_req.read())
    22092588        {
    … …  
    22172596
    22182597#if DEBUG_MEMC_WRITE
    2219       if(m_debug_write_fsm)
    2220       {
    2221         if(no_update)
    2222         {
    2223           std::cout << "  <MEMC " << name() << " WRITE_DIR_HIT> Write into cache / No coherence transaction"
    2224                     << std::endl;
    2225         }
    2226         else
    2227         {
    2228           std::cout << "  <MEMC " << name() << " WRITE_DIR_HIT> Coherence update required:"
    2229                     << " is_cnt = " << r_write_is_cnt.read()
    2230                     << " nb_copies = " << std::dec << r_write_count.read() << std::endl;
    2231           if(owner)
    2232             std::cout << "       ... but the first copy is the writer" << std::endl;
    2233         }
    2234       }
     2598if(m_debug)
     2599{
     2600    if(no_update)
     2601    {
     2602        std::cout << "  <MEMC " << name()
     2603                  << " WRITE_DIR_HIT> Write into cache / No coherence transaction"
     2604                  << std::endl;
     2605    }
     2606    else
     2607    {
     2608        std::cout << "  <MEMC " << name() << " WRITE_DIR_HIT> Coherence update required:"
     2609                  << " is_cnt = " << r_write_is_cnt.read()
     2610                  << " nb_copies = " << std::dec << r_write_count.read() << std::endl;
     2611        if(owner) std::cout << "       ... but the first copy is the writer" << std::endl;
     2612    }
     2613}
    22352614#endif
    22362615      break;
    … …  
    22532632
    22542633        wok = m_upt.set(true,  // it's an update transaction
    2255                                false,    // it's not a broadcast
    2256                                true,     // it needs a response
    2257                                srcid,
    2258                                trdid,
    2259                                pktid,
    2260                                nline,
    2261                                nb_copies,
    2262                                index);
     2634                        false,    // it's not a broadcast
     2635                        true,     // response required
     2636                        false,    // no acknowledge required
     2637                        srcid,   
     2638                        trdid,
     2639                        pktid,
     2640                        nline,
     2641                        nb_copies,
     2642                        index);
    22632643        if(wok)       // write data in cache
    22642644        {
    … …  
    22822662
    22832663#if DEBUG_MEMC_WRITE
    2284         if(m_debug_write_fsm)
    2285         {
    2286           if(wok)
    2287           {
    2288             std::cout << "  <MEMC " << name() << " WRITE_UPT_LOCK> Register the multicast update in UPT / "
    2289                       << " nb_copies = " << r_write_count.read() << std::endl;
    2290           }
    2291         }
     2664if(m_debug)
     2665{
     2666    if(wok)
     2667    {
     2668        std::cout << "  <MEMC " << name()
     2669                  << " WRITE_UPT_LOCK> Register the multicast update in UPT / "
     2670                  << " nb_copies = " << r_write_count.read() << std::endl;
     2671    }
     2672}
    22922673#endif
    22932674        r_write_upt_index = index;
    … …  
    23062687
    23072688#if DEBUG_MEMC_WRITE
    2308         if(m_debug_write_fsm)
    2309         {
    2310           std::cout << "  <MEMC " << name() << " WRITE_UPT_HEAP_LOCK> Get acces to the HEAP" << std::endl;
    2311         }
     2689if(m_debug)
     2690std::cout << "  <MEMC " << name()
     2691          << " WRITE_UPT_HEAP_LOCK> Get acces to the HEAP" << std::endl;
    23122692#endif
    23132693        r_write_fsm = WRITE_UPT_REQ;
    … …  
    23172697
    23182698    //////////////////
    2319     case WRITE_UPT_REQ:
    2320     {
    2321       // prepare the coherence transaction for the CC_SEND FSM
    2322       // and write the first copy in the FIFO
    2323       // send the request if only one copy
    2324 
     2699    case WRITE_UPT_REQ:    // prepare the coherence transaction for the CC_SEND FSM
     2700                           // and write the first copy in the FIFO
     2701                           // send the request if only one copy
     2702    {
    23252703      assert(not r_write_to_cc_send_multi_req.read()   and
    23262704             not r_write_to_cc_send_brdcast_req.read() and
    … …  
    23732751
    23742752#if DEBUG_MEMC_WRITE
    2375       if(m_debug_write_fsm)
     2753      if(m_debug)
    23762754      {
    23772755        std::cout
    … …  
    24042782      bool dec_upt_counter;
    24052783
    2406       if(((entry.owner.srcid != r_write_srcid.read()) || (r_write_pktid.read() == TYPE_SC)) or
     2784      if(((entry.owner.srcid != r_write_srcid.read()) or (r_write_pktid.read() == TYPE_SC)) or
    24072785#if L1_MULTI_CACHE
    24082786          (entry.owner.cache_id != r_write_pktid.read()) or
    … …  
    24192797
    24202798#if DEBUG_MEMC_WRITE
    2421         if(m_debug_write_fsm)
     2799        if(m_debug)
    24222800        {
    24232801          std::cout << "  <MEMC " << name() << " WRITE_UPT_NEXT> Post another request to CC_SEND FSM"
    … …  
    24352813
    24362814#if DEBUG_MEMC_WRITE
    2437         if(m_debug_write_fsm)
     2815        if(m_debug)
    24382816        {
    24392817          std::cout << "  <MEMC " << name() << " WRITE_UPT_NEXT> Skip one entry in heap matching the writer"
    … …  
    25332911          }
    25342912
    2535           if(m_cmd_write_eop_fifo.read() || ((m_cmd_write_pktid_fifo.read() & 0x7)  == TYPE_SC))
     2913          if(m_cmd_write_eop_fifo.read() or ((m_cmd_write_pktid_fifo.read() & 0x7)  == TYPE_SC))
    25362914          {
    25372915            r_write_fsm = WRITE_DIR_REQ;
    … …  
    25482926
    25492927#if DEBUG_MEMC_WRITE
    2550 if(m_debug_write_fsm)
     2928if(m_debug)
    25512929{
    25522930    std::cout << "  <MEMC " << name() << " WRITE_RSP> Post a request to TGT_RSP FSM"
    … …  
    25722950
    25732951#if DEBUG_MEMC_WRITE
    2574 if(m_debug_write_fsm)
     2952if(m_debug)
    25752953std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_LOCK> Check the TRT" << std::endl;
    25762954#endif
    … …  
    25882966          m_cpt_write_miss++;
    25892967        }
    2590         else if(wok && !hit_write)      // set a new entry in TRT
     2968        else if(wok and !hit_write)      // set a new entry in TRT
    25912969        {
    25922970          r_write_trt_index = wok_index;
    … …  
    26082986
    26092987#if DEBUG_MEMC_WRITE
    2610 if(m_debug_write_fsm)
     2988if(m_debug)
    26112989std::cout << "  <MEMC " << name() << " WRITE_WAIT> Releases the locks before retry" << std::endl;
    26122990#endif
    … …  
    26433021
    26443022#if DEBUG_MEMC_WRITE
    2645 if(m_debug_write_fsm)
     3023if(m_debug)
    26463024std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_SET> Set a new entry in TRT" << std::endl;
    26473025#endif
    … …  
    26703048
    26713049#if DEBUG_MEMC_WRITE
    2672 if(m_debug_write_fsm)
     3050if(m_debug)
    26733051std::cout << "  <MEMC " << name() << " WRITE_MISS_TRT_DATA> Modify an existing entry in TRT" << std::endl;
    26743052#endif
    … …  
    26893067
    26903068#if DEBUG_MEMC_WRITE
    2691 if(m_debug_write_fsm)
     3069if(m_debug)
    26923070std::cout << "  <MEMC " << name() << " WRITE_MISS_XRAM_REQ> Post a GET request to the IXR_CMD FSM" << std::endl;
    26933071#endif
    … …  
    27143092
    27153093#if DEBUG_MEMC_WRITE
    2716 if(m_debug_write_fsm)
     3094if(m_debug)
    27173095std::cout << "  <MEMC " << name() << " WRITE_BC_TRT_LOCK> Check TRT"
    27183096          << " : wok = " << wok << " / index = " << wok_index << std::endl;
    … …  
    27353113        size_t      nb_copies = r_write_count.read();
    27363114
    2737         wok =m_upt.set(false,  // it's an inval transaction
    2738                               true,     // it's a broadcast
    2739                               true,     // it needs a response
    2740                               srcid,
    2741                               trdid,
    2742                               pktid,
    2743                               nline,
    2744                               nb_copies,
    2745                               index);
     3115        wok = m_upt.set(false,  // it's an inval transaction
     3116                        true,     // it's a broadcast
     3117                        true,     // response required
     3118                        false,    // no acknowledge required
     3119                        srcid,
     3120                        trdid,
     3121                        pktid,
     3122                        nline,
     3123                        nb_copies,
     3124                        index);
    27463125
    27473126#if DEBUG_MEMC_WRITE
    2748 if( m_debug_write_fsm and wok )
     3127if( m_debug and wok )
    27493128std::cout << "  <MEMC " << name() << " WRITE_BC_UPT_LOCK> Register broadcast inval in UPT"
    27503129          << " / nb_copies = " << r_write_count.read() << std::endl;
    … …  
    27633142      // Register a put transaction to XRAM in TRT
    27643143      // and invalidate the line in directory
    2765       if((r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE) ||
    2766           (r_alloc_upt_fsm.read() != ALLOC_UPT_WRITE) ||
     3144      if((r_alloc_trt_fsm.read() != ALLOC_TRT_WRITE) or
     3145          (r_alloc_upt_fsm.read() != ALLOC_UPT_WRITE) or
    27673146          (r_alloc_dir_fsm.read() != ALLOC_DIR_WRITE))
    27683147      {
    … …  
    28053184
    28063185#if DEBUG_MEMC_WRITE
    2807 if(m_debug_write_fsm)
     3186if(m_debug)
    28083187std::cout << "  <MEMC " << name() << " WRITE_BC_DIR_INVAL> Invalidate the directory entry: @ = "
    28093188          << r_write_address.read() << " / register the put transaction in TRT:" << std::endl;
    … …  
    28163195    case WRITE_BC_CC_SEND:    // Post a coherence broadcast request to CC_SEND FSM
    28173196    {
    2818       if(!r_write_to_cc_send_multi_req.read() && !r_write_to_cc_send_brdcast_req.read())
     3197      if(!r_write_to_cc_send_multi_req.read() and !r_write_to_cc_send_brdcast_req.read())
    28193198      {
    28203199        r_write_to_cc_send_multi_req   = false;
    … …  
    28333212
    28343213#if DEBUG_MEMC_WRITE
    2835 if(m_debug_write_fsm)
    2836 {
    2837     std::cout << "  <MEMC " << name()
    2838               << " WRITE_BC_CC_SEND> Post a broadcast request to CC_SEND FSM" << std::endl;
    2839 }
     3214if(m_debug)
     3215std::cout << "  <MEMC " << name()
     3216          << " WRITE_BC_CC_SEND> Post a broadcast request to CC_SEND FSM" << std::endl;
    28403217#endif
    28413218      }
    … …  
    28583235
    28593236#if DEBUG_MEMC_WRITE
    2860 if(m_debug_write_fsm)
    2861 {
    2862      std::cout << "  <MEMC " << name()
    2863                << " WRITE_BC_XRAM_REQ> Post a put request to IXR_CMD FSM" << std::endl;
    2864 }
     3237if(m_debug)
     3238std::cout << "  <MEMC " << name()
     3239          << " WRITE_BC_XRAM_REQ> Post a put request to IXR_CMD FSM" << std::endl;
    28653240#endif
    28663241      }
    … …  
    29343309
    29353310#if DEBUG_MEMC_IXR_CMD
    2936 if(m_debug_ixr_cmd_fsm)
     3311if(m_debug)
    29373312std::cout << "  <MEMC " << name() << " IXR_CMD_READ>"
    29383313          << " Send a get request to xram / address = " << std::hex
    … …  
    29613336
    29623337#if DEBUG_MEMC_IXR_CMD
    2963 if(m_debug_ixr_cmd_fsm)
     3338if(m_debug)
    29643339std::cout << "  <MEMC " << name() << " IXR_CMD_WRITE>"
    29653340          << " Send a put request to xram / address = " << std::hex
    … …  
    29743349
    29753350#if DEBUG_MEMC_IXR_CMD
    2976 if(m_debug_ixr_cmd_fsm)
     3351if(m_debug)
    29773352std::cout << "  <MEMC " << name() << " IXR_CMD_WRITE>"
    29783353          << " Send a get request to xram / address = " << std::hex
    … …  
    30023377
    30033378#if DEBUG_MEMC_IXR_CMD
    3004 if(m_debug_ixr_cmd_fsm)
     3379if(m_debug)
    30053380std::cout << "  <MEMC " << name() << " IXR_CMD_CAS>"
    30063381          << " Send a put request to xram / address = " << std::hex
    … …  
    30153390
    30163391#if DEBUG_MEMC_IXR_CMD
    3017 if(m_debug_ixr_cmd_fsm)
     3392if(m_debug)
    30183393std::cout << "  <MEMC " << name() << " IXR_CMD_CAS>"
    30193394          << " Send a get request to xram / address = " << std::hex
    … …  
    30413416
    30423417#if DEBUG_MEMC_IXR_CMD
    3043 if(m_debug_ixr_cmd_fsm)
     3418if(m_debug)
    30443419std::cout << "  <MEMC " << name() << " IXR_CMD_XRAM>"
    30453420          << " Send a put request to xram / address = " << std::hex
    … …  
    30813456        r_ixr_rsp_cpt   = 0;
    30823457        r_ixr_rsp_trt_index = p_vci_ixr.rtrdid.read();
    3083         if(p_vci_ixr.reop.read() && !(p_vci_ixr.rerror.read() &0x1))   // PUT transaction
     3458        if(p_vci_ixr.reop.read() and !(p_vci_ixr.rerror.read() &0x1))   // PUT transaction
    30843459        {
    30853460          r_ixr_rsp_fsm = IXR_RSP_ACK;
    30863461
    30873462#if DEBUG_MEMC_IXR_RSP
    3088 if(m_debug_ixr_rsp_fsm)
    3089 {
    3090     std::cout << "  <MEMC " << name()
    3091               << " IXR_RSP_IDLE> Response from XRAM to a put transaction" << std::endl;
    3092 }
     3463if(m_debug)
     3464std::cout << "  <MEMC " << name()
     3465          << " IXR_RSP_IDLE> Response from XRAM to a put transaction" << std::endl;
    30933466#endif
    30943467        }
    … …  
    30983471
    30993472#if DEBUG_MEMC_IXR_RSP
    3100 if(m_debug_ixr_rsp_fsm)
    3101 {
    3102     std::cout << "  <MEMC " << name()
    3103               << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
    3104 }
     3473if(m_debug)
     3474std::cout << "  <MEMC " << name()
     3475          << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
    31053476#endif
    31063477        }
    … …  
    31143485
    31153486#if DEBUG_MEMC_IXR_RSP
    3116 if(m_debug_ixr_rsp_fsm)
    3117 {
    3118     std::cout << "  <MEMC " << name() << " IXR_RSP_ACK>" << std::endl;
    3119 }
     3487if(m_debug)
     3488std::cout << "  <MEMC " << name() << " IXR_RSP_ACK>" << std::endl;
    31203489#endif
    31213490      break;
    … …  
    31303499
    31313500#if DEBUG_MEMC_IXR_RSP
    3132 if(m_debug_ixr_rsp_fsm)
    3133 {
    3134           std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
    3135                     << r_ixr_rsp_trt_index.read() << std::endl;
    3136         }
     3501if(m_debug)
     3502std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
     3503          << r_ixr_rsp_trt_index.read() << std::endl;
    31373504#endif
    31383505      }
    … …  
    31423509    case IXR_RSP_TRT_READ:    // write a 64 bits data in the TRT
    31433510    {
    3144       if((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) &&  p_vci_ixr.rspval)
     3511      if((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
    31453512      {
    31463513        size_t      index    = r_ixr_rsp_trt_index.read();
    … …  
    31493516        bool        error    = ((p_vci_ixr.rerror.read() & 0x1) == 1);
    31503517
    3151         assert(((eop == (r_ixr_rsp_cpt.read() == (m_words-2))) || p_vci_ixr.rerror.read())
     3518        assert(((eop == (r_ixr_rsp_cpt.read() == (m_words-2))) or p_vci_ixr.rerror.read())
    31523519               and "Error in VCI_MEM_CACHE : invalid length for a response from XRAM");
    31533520
    … …  
    31663533
    31673534#if DEBUG_MEMC_IXR_RSP
    3168 if(m_debug_ixr_rsp_fsm)
    3169 {
    3170     std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing a word in TRT : "
    3171               << " index = " << std::dec << index
    3172               << " / word = " << r_ixr_rsp_cpt.read()
    3173               << " / data = " << std::hex << data << std::endl;
    3174 }
     3535if(m_debug)
     3536std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing a word in TRT : "
     3537          << " index = " << std::dec << index
     3538          << " / word = " << r_ixr_rsp_cpt.read()
     3539          << " / data = " << std::hex << data << std::endl;
    31753540#endif
    31763541      }
    … …  
    32193584
    32203585#if DEBUG_MEMC_XRAM_RSP
    3221 if(m_debug_xram_rsp_fsm)
     3586if(m_debug)
    32223587std::cout << "  <MEMC " << name() << " XRAM_RSP_IDLE>"
    32233588          << " Available cache line in TRT:"
    … …  
    32333598                            // Copy the TRT entry in a local buffer
    32343599    {
    3235       if((r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP) &&
     3600      if((r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP) and
    32363601          (r_alloc_trt_fsm.read() == ALLOC_TRT_XRAM_RSP))
    32373602      {
    … …  
    32423607        r_xram_rsp_fsm = XRAM_RSP_TRT_COPY;
    32433608
    3244 //        TransactionTabEntry trt_entry(m_trt.read(index));
    3245 //        r_xram_rsp_trt_buf.copy(trt_entry);           // TRT entry local buffer
    3246 
    32473609#if DEBUG_MEMC_XRAM_RSP
    3248 if(m_debug_xram_rsp_fsm)
     3610if(m_debug)
    32493611std::cout << "  <MEMC " << name() << " XRAM_RSP_DIR_LOCK>"
    32503612          << " Get access to DIR and TRT" << std::endl;
    … …  
    32663628        DirectoryEntry victim(m_cache_directory.select(set, way));
    32673629
    3268         bool inval = (victim.count && victim.valid) ;
     3630        bool inval = (victim.count and victim.valid) ;
    32693631
    32703632        // copy the victim line in a local buffer
    … …  
    32963658
    32973659#if DEBUG_MEMC_XRAM_RSP
    3298 if(m_debug_xram_rsp_fsm)
     3660if(m_debug)
    32993661std::cout << "  <MEMC " << name() << " XRAM_RSP_TRT_COPY>"
    33003662          << " Select a slot: "
    … …  
    33233685
    33243686#if DEBUG_MEMC_XRAM_RSP
    3325 if(m_debug_xram_rsp_fsm)
     3687if(m_debug)
    33263688std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    33273689          << " Get acces to UPT, but line invalidation registered"
    … …  
    33313693
    33323694        }
    3333         else if(m_upt.is_full() && r_xram_rsp_victim_inval.read()) // UPT full
     3695        else if(m_upt.is_full() and r_xram_rsp_victim_inval.read()) // UPT full
    33343696        {
    33353697          r_xram_rsp_fsm = XRAM_RSP_INVAL_WAIT;
    33363698
    33373699#if DEBUG_MEMC_XRAM_RSP
    3338 if(m_debug_xram_rsp_fsm)
     3700if(m_debug)
    33393701std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    33403702          << " Get acces to UPT, but inval required and UPT full" << std::endl;
    … …  
    33463708
    33473709#if DEBUG_MEMC_XRAM_RSP
    3348 if(m_debug_xram_rsp_fsm)
     3710if(m_debug)
    33493711std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_LOCK>"
    33503712          << " Get acces to UPT" << std::endl;
    … …  
    33593721
    33603722#if DEBUG_MEMC_XRAM_RSP
    3361 if(m_debug_xram_rsp_fsm)
     3723if(m_debug)
    33623724std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL_WAIT>"
    33633725          << " Release all locks and retry" << std::endl;
    … …  
    33733735      // TYPE_READ_INS_UNC   0bX010 with TSAR encoding
    33743736      // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    3375       bool inst_read = (r_xram_rsp_trt_buf.pktid & 0x2) && r_xram_rsp_trt_buf.proc_read;
     3737      bool inst_read = (r_xram_rsp_trt_buf.pktid & 0x2) and r_xram_rsp_trt_buf.proc_read;
    33763738
    33773739      // check if this is a cached read, this means pktid is either
    33783740      // TYPE_READ_DATA_MISS 0bX001 with TSAR encoding
    33793741      // TYPE_READ_INS_MISS  0bX011 with TSAR encoding
    3380       bool cached_read = (r_xram_rsp_trt_buf.pktid & 0x1) && r_xram_rsp_trt_buf.proc_read;
     3742      bool cached_read = (r_xram_rsp_trt_buf.pktid & 0x1) and r_xram_rsp_trt_buf.proc_read;
    33813743
    33823744      bool dirty = false;
    … …  
    33893751        m_cache_data.write(way, set, word, r_xram_rsp_trt_buf.wdata[word]);
    33903752
    3391         dirty = dirty || (r_xram_rsp_trt_buf.wdata_be[word] != 0);
     3753        dirty = dirty or (r_xram_rsp_trt_buf.wdata_be[word] != 0);
    33923754
    33933755        if(m_monitor_ok)
    … …  
    34353797        bool   wok = m_upt.set(false,      // it's an inval transaction
    34363798                               broadcast,  // set broadcast bit
    3437                                false,      // it does not need a response
     3799                               false,      // no response required
     3800                               false,      // no acknowledge required
    34383801                               0,          // srcid
    34393802                               0,          // trdid
    … …  
    34543817
    34553818#if DEBUG_MEMC_XRAM_RSP
    3456 if(m_debug_xram_rsp_fsm)
     3819if(m_debug)
    34573820{
    34583821std::cout << "  <MEMC " << name() << " XRAM_RSP_DIR_UPDT>"
    … …  
    35003863
    35013864#if DEBUG_MEMC_XRAM_RSP
    3502 if(m_debug_xram_rsp_fsm)
     3865if(m_debug)
    35033866std::cout << "  <MEMC " << name() << " XRAM_RSP_TRT_DIRTY>"
    35043867          << " Set TRT entry for the put transaction"
    … …  
    35343897
    35353898#if DEBUG_MEMC_XRAM_RSP
    3536 if(m_debug_xram_rsp_fsm)
     3899if(m_debug)
    35373900std::cout << "  <MEMC " << name() << " XRAM_RSP_DIR_RSP>"
    35383901          << " Request the TGT_RSP FSM to return data:"
    … …  
    35473910    case XRAM_RSP_INVAL:  // send invalidate request to CC_SEND FSM
    35483911    {
    3549       if(!r_xram_rsp_to_cc_send_multi_req.read() &&
     3912      if(!r_xram_rsp_to_cc_send_multi_req.read() and
    35503913          !r_xram_rsp_to_cc_send_brdcast_req.read())
    35513914      {
    35523915        bool multi_req = !r_xram_rsp_victim_is_cnt.read();
    3553         bool last_multi_req  = multi_req && (r_xram_rsp_victim_count.read() == 1);
    3554         bool not_last_multi_req = multi_req && (r_xram_rsp_victim_count.read() != 1);
     3916        bool last_multi_req  = multi_req and (r_xram_rsp_victim_count.read() == 1);
     3917        bool not_last_multi_req = multi_req and (r_xram_rsp_victim_count.read() != 1);
    35553918
    35563919        r_xram_rsp_to_cc_send_multi_req    = last_multi_req;
    … …  
    35713934
    35723935#if DEBUG_MEMC_XRAM_RSP
    3573 if(m_debug_xram_rsp_fsm)
     3936if(m_debug)
    35743937std::cout << "  <MEMC " << name() << " XRAM_RSP_INVAL>"
    35753938          << " Send an inval request to CC_SEND FSM"
    … …  
    35933956        m_cpt_write_dirty++;
    35943957
    3595         bool multi_req = !r_xram_rsp_victim_is_cnt.read() && r_xram_rsp_victim_inval.read();
    3596         bool not_last_multi_req = multi_req && (r_xram_rsp_victim_count.read() != 1);
     3958        bool multi_req = !r_xram_rsp_victim_is_cnt.read() and r_xram_rsp_victim_inval.read();
     3959        bool not_last_multi_req = multi_req and (r_xram_rsp_victim_count.read() != 1);
    35973960
    35983961        if(not_last_multi_req)   r_xram_rsp_fsm = XRAM_RSP_HEAP_REQ;
    … …  
    36003963
    36013964#if DEBUG_MEMC_XRAM_RSP
    3602 if(m_debug_xram_rsp_fsm)
     3965if(m_debug)
    36033966std::cout << "  <MEMC " << name() << " XRAM_RSP_WRITE_DIRTY>"
    36043967          << " Send the put request to IXR_CMD FSM"
    … …  
    36173980
    36183981#if DEBUG_MEMC_XRAM_RSP
    3619 if(m_debug_xram_rsp_fsm)
     3982if(m_debug)
    36203983std::cout << "  <MEMC " << name() << " XRAM_RSP_HEAP_REQ>"
    36213984          << " Requesting HEAP lock" << std::endl;
    … …  
    36554018
    36564019#if DEBUG_MEMC_XRAM_RSP
    3657 if(m_debug_xram_rsp_fsm)
     4020if(m_debug)
    36584021std::cout << "  <MEMC " << name() << " XRAM_RSP_HEAP_ERASE>"
    36594022          << " Erase copy:"
    3660           << " srcid = " << std::dec << entry.owner.srcid
     4023          << " srcid = " << std::hex << entry.owner.srcid
    36614024          << " / inst = " << std::dec << entry.owner.inst << std::endl;
    36624025#endif
    … …  
    36974060
    36984061#if DEBUG_MEMC_XRAM_RSP
    3699 if(m_debug_xram_rsp_fsm)
     4062if(m_debug)
    37004063std::cout << "  <MEMC " << name() << " XRAM_RSP_HEAP_LAST>"
    37014064          << " Heap housekeeping" << std::endl;
    … …  
    37134076
    37144077#if DEBUG_MEMC_XRAM_RSP
    3715 if(m_debug_xram_rsp_fsm)
     4078if(m_debug)
    37164079std::cout << "  <MEMC " << name() << " XRAM_RSP_ERROR_ERASE>"
    37174080          << " Error reported by XRAM / erase the TRT entry" << std::endl;
    … …  
    37394102
    37404103#if DEBUG_MEMC_XRAM_RSP
    3741 if(m_debug_xram_rsp_fsm)
    3742     std::cout << "  <MEMC " << name()
    3743               << " XRAM_RSP_ERROR_RSP> Request a response error to TGT_RSP FSM:"
    3744               << " srcid = " << std::dec << r_xram_rsp_trt_buf.srcid << std::endl;
     4104if(m_debug)
     4105std::cout << "  <MEMC " << name()
     4106          << " XRAM_RSP_ERROR_RSP> Request a response error to TGT_RSP FSM:"
     4107          << " srcid = " << std::dec << r_xram_rsp_trt_buf.srcid << std::endl;
    37454108#endif
    37464109      }
    … …  
    38034166
    38044167#if DEBUG_MEMC_CLEANUP
    3805       if(m_debug_cleanup_fsm)
    3806       {
    3807         std::cout
    3808             << "  <MEMC "         << name()
    3809             << " CLEANUP_IDLE> Cleanup request:" << std::hex
    3810             << " / owner_id = "   << srcid
    3811             << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST)
    3812             << std::endl;
    3813       }
     4168if(m_debug)
     4169std::cout << "  <MEMC "         << name()
     4170          << " CLEANUP_IDLE> Cleanup request:" << std::hex
     4171          << " / owner_id = "   << srcid
     4172          << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST) << std::endl;
    38144173#endif
    38154174      break;
    … …  
    38314190
    38324191#if DEBUG_MEMC_CLEANUP
    3833       if(m_debug_cleanup_fsm)
    3834       {
    3835         std::cout
    3836             << "  <MEMC "         << name()
    3837             << " CLEANUP_GET_NLINE> Cleanup request:"
    3838             << std::hex
    3839             << " / address = "    << nline * m_words * 4
    3840             << std::endl;
    3841       }
     4192if(m_debug)
     4193std::cout << "  <MEMC "         << name()
     4194          << " CLEANUP_GET_NLINE> Cleanup request:"
     4195          << " / address = " << std::hex << nline * m_words * 4 << std::endl;
    38424196#endif
    38434197      break;
    … …  
    38454199
    38464200    /////////////////////
    3847     case CLEANUP_DIR_REQ:
    3848     {
    3849       // Get the lock to the directory
     4201    case CLEANUP_DIR_REQ:   // Get the lock to the directory
     4202    {
    38504203      if(r_alloc_dir_fsm.read() != ALLOC_DIR_CLEANUP) break;
    38514204
    … …  
    38534206
    38544207#if DEBUG_MEMC_CLEANUP
    3855       if(m_debug_cleanup_fsm)
    3856       {
    3857         std::cout
    3858             << "  <MEMC " << name() << " CLEANUP_DIR_REQ> Requesting DIR lock "
    3859             << std::endl;
    3860       }
     4208if(m_debug)
     4209std::cout << "  <MEMC " << name() << " CLEANUP_DIR_REQ> Requesting DIR lock" << std::endl;
    38614210#endif
    38624211      break;
    … …  
    38954244#endif
    38964245
    3897       // hit :
    3898       // the copy must be cleared
    3899       if(entry.valid)
     4246      if(entry.valid)      // hit : the copy must be cleared
    39004247      {
    39014248        assert(
    3902             (entry.count > 0) &&
     4249            (entry.count > 0) and
    39034250            "VCI MEM CACHE ERROR: "
    39044251            "In CLEANUP_DIR_LOCK, CLEANUP command on a valid entry "
    … …  
    39064253
    39074254        // no access to the heap
    3908         if((entry.count == 1) || (entry.is_cnt))
     4255        if((entry.count == 1) or (entry.is_cnt))
    39094256        {
    39104257          r_cleanup_fsm = CLEANUP_DIR_WRITE;
    … …  
    39164263        }
    39174264      }
    3918       // miss :
    3919       // we must check the update table for a pending
    3920       // invalidation transaction
    3921       else
     4265      else                // miss : check UPT for a pending invalidation transaction
    39224266      {
    39234267        r_cleanup_fsm = CLEANUP_UPT_LOCK;
    … …  
    39254269
    39264270#if DEBUG_MEMC_CLEANUP
    3927       if(m_debug_cleanup_fsm)
     4271      if(m_debug)
    39284272      {
    39294273        std::cout
    … …  
    39684312
    39694313      bool   match_inst  = (r_cleanup_copy_inst.read() == r_cleanup_inst.read());
    3970       bool   match       = match_srcid && match_inst;
     4314      bool   match       = match_srcid and match_inst;
    39714315
    39724316      if(not r_cleanup_is_cnt.read() and not match)
    … …  
    39994343      m_cache_directory.write(set, way, entry);
    40004344
    4001       r_cleanup_fsm = CLEANUP_SEND_ACK;
     4345      r_cleanup_fsm = CLEANUP_SEND_CLACK;
    40024346
    40034347#if DEBUG_MEMC_CLEANUP
    4004       if(m_debug_cleanup_fsm)
     4348      if(m_debug)
    40054349      {
    40064350        std::cout
    … …  
    40294373
    40304374#if DEBUG_MEMC_CLEANUP
    4031       if(m_debug_cleanup_fsm)
     4375      if(m_debug)
    40324376      {
    40334377        std::cout
    … …  
    41824526
    41834527#if DEBUG_MEMC_CLEANUP
    4184       if(m_debug_cleanup_fsm)
     4528      if(m_debug)
    41854529      {
    41864530        std::cout
    … …  
    42204564      bool match_heap_srcid = (heap_entry.owner.srcid == r_cleanup_srcid.read());
    42214565      bool match_heap_inst  = (heap_entry.owner.inst  == r_cleanup_inst.read());
    4222       bool match_heap       = match_heap_srcid && match_heap_inst;
     4566      bool match_heap       = match_heap_srcid and match_heap_inst;
    42234567
    42244568#if L1_MULTI_CACHE
    … …  
    42604604
    42614605#if DEBUG_MEMC_CLEANUP
    4262       if(m_debug_cleanup_fsm)
     4606      if(m_debug)
    42634607      {
    42644608        if(not match_heap)
    … …  
    42894633      break;
    42904634    }
    4291 
    4292     case CLEANUP_HEAP_CLEAN:
    4293     {
    4294       // remove a copy in the linked list
     4635    ////////////////////////
     4636    case CLEANUP_HEAP_CLEAN:    // remove a copy in the linked list
     4637    {
    42954638      if(r_alloc_heap_fsm.read() != ALLOC_HEAP_CLEANUP)
    42964639      {
    … …  
    43294672
    43304673#if DEBUG_MEMC_CLEANUP
    4331       if(m_debug_cleanup_fsm)
    4332       {
    4333         std::cout
    4334             << "  <MEMC " << name()
    4335             << " CLEANUP_HEAP_SEARCH> Remove the copy in the linked list"
    4336             << std::endl;
    4337       }
    4338 #endif
    4339       break;
    4340     }
    4341 
    4342     case CLEANUP_HEAP_FREE:
    4343     {
    4344       // The heap entry pointed by r_cleanup_next_ptr is freed
    4345       // and becomes the head of the list of free entries
     4674if(m_debug)
     4675std::cout << "  <MEMC " << name() << " CLEANUP_HEAP_SEARCH>"
     4676          << " Remove the copy in the linked list" << std::endl;
     4677#endif
     4678      break;
     4679    }
     4680    ///////////////////////
     4681    case CLEANUP_HEAP_FREE:   // The heap entry pointed by r_cleanup_next_ptr is freed
     4682                              // and becomes the head of the list of free entries
     4683    {
    43464684      if(r_alloc_heap_fsm.read() != ALLOC_HEAP_CLEANUP)
    43474685      {
    … …  
    43754713      m_heap.unset_full();
    43764714
    4377       r_cleanup_fsm = CLEANUP_SEND_ACK;
     4715      r_cleanup_fsm = CLEANUP_SEND_CLACK;
    43784716
    43794717#if DEBUG_MEMC_CLEANUP
    4380       if(m_debug_cleanup_fsm)
    4381       {
    4382         std::cout
    4383             << "  <MEMC " << name()
    4384             << " CLEANUP_HEAP_SEARCH> Update the list of free entries"
    4385             << std::endl;
    4386       }
    4387 #endif
    4388       break;
    4389     }
    4390 
    4391     case CLEANUP_UPT_LOCK:
    4392     {
    4393       // search pending invalidate transaction matching the Cleanup NLINE in the UPDATE TABLE
    4394       // get the lock in the UPDATE_TABLE
     4718if(m_debug)
     4719std::cout << "  <MEMC " << name() << " CLEANUP_HEAP_FREE>"
     4720          << " Update the list of free entries" << std::endl;
     4721#endif
     4722      break;
     4723    }
     4724    //////////////////////
     4725    case CLEANUP_UPT_LOCK:   // get the lock protecting the UPT to search a pending
     4726                             // invalidate transaction matching the cleanup
     4727    {
    43954728      if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP) break;
    43964729
    … …  
    44004733      match_inval = m_upt.search_inval(r_cleanup_nline.read(), index);
    44014734
    4402       // no pending inval
    4403       if(not match_inval)
    4404       {
    4405         r_cleanup_fsm = CLEANUP_SEND_ACK;
     4735      if ( not match_inval )     // no pending inval
     4736      {
     4737          r_cleanup_fsm = CLEANUP_SEND_CLACK;
    44064738
    44074739#if DEBUG_MEMC_CLEANUP
    4408         if(m_debug_cleanup_fsm)
    4409         {
    4410           std::cout
    4411               << "  <MEMC " << name()
    4412               << " CLEANUP_UPT_LOCK> Unexpected cleanup"
    4413               << " with no corresponding UPT entry:"
    4414               << " address = " << std::hex
    4415               << (r_cleanup_nline.read() *4*m_words)
    4416               << std::endl;
    4417         }
    4418 #endif
    4419         break;
     4740if(m_debug)
     4741std::cout << "  <MEMC " << name()
     4742          << " CLEANUP_UPT_LOCK> Unexpected cleanup"
     4743          << " with no corresponding UPT entry:"
     4744          << " address = " << std::hex
     4745          << (r_cleanup_nline.read() *4*m_words)
     4746          << std::endl;
     4747#endif
     4748          break;
    44204749      }
    44214750
    44224751      // pending inval
    4423       r_cleanup_write_srcid    = m_upt.srcid(index);
    4424       r_cleanup_write_trdid    = m_upt.trdid(index);
    4425       r_cleanup_write_pktid    = m_upt.pktid(index);
    4426       r_cleanup_write_need_rsp = m_upt.need_rsp(index);
    4427       r_cleanup_index          = index;
     4752      r_cleanup_write_srcid = m_upt.srcid(index);
     4753      r_cleanup_write_trdid = m_upt.trdid(index);
     4754      r_cleanup_write_pktid = m_upt.pktid(index);
     4755      r_cleanup_need_rsp    = m_upt.need_rsp(index);
     4756      r_cleanup_need_ack    = m_upt.need_ack(index);
     4757      r_cleanup_index       = index;
    44284758
    44294759      r_cleanup_fsm         = CLEANUP_UPT_DECREMENT;
    44304760
    44314761#if DEBUG_MEMC_CLEANUP
    4432       if(m_debug_cleanup_fsm)
    4433       {
    4434         std::cout
    4435             << "  <MEMC " << name()
    4436             << " CLEANUP_UPT_LOCK> Cleanup matching pending"
    4437             << " invalidate transaction on UPT:"
    4438             << std::hex
    4439             << " address = "   << r_cleanup_nline.read() * m_words * 4
    4440             << " upt_entry = " << index
    4441             << std::endl;
    4442       }
    4443 #endif
    4444       break;
    4445     }
    4446 
    4447     case CLEANUP_UPT_DECREMENT:
    4448     {
    4449       // decrement response counter in UPT matching entry
     4762if(m_debug)
     4763std::cout << "  <MEMC " << name()
     4764          << " CLEANUP_UPT_LOCK> Cleanup matching pending"
     4765          << " invalidate transaction on UPT:"
     4766          << " address = " << std::hex << r_cleanup_nline.read() * m_words * 4
     4767          << " / upt_entry = " << index << std::endl;
     4768#endif
     4769      break;
     4770    }
     4771    ///////////////////////////
     4772    case CLEANUP_UPT_DECREMENT:   // decrement response counter in UPT matching entry
     4773    {
    44504774      if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
    44514775      {
    … …  
    44624786      m_upt.decrement(r_cleanup_index.read(), count);
    44634787
    4464       // invalidation transaction finished
    4465       // (all acknowledgements received)
    4466       if(count == 0)
     4788      if(count == 0)   // multi inval transaction completed
    44674789      {
    44684790        r_cleanup_fsm = CLEANUP_UPT_CLEAR;
    44694791      }
    4470       // invalidation transaction not finished
    4471       else
    4472       {
    4473         r_cleanup_fsm = CLEANUP_SEND_ACK ;
     4792      else             // multi inval transaction not completed
     4793      {
     4794        r_cleanup_fsm = CLEANUP_SEND_CLACK ;
    44744795      }
    44754796
    44764797#if DEBUG_MEMC_CLEANUP
    4477       if(m_debug_cleanup_fsm)
    4478       {
    4479         std::cout
    4480             << "  <MEMC "      << name()
    4481             << " CLEANUP_UPT_DECREMENT> Decrement response counter in UPT:"
     4798if(m_debug)
     4799std::cout << "  <MEMC " << name() << " CLEANUP_UPT_DECREMENT>"
     4800          << " Decrement response counter in UPT:"
    44824801            << " UPT_index = " << r_cleanup_index.read()
    4483             << " rsp_count = " << count
    4484             << std::endl;
    4485       }
    4486 #endif
    4487       break;
    4488     }
    4489 
    4490     case CLEANUP_UPT_CLEAR:
    4491     {
    4492       // Clear UPT entry of finished invalidation transaction
     4802            << " / rsp_count = " << count << std::endl;
     4803#endif
     4804      break;
     4805    }
     4806    ///////////////////////
     4807    case CLEANUP_UPT_CLEAR:    // Clear UPT entry
     4808    {
    44934809      if(r_alloc_upt_fsm.read() != ALLOC_UPT_CLEANUP)
    44944810      {
    … …  
    45044820      m_upt.clear(r_cleanup_index.read());
    45054821
    4506       if(r_cleanup_write_need_rsp.read())
    4507       {
    4508         r_cleanup_fsm = CLEANUP_WRITE_RSP;
    4509       }
    4510       else
    4511       {
    4512         r_cleanup_fsm = CLEANUP_SEND_ACK;
    4513       }
     4822      if      ( r_cleanup_need_rsp.read() ) r_cleanup_fsm = CLEANUP_WRITE_RSP;
     4823      else if ( r_cleanup_need_ack.read() ) r_cleanup_fsm = CLEANUP_CONFIG_ACK;
     4824      else                                  r_cleanup_fsm = CLEANUP_SEND_CLACK;
    45144825
    45154826#if DEBUG_MEMC_CLEANUP
    4516       if(m_debug_cleanup_fsm)
    4517       {
    4518         std::cout
    4519             << "  <MEMC "      << name()
    4520             << " CLEANUP_UPT_CLEAR> Clear entry in UPT:"
    4521             << " UPT_index = " << r_cleanup_index.read()
    4522             << std::endl;
    4523       }
    4524 #endif
    4525       break;
    4526     }
    4527 
    4528     case CLEANUP_WRITE_RSP:
    4529     {
    4530       // response to a previous write on the direct network
    4531       // wait if pending request to the TGT_RSP FSM
     4827if(m_debug)
     4828std::cout << "  <MEMC "      << name()
     4829          << " CLEANUP_UPT_CLEAR> Clear entry in UPT:"
     4830          << " UPT_index = " << r_cleanup_index.read() << std::endl;
     4831#endif
     4832      break;
     4833    }
     4834    ///////////////////////
     4835    case CLEANUP_WRITE_RSP:    // response to a previous write on the direct network
     4836                               // wait if pending request to the TGT_RSP FSM
     4837    {
    45324838      if(r_cleanup_to_tgt_rsp_req.read()) break;
    45334839
    … …  
    45384844      r_cleanup_to_tgt_rsp_pktid   = r_cleanup_write_pktid.read();
    45394845
    4540       r_cleanup_fsm                = CLEANUP_SEND_ACK;
     4846      r_cleanup_fsm                = CLEANUP_SEND_CLACK;
    45414847
    45424848#if DEBUG_MEMC_CLEANUP
    4543       if(m_debug_cleanup_fsm)
    4544       {
    4545         std::cout
    4546             << "  <MEMC " << name()
    4547             << " CLEANUP_WRITE_RSP> Send a response to a previous"
    4548             << " write request waiting for coherence transaction completion: "
    4549             << " rsrcid = "   << std::hex << r_cleanup_write_srcid.read()
    4550             << " / rtrdid = " << std::hex << r_cleanup_write_trdid.read()
    4551             << std::endl;
    4552       }
    4553 #endif
    4554       break;
    4555     }
    4556 
    4557     case CLEANUP_SEND_ACK:
    4558     {
    4559       // acknowledgement to a cleanup command
    4560       // on the coherence network (request to the CC_SEND FSM).
    4561       // wait if pending request to the CC_SEND FSM
     4849if(m_debug)
     4850std::cout << "  <MEMC " << name() << " CLEANUP_WRITE_RSP>"
     4851          << " Send a response to a previous write request: "
     4852          << " rsrcid = "   << std::hex << r_cleanup_write_srcid.read()
     4853          << " / rtrdid = " << r_cleanup_write_trdid.read()
     4854          << " / rpktid = " << r_cleanup_write_pktid.read() << std::endl;
     4855#endif
     4856      break;
     4857    }
     4858    ////////////////////////
     4859    case CLEANUP_CONFIG_ACK:   // signals inval completion to CONFIG FSM
     4860                               // wait if pending request
     4861    {
     4862      if ( r_cleanup_to_config_ack.read() ) break;
     4863
     4864      r_cleanup_to_config_ack      = true;
     4865      r_cleanup_fsm                = CLEANUP_SEND_CLACK;
     4866
     4867#if DEBUG_MEMC_CLEANUP
     4868if(m_debug)
     4869std::cout << "  <MEMC " << name() << " CLEANUP_CONFIG_ACK>"
     4870          << " Acknowledge broacast inval completion" << std::endl;
     4871#endif
     4872      break;
     4873    }
     4874    ////////////////////////
     4875    case CLEANUP_SEND_CLACK:    // acknowledgement to a cleanup command
     4876                              // on the coherence network (request to the CC_SEND FSM).
     4877                              // wait if pending request to the CC_SEND FSM
     4878    {
    45624879      if(r_cleanup_to_cc_send_req.read()) break;
    45634880
    … …  
    45714888
    45724889#if DEBUG_MEMC_CLEANUP
    4573       if(m_debug_cleanup_fsm)
    4574       {
    4575         std::cout
    4576             << "  <MEMC " << name()
    4577             << " CLEANUP_SEND_ACK> Send the response to a cleanup request:"
    4578             << " srcid = " << std::dec << r_cleanup_srcid.read()
    4579             << std::endl;
    4580       }
     4890if(m_debug)
     4891std::cout << "  <MEMC " << name()
     4892          << " CLEANUP_SEND_CLACK> Send the response to a cleanup request:"
     4893          << " srcid = " << std::dec << r_cleanup_srcid.read() << std::endl;
    45814894#endif
    45824895      break;
    … …  
    46184931
    46194932#if DEBUG_MEMC_CAS
    4620         if(m_debug_cas_fsm)
     4933        if(m_debug)
    46214934        {
    46224935          std::cout << "  <MEMC " << name() << " CAS_IDLE> CAS command: " << std::hex
    … …  
    46414954          r_cas_rdata[r_cas_cpt.read()] = m_cmd_cas_wdata_fifo.read();
    46424955
    4643         if((r_cas_cpt.read() == 1) && m_cmd_cas_eop_fifo.read())
     4956        if((r_cas_cpt.read() == 1) and m_cmd_cas_eop_fifo.read())
    46444957          r_cas_wdata = m_cmd_cas_wdata_fifo.read();
    46454958
    … …  
    46684981
    46694982#if DEBUG_MEMC_CAS
    4670       if(m_debug_cas_fsm)
     4983      if(m_debug)
    46714984      {
    46724985        std::cout
    … …  
    47025015
    47035016#if DEBUG_MEMC_CAS
    4704         if(m_debug_cas_fsm)
     5017        if(m_debug)
    47055018        {
    47065019          std::cout << "  <MEMC " << name() << " CAS_DIR_LOCK> Directory acces"
    … …  
    47545067
    47555068#if DEBUG_MEMC_CAS
    4756 if(m_debug_cas_fsm)
     5069if(m_debug)
    47575070std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_READ> Read data from "
    47585071          << " cache and store it in buffer" << std::endl;
    … …  
    47725085
    47735086      // to avoid livelock, force the atomic access to fail pseudo-randomly
    4774       bool forced_fail = ((r_cas_lfsr % (64) == 0) && RANDOMIZE_CAS);
     5087      bool forced_fail = ((r_cas_lfsr % (64) == 0) and RANDOMIZE_CAS);
    47755088      r_cas_lfsr = (r_cas_lfsr >> 1) ^ ((- (r_cas_lfsr & 1)) & 0xd0000001);
    47765089
    … …  
    47875100
    47885101#if DEBUG_MEMC_CAS
    4789 if(m_debug_cas_fsm)
     5102if(m_debug)
    47905103std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_COMPARE> Compare the old"
    47915104          << " and the new data"
    … …  
    48105123          r_cas_fsm = CAS_BC_TRT_LOCK;    // broadcast invalidate required
    48115124        }
    4812         else if(!r_cas_to_cc_send_multi_req.read() &&
     5125        else if(!r_cas_to_cc_send_multi_req.read() and
    48135126                !r_cas_to_cc_send_brdcast_req.read())
    48145127        {
    … …  
    48475160
    48485161#if DEBUG_MEMC_CAS
    4849 if(m_debug_cas_fsm)
     5162if(m_debug)
    48505163std::cout << "  <MEMC " << name() << " CAS_DIR_HIT_WRITE> Update cache:"
    48515164          << " way = " << std::dec << way
    … …  
    48745187        size_t      nb_copies  = r_cas_count.read();
    48755188
    4876         wok = m_upt.set(true,  // it's an update transaction
    4877                                false,   // it's not a broadcast
    4878                                true,    // it needs a response
    4879                                srcid,
    4880                                trdid,
    4881                                pktid,
    4882                                nline,
    4883                                nb_copies,
    4884                                index);
     5189        wok = m_upt.set(true,    // it's an update transaction
     5190                        false,   // it's not a broadcast
     5191                        true,    // response required 
     5192                        false,   // no acknowledge required
     5193                        srcid,
     5194                        trdid,
     5195                        pktid,
     5196                        nline,
     5197                        nb_copies,
     5198                        index);
    48855199        if(wok)   // coherence transaction registered in UPT
    48865200        {
    … …  
    49165230
    49175231#if DEBUG_MEMC_CAS
    4918 if(m_debug_cas_fsm)
     5232if(m_debug)
    49195233std::cout << "  <MEMC " << name()
    49205234          << " CAS_UPT_LOCK> Register multi-update transaction in UPT"
    … …  
    49315245
    49325246#if DEBUG_MEMC_CAS
    4933       if(m_debug_cas_fsm)
     5247      if(m_debug)
    49345248      {
    49355249        std::cout << "  <MEMC " << name()
    … …  
    49475261
    49485262#if DEBUG_MEMC_CAS
    4949         if(m_debug_cas_fsm)
     5263        if(m_debug)
    49505264        {
    49515265          std::cout << "  <MEMC " << name()
    … …  
    49635277             "VCI_MEM_CACHE ERROR : bad HEAP allocation");
    49645278
    4965       if(!r_cas_to_cc_send_multi_req.read() && !r_cas_to_cc_send_brdcast_req.read())
     5279      if(!r_cas_to_cc_send_multi_req.read() and !r_cas_to_cc_send_brdcast_req.read())
    49665280      {
    49675281        r_cas_to_cc_send_brdcast_req  = false;
    … …  
    50035317
    50045318#if DEBUG_MEMC_CAS
    5005         if(m_debug_cas_fsm)
     5319        if(m_debug)
    50065320        {
    50075321          std::cout << "  <MEMC " << name() << " CAS_UPT_REQ> Send the first update request to CC_SEND FSM "
    … …  
    50435357
    50445358#if DEBUG_MEMC_CAS
    5045       if(m_debug_cas_fsm)
     5359      if(m_debug)
    50465360      {
    50475361        std::cout << "  <MEMC " << name() << " CAS_UPT_NEXT> Send the next update request to CC_SEND FSM "
    … …  
    50695383              r_cas_to_ixr_cmd_data[i] = r_cas_wdata.read();
    50705384            }
    5071             else if((i == word+1) && (r_cas_cpt.read() == 4))   // 64 bit CAS
     5385            else if((i == word+1) and (r_cas_cpt.read() == 4))   // 64 bit CAS
    50725386            {
    50735387              r_cas_to_ixr_cmd_data[i] = m_cmd_cas_wdata_fifo.read();
    … …  
    51135427        // register a broadcast inval transaction in UPT
    51145428        wok = m_upt.set(false,  // it's an inval transaction
    5115                                true,    // it's a broadcast
    5116                                true,    // it needs a response
    5117                                srcid,
    5118                                trdid,
    5119                                pktid,
    5120                                nline,
    5121                                nb_copies,
    5122                                index);
     5429                        true,    // it's a broadcast
     5430                        true,    // response required
     5431                        false,   // no acknowledge required
     5432                        srcid,
     5433                        trdid,
     5434                        pktid,
     5435                        nline,
     5436                        nb_copies,
     5437                        index);
    51235438
    51245439        if(wok)     // UPT not full
    … …  
    51485463
    51495464#if DEBUG_MEMC_CAS
    5150 if(m_debug_cas_fsm)
     5465if(m_debug)
    51515466std::cout << "  <MEMC " << name()
    51525467          << " CAS_BC_UPT_LOCK> Register a broadcast inval transaction in UPT"
    … …  
    51665481    case CAS_BC_DIR_INVAL:  // Register the PUT transaction in TRT, and inval the DIR entry
    51675482    {
    5168       if((r_alloc_trt_fsm.read() == ALLOC_TRT_CAS) &&
    5169           (r_alloc_upt_fsm.read() == ALLOC_UPT_CAS) &&
     5483      if((r_alloc_trt_fsm.read() == ALLOC_TRT_CAS) and
     5484          (r_alloc_upt_fsm.read() == ALLOC_UPT_CAS) and
    51705485          (r_alloc_dir_fsm.read() == ALLOC_DIR_CAS))
    51715486      {
    … …  
    52045519
    52055520#if DEBUG_MEMC_CAS
    5206 if(m_debug_cas_fsm)
     5521if(m_debug)
    52075522std::cout << "  <MEMC " << name()
    52085523          << " CAS_BC_DIR_INVAL> Register the PUT in TRT and invalidate DIR entry"
    … …  
    52205535    case CAS_BC_CC_SEND:  // Request the broadcast inval to CC_SEND FSM
    52215536    {
    5222       if(!r_cas_to_cc_send_multi_req.read() &&
     5537      if(!r_cas_to_cc_send_multi_req.read() and
    52235538          !r_cas_to_cc_send_brdcast_req.read())
    52245539      {
    … …  
    52485563
    52495564#if DEBUG_MEMC_CAS
    5250 if(m_debug_cas_fsm)
     5565if(m_debug)
    52515566std::cout << "  <MEMC " << name()
    52525567          << " CAS_BC_XRAM_REQ> Request a PUT transaction to IXR_CMD FSM" << std::hex
    … …  
    52775592
    52785593#if DEBUG_MEMC_CAS
    5279 if(m_debug_cas_fsm)
     5594if(m_debug)
    52805595std::cout << "  <MEMC " << name()
    52815596          << " CAS_RSP_FAIL> Request TGT_RSP to send a failure response" << std::endl;
    … …  
    52995614
    53005615#if DEBUG_MEMC_CAS
    5301 if(m_debug_cas_fsm)
     5616if(m_debug)
    53025617std::cout << "  <MEMC " << name()
    53035618          << " CAS_RSP_SUCCESS> Request TGT_RSP to send a success response" << std::endl;
    … …  
    53195634
    53205635#if DEBUG_MEMC_CAS
    5321         if(m_debug_cas_fsm)
     5636        if(m_debug)
    53225637        {
    53235638          std::cout << "  <MEMC " << name() << " CAS_MISS_TRT_LOCK> Check TRT state"
    … …  
    53295644#endif
    53305645
    5331         if(hit_read || !wok || hit_write)    // missing line already requested or no space in TRT
     5646        if(hit_read or !wok or hit_write)    // missing line already requested or no space in TRT
    53325647        {
    53335648          r_cas_fsm = CAS_WAIT;
    … …  
    53705685
    53715686#if DEBUG_MEMC_CAS
    5372         if(m_debug_cas_fsm)
     5687        if(m_debug)
    53735688        {
    53745689          std::cout << "  <MEMC " << name() << " CAS_MISS_TRT_SET> Register a GET transaction in TRT" << std::hex
    … …  
    53925707
    53935708#if DEBUG_MEMC_CAS
    5394         if(m_debug_cas_fsm)
     5709        if(m_debug)
    53955710        {
    53965711          std::cout << "  <MEMC " << name() << " CAS_MISS_XRAM_REQ> Request a GET transaction to IXR_CMD FSM" << std::hex
    … …  
    54385753      {
    54395754        // XRAM_RSP FSM has highest priority
    5440         if(m_xram_rsp_to_cc_send_inst_fifo.rok() ||
     5755        if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    54415756            r_xram_rsp_to_cc_send_multi_req.read())
    54425757        {
    … …  
    54535768        }
    54545769
    5455         if(m_cas_to_cc_send_inst_fifo.rok() ||
     5770        if(m_cas_to_cc_send_inst_fifo.rok() or
    54565771            r_cas_to_cc_send_multi_req.read())
    54575772        {
    … …  
    54745789        }
    54755790
    5476         if(m_write_to_cc_send_inst_fifo.rok() ||
     5791        if(m_write_to_cc_send_inst_fifo.rok() or
    54775792            r_write_to_cc_send_multi_req.read())
    54785793        {
    … …  
    54935808      {
    54945809        // CAS FSM has highest priority
    5495         if(m_cas_to_cc_send_inst_fifo.rok() ||
     5810        if(m_cas_to_cc_send_inst_fifo.rok() or
    54965811            r_cas_to_cc_send_multi_req.read())
    54975812        {
    … …  
    55145829        }
    55155830
    5516         if(m_write_to_cc_send_inst_fifo.rok() ||
     5831        if(m_write_to_cc_send_inst_fifo.rok() or
    55175832            r_write_to_cc_send_multi_req.read())
    55185833        {
    … …  
    55295844        }
    55305845
    5531         if(m_xram_rsp_to_cc_send_inst_fifo.rok() ||
     5846        if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    55325847            r_xram_rsp_to_cc_send_multi_req.read())
    55335848        {
    … …  
    55555870        }
    55565871
    5557         if(m_write_to_cc_send_inst_fifo.rok() ||
     5872        if(m_write_to_cc_send_inst_fifo.rok() or
    55585873            r_write_to_cc_send_multi_req.read())
    55595874        {
    … …  
    55705885        }
    55715886
    5572         if(m_xram_rsp_to_cc_send_inst_fifo.rok() ||
     5887        if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    55735888            r_xram_rsp_to_cc_send_multi_req.read())
    55745889        {
    … …  
    55855900        }
    55865901
    5587         if(m_cas_to_cc_send_inst_fifo.rok() ||
     5902        if(m_cas_to_cc_send_inst_fifo.rok() or
    55885903            r_cas_to_cc_send_multi_req.read())
    55895904        {
    … …  
    56045919      {
    56055920        // WRITE FSM has highest priority
    5606         if(m_write_to_cc_send_inst_fifo.rok() ||
     5921        if(m_write_to_cc_send_inst_fifo.rok() or
    56075922            r_write_to_cc_send_multi_req.read())
    56085923        {
    … …  
    56195934        }
    56205935
    5621         if(m_xram_rsp_to_cc_send_inst_fifo.rok() ||
     5936        if(m_xram_rsp_to_cc_send_inst_fifo.rok() or
    56225937            r_xram_rsp_to_cc_send_multi_req.read())
    56235938        {
    … …  
    56345949        }
    56355950
    5636         if(m_cas_to_cc_send_inst_fifo.rok() ||
     5951        if(m_cas_to_cc_send_inst_fifo.rok() or
    56375952            r_cas_to_cc_send_multi_req.read())
    56385953        {
    … …  
    56665981
    56675982#if DEBUG_MEMC_CC_SEND
    5668 if(m_debug_cc_send_fsm)
     5983if(m_debug)
    56695984std::cout << "  <MEMC " << name()
    56705985          << " CC_SEND_CLEANUP_ACK> Cleanup Ack for srcid "
    … …  
    57056020
    57066021#if DEBUG_MEMC_CC_SEND
    5707 if(m_debug_cc_send_fsm)
     6022if(m_debug)
    57086023std::cout << "  <MEMC " << name()
    57096024          << " CC_SEND_XRAM_RSP_INVAL_NLINE> BC-Inval for line "
    … …  
    57336048
    57346049#if DEBUG_MEMC_CC_SEND
    5735 if(m_debug_cc_send_fsm)
     6050if(m_debug)
    57366051std::cout << "  <MEMC " << name()
    57376052          << " CC_SEND_XRAM_RSP_BRDCAST_NLINE> BC-Inval for line "
    … …  
    57616076
    57626077#if DEBUG_MEMC_CC_SEND
    5763 if(m_debug_cc_send_fsm)
     6078if(m_debug)
    57646079std::cout << "  <MEMC " << name()
    57656080          << " CC_SEND_WRITE_BRDCAST_NLINE> BC-Inval for line "
    … …  
    58006115
    58016116#if DEBUG_MEMC_CC_SEND
    5802         if(m_debug_cc_send_fsm)
     6117        if(m_debug)
    58036118        {
    58046119          std::cout
    … …  
    58486163
    58496164#if DEBUG_MEMC_CC_SEND
    5850         if(m_debug_cc_send_fsm)
     6165        if(m_debug)
    58516166        {
    58526167          std::cout
    … …  
    58926207
    58936208#if DEBUG_MEMC_CC_SEND
    5894         if(m_debug_cc_send_fsm)
    5895         {
    5896           std::cout
    5897             << "  <MEMC " << name()
    5898             << " CC_SEND_CAS_UPDT_NLINE> Multicast-Update for line "
    5899             << r_cas_to_cc_send_nline.read()
    5900             << std::endl;
    5901         }
     6209if(m_debug)
     6210std::cout << "  <MEMC " << name()
     6211          << " CC_SEND_CAS_UPDT_NLINE> Multicast-Update for line "
     6212          << r_cas_to_cc_send_nline.read() << std::endl;
    59026213#endif
    59036214        break;
    … …  
    59516262              DspinDhccpParam::FROM_L1_TYPE);
    59526263
    5953         if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) ||
     6264        if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
    59546265           (type == DspinDhccpParam::TYPE_CLEANUP_INST))
    59556266        {
    … …  
    59646275        }
    59656276
    5966         assert(false &&
     6277        assert(false and
    59676278            "VCI_MEM_CACHE ERROR in CC_RECEIVE : "
    59686279            "Illegal type in coherence request");
    … …  
    60496360        r_tgt_rsp_cpt = r_read_to_tgt_rsp_word.read();
    60506361      }
    6051       else if(r_write_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_WRITE;
    6052       else if(r_cas_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_CAS  ;
     6362      else if(r_write_to_tgt_rsp_req)
     6363      {
     6364        r_tgt_rsp_fsm = TGT_RSP_WRITE;
     6365      }
     6366      else if(r_cas_to_tgt_rsp_req)
     6367      {
     6368        r_tgt_rsp_fsm = TGT_RSP_CAS  ;
     6369      }
    60536370      else if(r_xram_rsp_to_tgt_rsp_req)
    60546371      {
    … …  
    60566373        r_tgt_rsp_cpt = r_xram_rsp_to_tgt_rsp_word.read();
    60576374      }
    6058       else if(r_multi_ack_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
    6059       else if(r_cleanup_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
    6060       else if(r_tgt_cmd_to_tgt_rsp_req) r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     6375      else if(r_multi_ack_to_tgt_rsp_req)
     6376      {
     6377        r_tgt_rsp_fsm = TGT_RSP_MULTI_ACK;
     6378      }
     6379      else if(r_cleanup_to_tgt_rsp_req)
     6380      {
     6381        r_tgt_rsp_fsm = TGT_RSP_CLEANUP;
     6382      }
     6383      else if(r_tgt_cmd_to_tgt_rsp_req)
     6384      {
     6385        r_tgt_rsp_fsm = TGT_RSP_TGT_CMD;
     6386      }
    60616387      break;
    60626388    }
    … …  
    61856511    /////////////////////
    61866512    case TGT_RSP_TGT_CMD: // send the response after a segmentation violation
     6513                          // or after a config transaction 
    61876514    {
    61886515      if ( p_vci_tgt.rspack )
    … …  
    61926519
    61936520#if DEBUG_MEMC_TGT_RSP
    6194 if( m_debug_tgt_rsp_fsm )
     6521if( m_debug )
    61956522{
    61966523  std::cout
    61976524    << "  <MEMC " << name()
    6198     << " TGT_RSP_TGT_CMD> Segmentation violation from TGT_CMD response"
     6525    << " TGT_RSP_TGT_CMD> Segmentation violation ior config access response"
    61996526    << " / rsrcid = " << std::hex << r_tgt_cmd_to_tgt_rsp_srcid.read()
    62006527    << " / rtrdid = " << r_tgt_cmd_to_tgt_rsp_trdid.read()
    … …  
    62146541
    62156542#if DEBUG_MEMC_TGT_RSP
    6216 if( m_debug_tgt_rsp_fsm )
     6543if( m_debug )
    62176544{
    62186545  std::cout
    … …  
    62606587
    62616588#if DEBUG_MEMC_TGT_RSP
    6262 if(m_debug_tgt_rsp_fsm)
     6589if(m_debug)
    62636590std::cout << "  <MEMC " << name() << " TGT_RSP_WRITE> Write response"
    62646591          << " / rsrcid = " << std::hex << r_write_to_tgt_rsp_srcid.read()
    … …  
    62716598      break;
    62726599    }
    6273     ///////////////////
     6600    /////////////////////
    62746601    case TGT_RSP_CLEANUP:   // pas clair pour moi (AG)
    62756602    {
    … …  
    62786605
    62796606#if DEBUG_MEMC_TGT_RSP
    6280 if(m_debug_tgt_rsp_fsm)
     6607if(m_debug)
    62816608std::cout << "  <MEMC " << name() << " TGT_RSP_CLEANUP> Cleanup response"
    62826609          << " / rsrcid = " << std::hex << r_cleanup_to_tgt_rsp_srcid.read()
    … …  
    62896616      break;
    62906617    }
    6291     //////////////////
     6618    /////////////////
    62926619    case TGT_RSP_CAS:    // send one atomic word response
    62936620    {
    … …  
    62966623
    62976624#if DEBUG_MEMC_TGT_RSP
    6298 if(m_debug_tgt_rsp_fsm)
     6625if(m_debug)
    62996626std::cout << "  <MEMC " << name() << " TGT_RSP_CAS> CAS response"
    63006627          << " / rsrcid = " << std::hex << r_cas_to_tgt_rsp_srcid.read()
    … …  
    63086635    }
    63096636
    6310     ///////////////////////
     6637    //////////////////
    63116638    case TGT_RSP_XRAM:    // send the response after XRAM access
    63126639    {
    … …  
    63156642
    63166643#if DEBUG_MEMC_TGT_RSP
    6317 if( m_debug_tgt_rsp_fsm )
     6644if( m_debug )
    63186645std::cout << "  <MEMC " << name() << " TGT_RSP_XRAM> Response following XRAM access"
    63196646          << " / rsrcid = " << std::hex << r_xram_rsp_to_tgt_rsp_srcid.read()
    … …  
    63516678      break;
    63526679    }
    6353     //////////////////
     6680    ///////////////////////
    63546681    case TGT_RSP_MULTI_ACK:    // send the write response after coherence transaction
    63556682    {
    … …  
    63586685
    63596686#if DEBUG_MEMC_TGT_RSP
    6360 if(m_debug_tgt_rsp_fsm)
     6687if(m_debug)
    63616688std::cout << "  <MEMC " << name() << " TGT_RSP_MULTI_ACK> Write response after coherence transaction"
    63626689          << " / rsrcid = " << std::hex << r_multi_ack_to_tgt_rsp_srcid.read()
    … …  
    63746701  //    ALLOC_UPT FSM
    63756702  ////////////////////////////////////////////////////////////////////////////////////
    6376   // The ALLOC_UPT FSM allocates the access to the Update/Inval Table (UPT).
    6377   // with a round robin priority between three FSMs : MULTI_ACK > WRITE > XRAM_RSP > CLEANUP
    6378   // - The WRITE FSM initiates update transactions and sets  new entry in UPT.
    6379   // - The XRAM_RSP FSM initiates inval transactions and sets new entry in UPT.
     6703  // The ALLOC_UPT FSM allocates the access to the Update/Inval Table (UPT),
     6704  // with a round robin priority between six FSMs, with the following order:
     6705  //  CONFIG > MULTI_ACK > WRITE > XRAM_RSP > CLEANUP > CAS
     6706  // - The CONFIG FSM initiates an inval transaction and sets a new entry in UPT.
    63806707  // - The MULTI_ACK FSM complete those trasactions and erase the UPT entry.
     6708  // - The WRITE FSM initiates update transaction and sets a new entry in UPT.
     6709  // - The XRAM_RSP FSM initiates an inval transactions and sets a new entry in UPT.
    63816710  // - The CLEANUP  FSM decrement an entry in UPT.
     6711  // - The CAS FSM does the same thing as the WRITE FSM.
    63826712  // The resource is always allocated.
    63836713  /////////////////////////////////////////////////////////////////////////////////////
    … …  
    63856715  switch(r_alloc_upt_fsm.read())
    63866716  {
    6387 
    6388       ////////////////////////
    6389     case ALLOC_UPT_MULTI_ACK:
    6390       if((r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK) &&
     6717      //////////////////////
     6718      case ALLOC_UPT_CONFIG:   // allocated to CONFIG FSM
     6719      if ( (r_config_fsm.read() != CONFIG_UPT_LOCK) and
     6720           (r_config_fsm.read() != CONFIG_BC_UPT_LOCK) )
     6721      {
     6722        if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6723          r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
     6724               
     6725        else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
     6726                (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
     6727          r_alloc_upt_fsm = ALLOC_UPT_WRITE;
     6728
     6729        else if(r_xram_rsp_fsm.read() == XRAM_RSP_INVAL_LOCK)
     6730          r_alloc_upt_fsm = ALLOC_UPT_XRAM_RSP;
     6731
     6732        else if(r_cleanup_fsm.read() == CLEANUP_UPT_LOCK)
     6733          r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
     6734
     6735        else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
     6736                (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
     6737          r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6738      }
     6739      break;
     6740
     6741      /////////////////////////
     6742      case ALLOC_UPT_MULTI_ACK:   // allocated to MULTI_ACK FSM
     6743      if( (r_multi_ack_fsm.read() != MULTI_ACK_UPT_LOCK) and
    63916744          (r_multi_ack_fsm.read() != MULTI_ACK_UPT_CLEAR))
    63926745      {
    6393         if((r_write_fsm.read() == WRITE_UPT_LOCK) ||
     6746        if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    63946747            (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    63956748          r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    … …  
    64016754          r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    64026755
    6403         else if((r_cas_fsm.read() == CAS_UPT_LOCK) ||
     6756        else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    64046757                (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    64056758          r_alloc_upt_fsm = ALLOC_UPT_CAS;
     6759
     6760        else if((r_config_fsm.read() == CONFIG_UPT_LOCK) or
     6761                (r_config_fsm.read() == CONFIG_BC_UPT_LOCK))
     6762          r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
    64066763      }
    64076764      break;
    64086765
    64096766      /////////////////////
    6410     case ALLOC_UPT_WRITE:
    6411       if((r_write_fsm.read() != WRITE_UPT_LOCK) &&
     6767      case ALLOC_UPT_WRITE:   // allocated to WRITE FSM
     6768      if((r_write_fsm.read() != WRITE_UPT_LOCK) and
    64126769          (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
    64136770      {
    … …  
    64186775          r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    64196776
    6420         else if((r_cas_fsm.read() == CAS_UPT_LOCK) ||
     6777        else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    64216778                (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    64226779          r_alloc_upt_fsm = ALLOC_UPT_CAS;
    64236780
     6781        else if((r_config_fsm.read() == CONFIG_UPT_LOCK) or
     6782                (r_config_fsm.read() == CONFIG_BC_UPT_LOCK))
     6783          r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
     6784
    64246785        else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    64256786          r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    … …  
    64286789
    64296790      ////////////////////////
    6430     case ALLOC_UPT_XRAM_RSP:
     6791      case ALLOC_UPT_XRAM_RSP:
    64316792      if(r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK)
    64326793      {
    … …  
    64346795          r_alloc_upt_fsm = ALLOC_UPT_CLEANUP;
    64356796
    6436         else if((r_cas_fsm.read() == CAS_UPT_LOCK) ||
     6797        else if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    64376798                (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    64386799          r_alloc_upt_fsm = ALLOC_UPT_CAS;
    64396800
     6801        else if((r_config_fsm.read() == CONFIG_UPT_LOCK) or
     6802                (r_config_fsm.read() == CONFIG_BC_UPT_LOCK))
     6803          r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
     6804
    64406805        else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    64416806          r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    64426807
    6443         else if((r_write_fsm.read() == WRITE_UPT_LOCK)   ||
     6808        else if((r_write_fsm.read() == WRITE_UPT_LOCK)   or
    64446809                (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    64456810          r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    … …  
    64486813
    64496814      //////////////////////////
    6450     case ALLOC_UPT_CLEANUP:
    6451       if((r_cleanup_fsm.read() != CLEANUP_UPT_LOCK     ) &&
     6815      case ALLOC_UPT_CLEANUP:
     6816      if((r_cleanup_fsm.read() != CLEANUP_UPT_LOCK     ) and
    64526817         (r_cleanup_fsm.read() != CLEANUP_UPT_DECREMENT))
    64536818      {
    6454         if((r_cas_fsm.read() == CAS_UPT_LOCK) ||
     6819        if((r_cas_fsm.read() == CAS_UPT_LOCK) or
    64556820            (r_cas_fsm.read() == CAS_BC_UPT_LOCK))
    64566821          r_alloc_upt_fsm = ALLOC_UPT_CAS;
    64576822
     6823        else if((r_config_fsm.read() == CONFIG_UPT_LOCK) or
     6824                (r_config_fsm.read() == CONFIG_BC_UPT_LOCK))
     6825          r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
     6826
    64586827        else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    64596828          r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    64606829
    6461         else if((r_write_fsm.read() == WRITE_UPT_LOCK) ||
     6830        else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    64626831                (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    64636832          r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    … …  
    64696838
    64706839      //////////////////////////
    6471     case ALLOC_UPT_CAS:
    6472       if((r_cas_fsm.read() != CAS_UPT_LOCK) &&
     6840      case ALLOC_UPT_CAS:
     6841      if((r_cas_fsm.read() != CAS_UPT_LOCK) and
    64736842          (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
    64746843      {
    6475         if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
     6844        if((r_config_fsm.read() == CONFIG_UPT_LOCK) or
     6845                (r_config_fsm.read() == CONFIG_BC_UPT_LOCK))
     6846          r_alloc_upt_fsm = ALLOC_UPT_CONFIG;
     6847
     6848        else if(r_multi_ack_fsm.read() == MULTI_ACK_UPT_LOCK)
    64766849          r_alloc_upt_fsm = ALLOC_UPT_MULTI_ACK;
    64776850
    6478         else if((r_write_fsm.read() == WRITE_UPT_LOCK) ||
     6851        else if((r_write_fsm.read() == WRITE_UPT_LOCK) or
    64796852                (r_write_fsm.read() == WRITE_BC_UPT_LOCK))
    64806853          r_alloc_upt_fsm = ALLOC_UPT_WRITE;
    … …  
    64946867  ////////////////////////////////////////////////////////////////////////////////////
    64956868  // The ALLOC_DIR FSM allocates the access to the directory and
    6496   // the data cache with a round robin priority between 5 user FSMs :
    6497   // The cyclic ordering is READ > WRITE > CAS > CLEANUP > XRAM_RSP
     6869  // the data cache with a round robin priority between 6 user FSMs :
     6870  // The cyclic ordering is CONFIG > READ > WRITE > CAS > CLEANUP > XRAM_RSP
    64986871  // The ressource is always allocated.
    64996872  /////////////////////////////////////////////////////////////////////////////////////
    … …  
    65016874  switch(r_alloc_dir_fsm.read())
    65026875  {
     6876    /////////////////////
    65036877    case ALLOC_DIR_RESET: // Initializes the directory one SET per cycle.
    65046878                          // All the WAYS of a SET initialized in parallel
    … …  
    65136887      break;
    65146888
     6889    //////////////////////
     6890    case ALLOC_DIR_CONFIG:    // allocated to CONFIG FSM
     6891    if ( (r_config_fsm.read()    != CONFIG_DIR_REQ) and
     6892         (r_config_fsm.read()    != CONFIG_DIR_ACCESS) and
     6893         (r_config_fsm.read()    != CONFIG_DIR_INVAL) )
     6894    {
     6895        if(r_read_fsm.read() == READ_DIR_REQ)
     6896          r_alloc_dir_fsm = ALLOC_DIR_READ;
     6897
     6898        else if(r_write_fsm.read() == WRITE_DIR_REQ)
     6899          r_alloc_dir_fsm = ALLOC_DIR_WRITE;
     6900
     6901        else if(r_cas_fsm.read() == CAS_DIR_REQ)
     6902          r_alloc_dir_fsm = ALLOC_DIR_CAS;
     6903
     6904        else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
     6905          r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
     6906
     6907        else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
     6908          r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
     6909    }
     6910    break;
     6911
    65156912    ////////////////////
    6516     case ALLOC_DIR_READ:
    6517       if(((r_read_fsm.read()        != READ_DIR_REQ)   &&
    6518           (r_read_fsm.read()        != READ_DIR_LOCK)   &&
    6519           (r_read_fsm.read()        != READ_TRT_LOCK)   &&
    6520           (r_read_fsm.read()        != READ_HEAP_REQ))
    6521           ||
    6522           ((r_read_fsm.read()       == READ_TRT_LOCK)   &&
    6523            (r_alloc_trt_fsm.read()  == ALLOC_TRT_READ)))
    6524       {
     6913    case ALLOC_DIR_READ:    // allocated to READ FSM
     6914    if( ((r_read_fsm.read()      != READ_DIR_REQ)   and
     6915         (r_read_fsm.read()      != READ_DIR_LOCK)   and
     6916         (r_read_fsm.read()      != READ_TRT_LOCK)   and
     6917         (r_read_fsm.read()      != READ_HEAP_REQ))
     6918         or
     6919         ((r_read_fsm.read()       == READ_TRT_LOCK)   and
     6920          (r_alloc_trt_fsm.read()  == ALLOC_TRT_READ)) )
     6921    {
    65256922        if(r_write_fsm.read() == WRITE_DIR_REQ)
    65266923          r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    … …  
    65346931        else if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    65356932          r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    6536       }
    6537       break;
    6538 
    6539       /////////////////////
    6540     case ALLOC_DIR_WRITE:
    6541       if(((r_write_fsm.read()       != WRITE_DIR_REQ)  &&
    6542           (r_write_fsm.read()       != WRITE_DIR_LOCK)  &&
    6543           (r_write_fsm.read()       != WRITE_DIR_READ)  &&
    6544           (r_write_fsm.read()       != WRITE_DIR_HIT)  &&
    6545           (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  &&
    6546           (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  &&
    6547           (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  &&
    6548           (r_write_fsm.read()       != WRITE_UPT_LOCK)  &&
    6549           (r_write_fsm.read()       != WRITE_UPT_HEAP_LOCK))
    6550           ||
    6551           ((r_write_fsm.read()      == WRITE_UPT_HEAP_LOCK)  &&
    6552            (r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE))
    6553           ||
    6554           ((r_write_fsm.read()      == WRITE_MISS_TRT_LOCK)  &&
    6555            (r_alloc_trt_fsm.read()  == ALLOC_TRT_WRITE)))
    6556       {
     6933
     6934        else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     6935          r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     6936    }
     6937    break;
     6938
     6939    /////////////////////
     6940    case ALLOC_DIR_WRITE:    // allocated to WRITE FSM
     6941    if(((r_write_fsm.read()       != WRITE_DIR_REQ)  and
     6942        (r_write_fsm.read()       != WRITE_DIR_LOCK)  and
     6943        (r_write_fsm.read()       != WRITE_DIR_READ)  and
     6944        (r_write_fsm.read()       != WRITE_DIR_HIT)  and
     6945        (r_write_fsm.read()       != WRITE_BC_TRT_LOCK)  and
     6946        (r_write_fsm.read()       != WRITE_BC_UPT_LOCK)  and
     6947        (r_write_fsm.read()       != WRITE_MISS_TRT_LOCK)  and
     6948        (r_write_fsm.read()       != WRITE_UPT_LOCK)  and
     6949        (r_write_fsm.read()       != WRITE_UPT_HEAP_LOCK))
     6950        or
     6951        ((r_write_fsm.read()      == WRITE_UPT_HEAP_LOCK)  and
     6952         (r_alloc_heap_fsm.read() == ALLOC_HEAP_WRITE))
     6953        or
     6954        ((r_write_fsm.read()      == WRITE_MISS_TRT_LOCK)  and
     6955         (r_alloc_trt_fsm.read()  == ALLOC_TRT_WRITE)))
     6956    {
    65576957        if(r_cas_fsm.read() == CAS_DIR_REQ)
    65586958          r_alloc_dir_fsm = ALLOC_DIR_CAS;
    … …  
    65646964          r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    65656965
     6966        else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     6967          r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     6968
    65666969        else if(r_read_fsm.read() == READ_DIR_REQ)
    65676970          r_alloc_dir_fsm = ALLOC_DIR_READ;
    6568       }
    6569       break;
    6570 
    6571       ////////////////////
    6572     case ALLOC_DIR_CAS:
    6573       if(((r_cas_fsm.read()         != CAS_DIR_REQ)  &&
    6574           (r_cas_fsm.read()         != CAS_DIR_LOCK)  &&
    6575           (r_cas_fsm.read()         != CAS_DIR_HIT_READ)  &&
    6576           (r_cas_fsm.read()         != CAS_DIR_HIT_COMPARE)  &&
    6577           (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  &&
    6578           (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  &&
    6579           (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  &&
    6580           (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  &&
    6581           (r_cas_fsm.read()         != CAS_UPT_LOCK)  &&
    6582           (r_cas_fsm.read()         != CAS_UPT_HEAP_LOCK))
    6583           ||
    6584           ((r_cas_fsm.read()        == CAS_UPT_HEAP_LOCK)  &&
    6585            (r_alloc_heap_fsm.read() == ALLOC_HEAP_CAS))
    6586           ||
    6587           ((r_cas_fsm.read()        == CAS_MISS_TRT_LOCK)  &&
    6588            (r_alloc_trt_fsm.read()  == ALLOC_TRT_CAS)))
    6589       {
     6971    }
     6972    break;
     6973
     6974    ///////////////////
     6975    case ALLOC_DIR_CAS:    // allocated to CAS FSM
     6976    if(((r_cas_fsm.read()         != CAS_DIR_REQ)  and
     6977        (r_cas_fsm.read()         != CAS_DIR_LOCK)  and
     6978        (r_cas_fsm.read()         != CAS_DIR_HIT_READ)  and
     6979        (r_cas_fsm.read()         != CAS_DIR_HIT_COMPARE)  and
     6980        (r_cas_fsm.read()         != CAS_DIR_HIT_WRITE)  and
     6981        (r_cas_fsm.read()         != CAS_BC_TRT_LOCK)  and
     6982        (r_cas_fsm.read()         != CAS_BC_UPT_LOCK)  and
     6983        (r_cas_fsm.read()         != CAS_MISS_TRT_LOCK)  and
     6984        (r_cas_fsm.read()         != CAS_UPT_LOCK)  and
     6985        (r_cas_fsm.read()         != CAS_UPT_HEAP_LOCK))
     6986        or
     6987        ((r_cas_fsm.read()        == CAS_UPT_HEAP_LOCK)  and
     6988         (r_alloc_heap_fsm.read() == ALLOC_HEAP_CAS))
     6989        or
     6990        ((r_cas_fsm.read()        == CAS_MISS_TRT_LOCK)  and
     6991         (r_alloc_trt_fsm.read()  == ALLOC_TRT_CAS)))
     6992    {
    65906993        if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    65916994          r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    … …  
    65946997          r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    65956998
     6999        else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     7000          r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     7001
    65967002        else if(r_read_fsm.read() == READ_DIR_REQ)
    65977003          r_alloc_dir_fsm = ALLOC_DIR_READ;
    … …  
    65997005        else if(r_write_fsm.read() == WRITE_DIR_REQ)
    66007006          r_alloc_dir_fsm = ALLOC_DIR_WRITE;
    6601       }
    6602       break;
    6603 
    6604       ///////////////////////
    6605     case ALLOC_DIR_CLEANUP:
    6606       if((r_cleanup_fsm.read() != CLEANUP_DIR_REQ) &&
    6607           (r_cleanup_fsm.read() != CLEANUP_DIR_LOCK) &&
    6608           (r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) &&
    6609           (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK))
    6610       {
     7007    }
     7008      break;
     7009
     7010    ///////////////////////
     7011    case ALLOC_DIR_CLEANUP:    // allocated to CLEANUP FSM
     7012    if((r_cleanup_fsm.read() != CLEANUP_DIR_REQ) and
     7013        (r_cleanup_fsm.read() != CLEANUP_DIR_LOCK) and
     7014        (r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) and
     7015        (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK))
     7016    {
    66117017        if(r_xram_rsp_fsm.read() == XRAM_RSP_DIR_LOCK)
    66127018          r_alloc_dir_fsm = ALLOC_DIR_XRAM_RSP;
    66137019
     7020        else if(r_config_fsm.read() == CONFIG_DIR_REQ)
     7021          r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     7022
    66147023        else if(r_read_fsm.read() == READ_DIR_REQ)
    66157024          r_alloc_dir_fsm = ALLOC_DIR_READ;
    … …  
    66207029        else if(r_cas_fsm.read() == CAS_DIR_REQ)
    66217030          r_alloc_dir_fsm = ALLOC_DIR_CAS;
    6622       }
    6623       break;
    6624 
    6625       ////////////////////////
    6626     case ALLOC_DIR_XRAM_RSP:
    6627       if((r_xram_rsp_fsm.read() != XRAM_RSP_DIR_LOCK) &&
    6628           (r_xram_rsp_fsm.read() != XRAM_RSP_TRT_COPY) &&
    6629           (r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK))
    6630       {
    6631         if(r_read_fsm.read() == READ_DIR_REQ)
     7031    }
     7032    break;
     7033
     7034    ////////////////////////
     7035    case ALLOC_DIR_XRAM_RSP:    // allocated to XRAM_RSP FSM
     7036    if( (r_xram_rsp_fsm.read() != XRAM_RSP_DIR_LOCK) and
     7037        (r_xram_rsp_fsm.read() != XRAM_RSP_TRT_COPY) and
     7038        (r_xram_rsp_fsm.read() != XRAM_RSP_INVAL_LOCK))
     7039    {
     7040        if(r_config_fsm.read() == CONFIG_DIR_REQ)
     7041          r_alloc_dir_fsm = ALLOC_DIR_CONFIG;
     7042
     7043        else if(r_read_fsm.read() == READ_DIR_REQ)
    66327044          r_alloc_dir_fsm = ALLOC_DIR_READ;
    66337045
    … …  
    66407052        else if(r_cleanup_fsm.read() == CLEANUP_DIR_REQ)
    66417053          r_alloc_dir_fsm = ALLOC_DIR_CLEANUP;
    6642       }
    6643       break;
     7054    }
     7055    break;
    66447056
    66457057  } // end switch alloc_dir_fsm
    … …  
    66607072      if(r_read_fsm.read() != READ_TRT_LOCK)
    66617073      {
    6662         if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) ||
     7074        if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) or
    66637075            (r_write_fsm.read() == WRITE_BC_TRT_LOCK))
    66647076          r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    66657077
    6666         else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) ||
     7078        else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
    66677079                (r_cas_fsm.read() == CAS_BC_TRT_LOCK))
    66687080          r_alloc_trt_fsm = ALLOC_TRT_CAS;
    66697081
    6670         else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) &&
     7082        else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    66717083                (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    66727084          r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    66737085
    6674         else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
     7086        else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    66757087                (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    66767088          r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    … …  
    66807092    /////////////////////
    66817093    case ALLOC_TRT_WRITE:
    6682       if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) &&
    6683           (r_write_fsm.read() != WRITE_BC_TRT_LOCK) &&
     7094      if((r_write_fsm.read() != WRITE_MISS_TRT_LOCK) and
     7095          (r_write_fsm.read() != WRITE_BC_TRT_LOCK) and
    66847096          (r_write_fsm.read() != WRITE_BC_UPT_LOCK))
    66857097      {
    6686         if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) ||
     7098        if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
    66877099            (r_cas_fsm.read() == CAS_BC_TRT_LOCK))
    66887100          r_alloc_trt_fsm = ALLOC_TRT_CAS;
    66897101
    6690         else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) &&
     7102        else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    66917103                (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    66927104          r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    66937105
    6694         else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
     7106        else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    66957107                (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    66967108          r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    … …  
    67037115    ////////////////////
    67047116    case ALLOC_TRT_CAS:
    6705       if((r_cas_fsm.read() != CAS_MISS_TRT_LOCK) &&
    6706           (r_cas_fsm.read() != CAS_BC_TRT_LOCK) &&
     7117      if((r_cas_fsm.read() != CAS_MISS_TRT_LOCK) and
     7118          (r_cas_fsm.read() != CAS_BC_TRT_LOCK) and
    67077119          (r_cas_fsm.read() != CAS_BC_UPT_LOCK))
    67087120      {
    6709         if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) &&
     7121        if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    67107122            (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    67117123          r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    67127124
    6713         else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
     7125        else if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    67147126                (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    67157127          r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    … …  
    67187130          r_alloc_trt_fsm = ALLOC_TRT_READ;
    67197131
    6720         else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) ||
     7132        else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) or
    67217133                (r_write_fsm.read() == WRITE_BC_TRT_LOCK))
    67227134          r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    … …  
    67267138    ////////////////////////
    67277139    case ALLOC_TRT_XRAM_RSP:
    6728       if(((r_xram_rsp_fsm.read()  != XRAM_RSP_DIR_LOCK)  ||
    6729           (r_alloc_dir_fsm.read() != ALLOC_DIR_XRAM_RSP)) &&
    6730           (r_xram_rsp_fsm.read()  != XRAM_RSP_TRT_COPY)  &&
    6731           (r_xram_rsp_fsm.read()  != XRAM_RSP_DIR_UPDT)  &&
     7140      if(((r_xram_rsp_fsm.read()  != XRAM_RSP_DIR_LOCK)  or
     7141          (r_alloc_dir_fsm.read() != ALLOC_DIR_XRAM_RSP)) and
     7142          (r_xram_rsp_fsm.read()  != XRAM_RSP_TRT_COPY)  and
     7143          (r_xram_rsp_fsm.read()  != XRAM_RSP_DIR_UPDT)  and
    67327144          (r_xram_rsp_fsm.read()  != XRAM_RSP_INVAL_LOCK))
    67337145      {
    6734         if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) ||
     7146        if((r_ixr_rsp_fsm.read() == IXR_RSP_TRT_ERASE) or
    67357147            (r_ixr_rsp_fsm.read() == IXR_RSP_TRT_READ))
    67367148          r_alloc_trt_fsm = ALLOC_TRT_IXR_RSP;
    … …  
    67397151          r_alloc_trt_fsm = ALLOC_TRT_READ;
    67407152
    6741         else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) ||
     7153        else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) or
    67427154                (r_write_fsm.read() == WRITE_BC_TRT_LOCK))
    67437155          r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    67447156
    6745         else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) ||
     7157        else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
    67467158                (r_cas_fsm.read() == CAS_BC_TRT_LOCK))
    67477159          r_alloc_trt_fsm = ALLOC_TRT_CAS;
    … …  
    67517163    ////////////////////////
    67527164    case ALLOC_TRT_IXR_RSP:
    6753       if((r_ixr_rsp_fsm.read() != IXR_RSP_TRT_ERASE) &&
     7165      if((r_ixr_rsp_fsm.read() != IXR_RSP_TRT_ERASE) and
    67547166          (r_ixr_rsp_fsm.read() != IXR_RSP_TRT_READ))
    67557167      {
    … …  
    67577169          r_alloc_trt_fsm = ALLOC_TRT_READ;
    67587170
    6759         else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) ||
     7171        else if((r_write_fsm.read() == WRITE_MISS_TRT_LOCK) or
    67607172                (r_write_fsm.read() == WRITE_BC_TRT_LOCK))
    67617173          r_alloc_trt_fsm = ALLOC_TRT_WRITE;
    67627174
    6763         else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) ||
     7175        else if((r_cas_fsm.read() == CAS_MISS_TRT_LOCK) or
    67647176                (r_cas_fsm.read() == CAS_BC_TRT_LOCK))
    67657177          r_alloc_trt_fsm = ALLOC_TRT_CAS;
    67667178
    6767         else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) &&
     7179        else if((r_xram_rsp_fsm.read()  == XRAM_RSP_DIR_LOCK) and
    67687180                (r_alloc_dir_fsm.read() == ALLOC_DIR_XRAM_RSP))
    67697181          r_alloc_trt_fsm = ALLOC_TRT_XRAM_RSP;
    … …  
    68007212      ////////////////////
    68017213    case ALLOC_HEAP_READ:
    6802       if((r_read_fsm.read() != READ_HEAP_REQ) &&
    6803           (r_read_fsm.read() != READ_HEAP_LOCK) &&
     7214      if((r_read_fsm.read() != READ_HEAP_REQ) and
     7215          (r_read_fsm.read() != READ_HEAP_LOCK) and
    68047216          (r_read_fsm.read() != READ_HEAP_ERASE))
    68057217      {
    … …  
    68207232      /////////////////////
    68217233    case ALLOC_HEAP_WRITE:
    6822       if((r_write_fsm.read() != WRITE_UPT_HEAP_LOCK) &&
    6823           (r_write_fsm.read() != WRITE_UPT_REQ) &&
     7234      if((r_write_fsm.read() != WRITE_UPT_HEAP_LOCK) and
     7235          (r_write_fsm.read() != WRITE_UPT_REQ) and
    68247236          (r_write_fsm.read() != WRITE_UPT_NEXT))
    68257237      {
    … …  
    68407252      ////////////////////
    68417253    case ALLOC_HEAP_CAS:
    6842       if((r_cas_fsm.read() != CAS_UPT_HEAP_LOCK) &&
    6843           (r_cas_fsm.read() != CAS_UPT_REQ) &&
     7254      if((r_cas_fsm.read() != CAS_UPT_HEAP_LOCK) and
     7255          (r_cas_fsm.read() != CAS_UPT_REQ) and
    68447256          (r_cas_fsm.read() != CAS_UPT_NEXT))
    68457257      {
    … …  
    68607272      ///////////////////////
    68617273    case ALLOC_HEAP_CLEANUP:
    6862       if((r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) &&
    6863           (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK) &&
    6864           (r_cleanup_fsm.read() != CLEANUP_HEAP_SEARCH) &&
     7274      if((r_cleanup_fsm.read() != CLEANUP_HEAP_REQ) and
     7275          (r_cleanup_fsm.read() != CLEANUP_HEAP_LOCK) and
     7276          (r_cleanup_fsm.read() != CLEANUP_HEAP_SEARCH) and
    68657277          (r_cleanup_fsm.read() != CLEANUP_HEAP_CLEAN))
    68667278      {
    … …  
    68817293      ////////////////////////
    68827294    case ALLOC_HEAP_XRAM_RSP:
    6883       if((r_xram_rsp_fsm.read() != XRAM_RSP_HEAP_REQ) &&
     7295      if((r_xram_rsp_fsm.read() != XRAM_RSP_HEAP_REQ) and
    68847296          (r_xram_rsp_fsm.read() != XRAM_RSP_HEAP_ERASE))
    68857297      {
    … …  
    69017313  } // end switch alloc_heap_fsm
    69027314
    6903 
    6904   ////////////////////////////////////////////////////////////////////////////////////
     7315  /////////////////////////////////////////////////////////////////////
    69057316  //    TGT_CMD to READ FIFO
    6906   ////////////////////////////////////////////////////////////////////////////////////
    6907 
    6908   if(cmd_read_fifo_put)
    6909   {
    6910     if(cmd_read_fifo_get)
    6911     {
    6912       m_cmd_read_addr_fifo.put_and_get((addr_t)(p_vci_tgt.address.read()));
    6913       m_cmd_read_length_fifo.put_and_get(p_vci_tgt.plen.read() >>2);
    6914       m_cmd_read_srcid_fifo.put_and_get(p_vci_tgt.srcid.read());
    6915       m_cmd_read_trdid_fifo.put_and_get(p_vci_tgt.trdid.read());
    6916       m_cmd_read_pktid_fifo.put_and_get(p_vci_tgt.pktid.read());
    6917     }
    6918     else
    6919     {
    6920       m_cmd_read_addr_fifo.simple_put((addr_t)(p_vci_tgt.address.read()));
    6921       m_cmd_read_length_fifo.simple_put(p_vci_tgt.plen.read() >>2);
    6922       m_cmd_read_srcid_fifo.simple_put(p_vci_tgt.srcid.read());
    6923       m_cmd_read_trdid_fifo.simple_put(p_vci_tgt.trdid.read());
    6924       m_cmd_read_pktid_fifo.simple_put(p_vci_tgt.pktid.read());
    6925     }
    6926   }
    6927   else
    6928   {
    6929     if(cmd_read_fifo_get)
    6930     {
    6931       m_cmd_read_addr_fifo.simple_get();
    6932       m_cmd_read_length_fifo.simple_get();
    6933       m_cmd_read_srcid_fifo.simple_get();
    6934       m_cmd_read_trdid_fifo.simple_get();
    6935       m_cmd_read_pktid_fifo.simple_get();
    6936     }
    6937   }
     7317  /////////////////////////////////////////////////////////////////////
     7318
     7319  m_cmd_read_addr_fifo.update(   cmd_read_fifo_get, cmd_read_fifo_put,
     7320                                 p_vci_tgt.address.read() );
     7321  m_cmd_read_length_fifo.update( cmd_read_fifo_get, cmd_read_fifo_put,
     7322                                 p_vci_tgt.plen.read()>>2 );
     7323  m_cmd_read_srcid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
     7324                                 p_vci_tgt.srcid.read() );
     7325  m_cmd_read_trdid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
     7326                                 p_vci_tgt.trdid.read() );
     7327  m_cmd_read_pktid_fifo.update(  cmd_read_fifo_get, cmd_read_fifo_put,
     7328                                 p_vci_tgt.pktid.read() );
     7329
    69387330  /////////////////////////////////////////////////////////////////////
    69397331  //    TGT_CMD to WRITE FIFO
    … …  
    72647656  ////////////////////////////////////////////////////
    72657657
    7266   if(((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) &&
    7267       (r_ixr_rsp_fsm.read()   == IXR_RSP_TRT_READ)) ||
     7658  if(((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and
     7659      (r_ixr_rsp_fsm.read()   == IXR_RSP_TRT_READ)) or
    72687660      (r_ixr_rsp_fsm.read()   == IXR_RSP_ACK))
    72697661
    … …  
    73337725      p_vci_tgt.rtrdid  = r_tgt_cmd_to_tgt_rsp_trdid.read();
    73347726      p_vci_tgt.rpktid  = r_tgt_cmd_to_tgt_rsp_pktid.read();
    7335       p_vci_tgt.rerror  = 0x1;
     7727      p_vci_tgt.rerror  = r_tgt_cmd_to_tgt_rsp_error.read();
    73367728      p_vci_tgt.reop    = true;
    73377729
    … …  
    73687760    case TGT_RSP_WRITE:
    73697761      p_vci_tgt.rspval   = true;
    7370       if(((r_write_to_tgt_rsp_pktid.read() & 0x7) == TYPE_SC) && r_write_to_tgt_rsp_sc_fail.read())
     7762      if(((r_write_to_tgt_rsp_pktid.read() & 0x7) == TYPE_SC) and r_write_to_tgt_rsp_sc_fail.read())
    73717763        p_vci_tgt.rdata  = 1;
    73727764      else
Note: See TracChangeset for help on using the changeset viewer.