Ignore:
Timestamp:
Aug 22, 2013, 6:45:38 PM (9 years ago)
Author:
haoliu
Message:

This version for RWT has merged with the lastest version of classic tsar.
It pass the test with giet_vm.

Location:
branches/RWT/modules/vci_cc_vcache_wrapper/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r477 r495  
    179179        CC_RECEIVE_INS_UPDT_HEADER,
    180180        CC_RECEIVE_INS_UPDT_NLINE,
    181         CC_RECEIVE_INS_UPDT_DATA,
    182181        CC_RECEIVE_DATA_INVAL_HEADER,
    183182        CC_RECEIVE_DATA_INVAL_NLINE,
    184183        CC_RECEIVE_DATA_UPDT_HEADER,
    185184        CC_RECEIVE_DATA_UPDT_NLINE,
     185        CC_RECEIVE_INS_UPDT_DATA,
    186186        CC_RECEIVE_DATA_UPDT_DATA,
    187187    };
     
    403403    sc_signal<bool>         r_icache_tlb_rsp_error;      // tlb miss response error
    404404
     405    // Filp-Flop in ICACHE FSM for saving the cleanup victim request
     406    sc_signal<bool>         r_icache_cleanup_victim_req;
     407    sc_signal<paddr_t>      r_icache_cleanup_victim_nline;
     408
    405409    // communication between ICACHE FSM and CC_SEND FSM
    406410    sc_signal<bool>         r_icache_cc_send_req;           // ICACHE cc_send request
     
    504508    sc_signal<bool>         r_dcache_xtn_req;           // xtn request (caused by processor)
    505509    sc_signal<int>          r_dcache_xtn_opcode;        // xtn request type
     510
     511    // Filp-Flop in DCACHE FSM for saving the cleanup victim request
     512    sc_signal<bool>         r_dcache_cleanup_victim_req;
     513    sc_signal<bool>         r_dcache_cleanup_victim_line_ncc;
     514    sc_signal<bool>         r_dcache_cleanup_victim_updt_data;
     515    sc_signal<paddr_t>      r_dcache_cleanup_victim_nline;
    506516
    507517    // communication between DCACHE FSM and CC_SEND FSM
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r477 r495  
    354354      r_dcache_xtn_req("r_dcache_xtn_req"),
    355355      r_dcache_xtn_opcode("r_dcache_xtn_opcode"),
    356 
     356 
     357      r_dcache_cleanup_victim_req("r_dcache_cleanup_victim_req"),
     358      r_dcache_cleanup_victim_nline("r_dcache_cleanup_victim_nline"),
     359 
    357360      r_dcache_cc_send_req("r_dcache_cc_send_req"),
    358361      r_dcache_cc_send_type("r_dcache_cc_send_type"),
     
    374377      r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2),        // 2 words depth
    375378      r_vci_rsp_fifo_rpktid("r_vci_rsp_fifo_rpktid", 2),    // 2 words depth
    376       r_cc_send_data_fifo("r_cc_send_data_fifo", 2),
     379      r_cc_send_data_fifo("r_cc_send_data_fifo", 16),
    377380
    378381      r_cc_send_fsm("r_cc_send_fsm"),
     
    815818        // No request from DCACHE FSM to CC_SEND FSM
    816819        r_dcache_cc_send_req       = false;
    817 
    818820        r_dcache_clack_req         = false;
    819821
     
    852854        r_dcache_miss_data_cpt = 0;
    853855        r_dcache_miss_data_addr = 0;
     856
     857        r_dcache_cleanup_victim_req = false;
     858        r_dcache_cleanup_victim_line_ncc = false;
     859        r_dcache_cleanup_victim_updt_data = false;
    854860
    855861        // activity counters
     
    10931099
    10941100        // coherence interrupt
    1095         if ( r_cc_receive_icache_req.read() )
     1101        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    10961102        {
    10971103            r_icache_fsm = ICACHE_CC_CHECK;
     
    13291335
    13301336        // coherence interrupt
    1331         if ( r_cc_receive_icache_req.read() )
     1337        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    13321338        {
    13331339            r_icache_fsm = ICACHE_CC_CHECK;
     
    13811387
    13821388        // coherence request (from CC_RECEIVE FSM)
    1383         if ( r_cc_receive_icache_req.read() )
     1389        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    13841390        {
    13851391            r_icache_fsm = ICACHE_CC_CHECK;
     
    15881594
    15891595        // coherence interrupt
    1590         if ( r_cc_receive_icache_req.read() )
     1596        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    15911597        {
    15921598            r_icache_fsm = ICACHE_CC_CHECK;
     
    16851691
    16861692        // coherence interrupt
    1687         if ( r_cc_receive_icache_req.read() )
     1693        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    16881694        {
    16891695            r_icache_fsm = ICACHE_CC_CHECK;
     
    17641770
    17651771        // coherence interrupt
    1766         if ( r_cc_receive_icache_req.read() )
     1772        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    17671773        {
    17681774            r_icache_fsm = ICACHE_CC_CHECK;
     
    18431849
    18441850        // coherence interrupt
    1845         if ( r_cc_receive_icache_req.read() )
     1851        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read())
    18461852        {
    18471853            r_icache_fsm = ICACHE_CC_CHECK;
     
    18821888        paddr_t  mask  = ~((m_icache_words<<2)-1);
    18831889
     1890        // CLACK handler
     1891        // We switch the directory slot to EMPTY state
     1892        // and reset r_icache_miss_clack if the cleanup ack
     1893        // is matching a pending miss.
     1894        if ( r_icache_clack_req.read() )
     1895        {
     1896
     1897            if ( m_ireq.valid ) m_cost_ins_miss_frz++;
     1898
     1899#ifdef INSTRUMENTATION
     1900m_cpt_icache_dir_write++;
     1901#endif
     1902            r_icache.write_dir( 0,
     1903                                r_icache_clack_way.read(),
     1904                                r_icache_clack_set.read(),
     1905                                CACHE_SLOT_STATE_EMPTY);
     1906
     1907            if ( (r_icache_miss_set.read() == r_icache_clack_set.read()) and
     1908                 (r_icache_miss_way.read() == r_icache_clack_way.read()) )
     1909            {
     1910                r_icache_miss_clack = false;
     1911            }
     1912
     1913            r_icache_clack_req = false;
     1914
     1915            // return to cc_save state
     1916            r_icache_fsm = r_icache_fsm_save.read();
     1917
     1918#if DEBUG_ICACHE
     1919if ( m_debug_activated )
     1920{
     1921    std::cout << "  <PROC " << name()
     1922        << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
     1923        << " set = " << r_icache_clack_set.read()
     1924        << " / way = " << r_icache_clack_way.read() << std::endl;
     1925}
     1926#endif
     1927
     1928            break;
     1929        }
    18841930
    18851931        // Match between MISS address and CC address
     
    19211967        }
    19221968
    1923         // CLACK handler
    1924         // We switch the directory slot to EMPTY state
    1925         // and reset r_icache_miss_clack if the cleanup ack
    1926         // is matching a pending miss.
    1927         if ( r_icache_clack_req.read() )
    1928         {
    1929 
    1930             if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    1931 
    1932 #ifdef INSTRUMENTATION
    1933 m_cpt_icache_dir_write++;
    1934 #endif
    1935             r_icache.write_dir( 0,
    1936                                 r_icache_clack_way.read(),
    1937                                 r_icache_clack_set.read(),
    1938                                 CACHE_SLOT_STATE_EMPTY);
    1939 
    1940             if ( (r_icache_miss_set.read() == r_icache_clack_set.read()) and
    1941                  (r_icache_miss_way.read() == r_icache_clack_way.read()) )
    1942             {
    1943                 r_icache_miss_clack = false;
    1944             }
    1945 
    1946             r_icache_clack_req = false;
    1947 
    1948             // return to cc_save state if no pending CC request
    1949             if ( not r_cc_receive_icache_req.read() )
    1950                 r_icache_fsm = r_icache_fsm_save.read();
    1951 
    1952 #if DEBUG_ICACHE
    1953 if ( m_debug_activated )
    1954 {
    1955     std::cout << "  <PROC " << name()
    1956         << " ICACHE_CC_CHECK>  CC_TYPE_CLACK slot returns to empty state"
    1957         << " set = " << r_icache_clack_set.read()
    1958         << " / way = " << r_icache_clack_way.read() << std::endl;
    1959 }
    1960 #endif
    1961 
    1962             break;
    1963         }
    1964 
    1965         // wait if pending request to CC_SEND. This way if there are pending
    1966         // CLACK they can be treated in this state and then a deadlock
    1967         // situation is avoided
    1968         if ( r_icache_cc_send_req.read() ) break;
     1969        assert ( not r_icache_cc_send_req.read() and "CC_SEND must be available in ICACHE_CC_CHECK");
    19691970
    19701971        // CC request handler
     
    24182419        }
    24192420        // coherence request (from CC_RECEIVE FSM)
    2420         else if ( r_cc_receive_dcache_req.read() )
     2421        else if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    24212422        {
    24222423            r_dcache_fsm = DCACHE_CC_CHECK;
     
    30573058
    30583059        // coherence request (from CC_RECEIVE FSM)
    3059         if ( r_cc_receive_dcache_req.read() )
     3060        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    30603061        {
    30613062            r_dcache_fsm = DCACHE_CC_CHECK;
     
    33693370
    33703371        // coherence request (from CC_RECEIVE FSM)
    3371         if ( r_cc_receive_dcache_req.read() )
     3372        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    33723373        {
    33733374            r_dcache_fsm = DCACHE_CC_CHECK;
     
    37373738
    37383739        // coherence request (from CC_RECEIVE FSM)
    3739         if ( r_cc_receive_dcache_req.read() )
     3740        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    37403741        {
    37413742            r_dcache_fsm = DCACHE_CC_CHECK;
     
    38163817
    38173818        // coherence request (from CC_RECEIVE FSM)
    3818         if ( r_cc_receive_dcache_req.read() )
     3819        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38193820        {
    38203821            r_dcache_fsm = DCACHE_CC_CHECK;
     
    38463847
    38473848        // coherence request (from CC_RECEIVE FSM)
    3848         if ( r_cc_receive_dcache_req.read() )
     3849        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38493850        {
    38503851            r_dcache_fsm = DCACHE_CC_CHECK;
     
    38893890
    38903891        // coherence request (from CC_RECEIVE FSM)
    3891         if ( r_cc_receive_dcache_req.read() )
     3892        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    38923893        {
    38933894            r_dcache_fsm = DCACHE_CC_CHECK;
     
    39803981        size_t   set;
    39813982        size_t   word;
     3983
    39823984        r_dcache.read_neutral(r_dcache_xtn_flush_addr_data.read(),
    39833985                              &rdata,
     
    39994001            }
    40004002        }
     4003//       else if ( r_dcache_clack_req.read() )
     4004//       {
     4005//           r_dcache_fsm = DCACHE_CC_CHECK;
     4006//           r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4007//           break;
     4008//       }
    40014009        break;
    40024010    }
     
    43114319
    43124320        // coherence request (from CC_RECEIVE FSM)
    4313         if ( r_cc_receive_dcache_req.read() )
     4321        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    43144322        {
    43154323            r_dcache_fsm = DCACHE_CC_CHECK;
     
    43184326        }
    43194327
    4320         if ( not r_dcache_cc_send_req.read() ) // blocked until previous cc_send request is sent
    4321         {
    43224328            bool     found = false;
    43234329            bool     cleanup = false;
     
    43264332            paddr_t  victim = 0;
    43274333            int state;
     4334            bool     s_cleanup_updt_data = false;
     4335            bool     s_cleanup_line_ncc = false;
    43284336
    43294337#ifdef INSTRUMENTATION
     
    43474355                    r_dcache_miss_clack   = true;
    43484356                    r_dcache_fsm          = DCACHE_MISS_CLEAN;
    4349                     // request cleanup
    4350                     r_dcache_cc_send_req   = true;
    4351                     r_dcache_cc_send_nline = victim;
    4352                     r_dcache_cc_send_way   = way;
    4353                     r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
    43544357                    if( (state == CACHE_SLOT_STATE_VALID_NCC) )//and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_DIRTY) )
    43554358                    {
    43564359                        //MODIFIER POUR DIRTY BIT //
    4357                         r_dcache_cc_cleanup_line_ncc = true;
     4360                        s_cleanup_line_ncc = true;
    43584361                        r_dcache_miss_data_addr = (victim*m_dcache_words)*4;
    43594362                        //if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY))//must send data
    43604363                        if (true)//must send data
    43614364                        {
    4362                             r_dcache_cc_cleanup_updt_data = true;
     4365                            s_cleanup_updt_data = true;
    43634366                            for (size_t w = 0; w< m_dcache_words; w++)
    43644367                            {
     
    43694372                        else
    43704373                        {
    4371                             r_dcache_cc_cleanup_updt_data = false;
     4374                            s_cleanup_updt_data = false;
    43724375                        }
    43734376
     
    43784381                    else
    43794382                    {
    4380                         r_dcache_cc_cleanup_line_ncc  = false;
    4381                         r_dcache_cc_cleanup_updt_data = false;
     4383                        s_cleanup_line_ncc  = false;
     4384                        s_cleanup_updt_data = false;
     4385                    }
     4386
     4387                    if( not r_dcache_cc_send_req.read() )
     4388                    {
     4389                        // request cleanup
     4390                        r_dcache_cc_send_req   = true;
     4391                        r_dcache_cc_send_nline = victim;
     4392                        r_dcache_cc_send_way   = way;
     4393                        r_dcache_cc_send_type  = CC_TYPE_CLEANUP;
     4394                        r_dcache_cc_cleanup_updt_data = s_cleanup_updt_data;
     4395                        r_dcache_cc_cleanup_line_ncc  = s_cleanup_line_ncc;
     4396                    }
     4397                    else
     4398                    {
     4399                        r_dcache_cleanup_victim_nline = victim;
     4400                        r_dcache_cleanup_victim_req = true;
     4401                        r_dcache_cleanup_victim_updt_data = s_cleanup_updt_data;
     4402                        r_dcache_cleanup_victim_line_ncc = s_cleanup_line_ncc;
     4403                        std::cout << "  <PROC " << name()
     4404                                  << "/ CYCLE = "
     4405                                  << m_cpt_total_cycles
     4406                                  << std :: endl;
    43824407                    }
    43834408                }
     
    44004425#endif
    44014426            } // end found
    4402         }
    44034427        break;
    44044428    }
     
    44104434        size_t set;
    44114435        size_t word;
     4436
     4437        if( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
     4438        {
     4439            r_dcache_cc_send_req = true;
     4440            r_dcache_cc_send_type = CC_TYPE_CLEANUP;
     4441            r_dcache_cc_send_nline = r_dcache_cleanup_victim_nline.read();
     4442            r_dcache_cleanup_victim_req = false;
     4443            r_dcache_cc_cleanup_updt_data = r_dcache_cleanup_victim_updt_data.read();
     4444            r_dcache_cc_cleanup_line_ncc = r_dcache_cleanup_victim_line_ncc.read();
     4445            r_dcache_cc_send_way = r_dcache_miss_way;
     4446        }
    44124447
    44134448        r_dcache.read_neutral(r_dcache_miss_data_addr,
     
    44304465            }
    44314466        }
     4467//       else if ( r_dcache_clack_req.read() )
     4468//       {
     4469//           r_dcache_fsm = DCACHE_CC_CHECK;
     4470//           r_dcache_fsm_cc_save = r_dcache_fsm.read();
     4471//           break;
     4472//       }
     4473
    44324474        break;
    44334475    }
     
    44954537    {
    44964538        if ( m_dreq.valid) m_cost_data_miss_frz++;
     4539
     4540        if( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
     4541        {
     4542            r_dcache_cc_send_req = true;
     4543            r_dcache_cc_send_type = CC_TYPE_CLEANUP;
     4544            r_dcache_cc_send_nline = r_dcache_cleanup_victim_nline.read();
     4545            r_dcache_cleanup_victim_req = false;
     4546            r_dcache_cc_cleanup_updt_data = r_dcache_cleanup_victim_updt_data.read();
     4547            r_dcache_cc_cleanup_line_ncc = r_dcache_cleanup_victim_line_ncc.read();
     4548            r_dcache_cc_send_way = r_dcache_miss_way;
     4549        }
     4550
    44974551        // coherence clack request (from DSPIN CLACK)
    44984552        if ( r_dcache_clack_req.read() )
     
    45044558
    45054559        // coherence request (from CC_RECEIVE FSM)
    4506         if ( r_cc_receive_dcache_req.read() )
     4560        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() and not r_dcache_cleanup_victim_req.read() )
    45074561        {
    45084562            r_dcache_fsm = DCACHE_CC_CHECK;
     
    46234677        if ( m_dreq.valid) m_cost_data_miss_frz++;
    46244678
     4679        if( r_dcache_cleanup_victim_req.read() and not r_dcache_cc_send_req.read() )
     4680        {
     4681            r_dcache_cc_send_req = true;
     4682            r_dcache_cc_send_type = CC_TYPE_CLEANUP;
     4683            r_dcache_cc_send_nline = r_dcache_cleanup_victim_nline.read();
     4684            r_dcache_cleanup_victim_req = false;
     4685            r_dcache_cc_cleanup_updt_data = r_dcache_cleanup_victim_updt_data.read();
     4686            r_dcache_cc_cleanup_line_ncc = r_dcache_cleanup_victim_line_ncc.read();
     4687            r_dcache_cc_send_way = r_dcache_miss_way;
     4688        }
     4689
    46254690        // coherence clack request (from DSPIN CLACK)
    46264691        if ( r_dcache_clack_req.read() )
     
    46324697
    46334698        // coherence request (from CC_RECEIVE FSM)
    4634         if ( r_cc_receive_dcache_req.read() )
     4699        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read() and not r_dcache_cleanup_victim_req.read() )
    46354700        {
    46364701            r_dcache_fsm = DCACHE_CC_CHECK;
     
    47364801
    47374802        // coherence request (from CC_RECEIVE FSM)
    4738         if ( r_cc_receive_dcache_req.read() )
     4803        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    47394804        {
    47404805            r_dcache_fsm = DCACHE_CC_CHECK;
     
    47814846
    47824847        // coherence request (from CC_RECEIVE FSM)
    4783         if ( r_cc_receive_dcache_req.read() )
     4848        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    47844849        {
    47854850            r_dcache_fsm = DCACHE_CC_CHECK;
     
    48354900
    48364901        // coherence request (from CC_RECEIVE FSM)
    4837         if ( r_cc_receive_dcache_req.read() )
     4902        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    48384903        {
    48394904            r_dcache_fsm = DCACHE_CC_CHECK;
     
    49545019
    49555020        // coherence request (from CC_RECEIVE FSM)
    4956         if ( r_cc_receive_dcache_req.read() )
     5021        if ( r_cc_receive_dcache_req.read() and not r_dcache_cc_send_req.read())
    49575022        {
    49585023            r_dcache_fsm = DCACHE_CC_CHECK;
     
    50455110}
    50465111#endif
     5112        // CLACK handler
     5113        // We switch the directory slot to EMPTY state and reset
     5114        // r_dcache_miss_clack if the cleanup ack is matching a pending miss.
     5115        if ( r_dcache_clack_req.read() )
     5116        {
     5117            if ( m_dreq.valid ) m_cost_data_miss_frz++;
     5118
     5119#ifdef INSTRUMENTATION
     5120m_cpt_dcache_dir_write++;
     5121#endif
     5122            r_dcache.write_dir( 0,
     5123                                r_dcache_clack_way.read(),
     5124                                r_dcache_clack_set.read(),
     5125                                CACHE_SLOT_STATE_EMPTY);
     5126
     5127            if ( (r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
     5128                 (r_dcache_miss_way.read() == r_dcache_clack_way.read()) )
     5129            {
     5130                  r_dcache_miss_clack = false;
     5131            }
     5132
     5133            r_dcache_clack_req = false;
     5134
     5135            // return to cc_save state
     5136            r_dcache_fsm = r_dcache_fsm_cc_save.read() ;
     5137
     5138#if DEBUG_DCACHE
     5139if ( m_debug_activated )
     5140{
     5141    std::cout << "  <PROC " << name()
     5142              << " DCACHE_CC_CHECK> CC_TYPE_CLACK Switch slot to EMPTY state"
     5143              << " set = " << r_dcache_clack_set.read()
     5144              << " / way = " << r_dcache_clack_way.read() << std::endl;
     5145}
     5146#endif
     5147            break;
     5148        }
    50475149
    50485150       
     
    50865188        }
    50875189
    5088         // CLACK handler
    5089         // We switch the directory slot to EMPTY state and reset
    5090         // r_dcache_miss_clack if the cleanup ack is matching a pending miss.
    5091         if ( r_dcache_clack_req.read() )
    5092         {
    5093             if ( m_dreq.valid ) m_cost_data_miss_frz++;
    5094 
    5095 #ifdef INSTRUMENTATION
    5096 m_cpt_dcache_dir_write++;
    5097 #endif
    5098             r_dcache.write_dir( 0,
    5099                                 r_dcache_clack_way.read(),
    5100                                 r_dcache_clack_set.read(),
    5101                                 CACHE_SLOT_STATE_EMPTY);
    5102 
    5103             if ( (r_dcache_miss_set.read() == r_dcache_clack_set.read()) and
    5104                  (r_dcache_miss_way.read() == r_dcache_clack_way.read()) )
    5105             {
    5106                   r_dcache_miss_clack = false;
    5107             }
    5108 
    5109             r_dcache_clack_req = false;
    5110 
    5111             // return to cc_save state if no pending CC request
    5112             if ( not r_cc_receive_dcache_req.read() )
    5113             {
    5114                 r_dcache_fsm = r_dcache_fsm_cc_save.read() ;
    5115             }
    5116 
    5117 #if DEBUG_DCACHE
    5118 if ( m_debug_activated )
    5119 {
    5120     std::cout << "  <PROC " << name()
    5121               << " DCACHE_CC_CHECK> CC_TYPE_CLACK Switch slot to EMPTY state"
    5122               << " set = " << r_dcache_clack_set.read()
    5123               << " / way = " << r_dcache_clack_way.read() << std::endl;
    5124 }
    5125 #endif
    5126             break;
    5127         }
    5128 
    5129         // wait if pending request to CC_SEND. This way if there are pending
    5130         // CLACK they can be treated in this state and then a deadlock
    5131         // situation is avoided
    5132         if ( r_dcache_cc_send_req.read() ) break;
     5190
     5191        assert ( not r_dcache_cc_send_req.read() and "CC_SEND must be available in DCACHE_CC_CHECK" );
    51335192
    51345193        // CC request handler
     
    59436002            if (p_vci.rspval.read())
    59446003            {
     6004                /**/
     6005                if( p_vci.reop.read() ==0)
     6006                {
     6007                    std::cout << "PROC " << m_srcid
     6008                              << "/ CYCLE " << m_cpt_total_cycles
     6009                              <<std::endl;
     6010                }
    59456011                assert( p_vci.reop.read() and
    59466012                "a VCI response packet must contain one flit for a write transaction");
     
    61536219            // flip_flop to check that ?
    61546220            if (not (r_cc_receive_icache_req.read()) and
    6155                 not (r_cc_receive_dcache_req.read()) and 
     6221                not (r_cc_receive_dcache_req.read()) and
    61566222                (p_dspin_m2p.write.read()))
    61576223            {
     
    61936259            uint64_t receive_data = p_dspin_m2p.data.read();
    61946260            // for data INVAL, wait for dcache to take the request
    6195             if (p_dspin_m2p.write.read() and not r_cc_receive_dcache_req.read())
     6261            if (p_dspin_m2p.write.read()           and
     6262                not r_cc_receive_dcache_req.read() )
    61966263            {
    61976264                // request dcache to handle the INVAL
     
    62116278            uint64_t receive_data = p_dspin_m2p.data.read();
    62126279            // for ins INVAL, wait for icache to take the request
    6213             if (p_dspin_m2p.write.read() and not r_cc_receive_icache_req.read())
     6280            if (p_dspin_m2p.write.read()           and
     6281                not r_cc_receive_icache_req.read() )
    62146282            {
    62156283                // request icache to handle the INVAL
     
    62616329            // for data INVAL, wait for dcache to take the request and fifo to
    62626330            // be empty
    6263             if ( r_cc_receive_updt_fifo_be.empty() and 
     6331            if ( r_cc_receive_updt_fifo_be.empty() and
    62646332                 p_dspin_m2p.write.read() )
    62656333            {
     
    62816349            // for ins INVAL, wait for icache to take the request and fifo to be
    62826350            // empty
    6283             if ( r_cc_receive_updt_fifo_be.empty() and 
     6351            if ( r_cc_receive_updt_fifo_be.empty() and
    62846352                 p_dspin_m2p.write.read() )
    62856353            {
Note: See TracChangeset for help on using the changeset viewer.