Ignore:
Timestamp:
Oct 17, 2013, 8:50:46 PM (11 years ago)
Author:
alain
Message:

Compliance with mapping_table defined in release 2462
Introducing the dspin_router_tsar component used in tsar_generic_iob
platform to implement the RAM networt (between L2 & L3).

Location:
trunk/modules/vci_mem_cache/caba/source
Files:
3 edited

Legend:

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

    r535 r549  
    516516
    517517      void print_stats(bool activity_counters, bool stats);
    518       void print_trace();
     518      void print_trace( size_t detailed = 0 );
    519519      void cache_monitor(addr_t addr);
    520520      void start_monitor(addr_t addr, addr_t length);
  • trunk/modules/vci_mem_cache/caba/source/include/xram_transaction.h

    r489 r549  
    2929    bool                        proc_read;          // read request from processor
    3030    size_t                  read_length;    // length of the read (for the response)
    31     size_t                  word_index;         // index of the first read word (for the response)
     31    size_t                  word_index;         // index of the first read word (for response)
    3232    std::vector<data_t> wdata;          // write buffer (one cache line)
    3333    std::vector<be_t>   wdata_be;       // be for each data in the write buffer
     
    4848    /////////////////////////////////////////////////////////////////////
    4949    // The alloc() function initializes the vectors of an entry
    50     // Its arguments are :
    51     // - n_words : number of words per line in the cache
     50    // The "n_words" argument is the number of words in a cache line.
    5251    /////////////////////////////////////////////////////////////////////
    5352    void alloc(size_t n_words)
     
    6463    ////////////////////////////////////////////////////////////////////
    6564    // The copy() function copies an existing entry
    66     // Its arguments are :
    67     // - source : the transaction tab entry to copy
    6865    ////////////////////////////////////////////////////////////////////
    6966    void copy(const TransactionTabEntry &source)
     
    8683
    8784    ////////////////////////////////////////////////////////////////////
    88     // The print() function prints the entry
    89     ////////////////////////////////////////////////////////////////////
    90     void print()
    91     {
    92         std::cout << "------- TRT entry -------" << std::endl;
    93         std::cout << "valid       = " << valid        << std::endl;
    94         std::cout << "xram_read   = " << xram_read    << std::endl;
    95         std::cout << "nline       = " << std::hex << nline << std::endl;
    96         std::cout << "srcid       = " << srcid        << std::endl;
    97         std::cout << "trdid       = " << trdid        << std::endl;
    98         std::cout << "pktid       = " << pktid        << std::endl;
    99         std::cout << "proc_read   = " << proc_read    << std::endl;
    100         std::cout << "read_length = " << read_length  << std::endl;
    101         std::cout << "word_index  = " << word_index   << std::endl;
    102         for(size_t i=0; i<wdata_be.size() ; i++)
    103         {
    104             std::cout << "wdata_be[" << std::dec << i << "] = "
    105                       << std::hex << wdata_be[i] << std::endl;
    106         }
    107         for(size_t i=0; i<wdata.size() ; i++)
    108         {
    109             std::cout << "wdata[" << std::dec << i << "] = "
    110                       << std::hex << wdata[i] << std::endl;
    111         }
    112         std::cout << "rerror      = " << rerror       << std::endl;
    113         std::cout << "ll_key      = " << ll_key       << std::endl;
    114         std::cout << "config      = " << config       << std::endl;
    115         std::cout << std::endl;
     85    // The print() function prints the entry identified by "index".
     86    ////////////////////////////////////////////////////////////////////
     87    void print( size_t index, size_t mode )
     88    {
     89        std::cout << "  TRT[" << std::dec << index << "] "
     90                  << " valid = " << valid
     91                  << " / error = " << rerror
     92                  << " / get = " << xram_read
     93                  << " / config = " << config << std::hex
     94                  << " / address = " << nline*4*wdata.size()
     95                  << " / srcid = " << srcid << std::endl;
     96        if ( mode )
     97        {
     98            std::cout << "        trdid = " << trdid
     99                      << " / pktid = " << pktid << std::dec
     100                      << " / proc_read = " << proc_read
     101                      << " / read_length = " << read_length
     102                      << " / word_index  = " << word_index << std::hex
     103                      << " / ll_key = " << ll_key << std::endl;
     104            std::cout << "        wdata = ";
     105            for(size_t i=0; i<wdata.size() ; i++)
     106            {
     107                std::cout << std::hex << wdata[i] << " / ";
     108            }
     109            std::cout << std::endl;
     110        }
    116111    }
    117112
     
    228223    }
    229224    /////////////////////////////////////////////////////////////////////
    230     // The print() function prints a transaction tab entry
    231     // Arguments :
    232     // - index : the index of the entry to print
    233     /////////////////////////////////////////////////////////////////////
    234     void print(const size_t index)
    235     {
    236         assert( (index < size_tab) and
    237         "MEMC ERROR: The selected entry is out of range in TRT write_data_mask()");
    238 
    239         tab[index].print();
    240         return;
     225    // The print() function prints TRT content.
     226    // Detailed content if detailed argument is non zero.
     227    /////////////////////////////////////////////////////////////////////
     228    void print( size_t detailed = 0 )
     229    {
     230        std::cout << "  < TRT content in " <<  tab_name << " >" << std::endl;
     231        for ( size_t id = 0 ; id < size_tab ; id++ )
     232        {
     233            tab[id].print( id , detailed );
     234        }
    241235    }
    242236    /////////////////////////////////////////////////////////////////////
  • trunk/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r537 r549  
    654654
    655655    //////////////////////////////////////////////////
    656     tmpl(void)::print_trace()
     656    tmpl(void)::print_trace( size_t detailed )
    657657    //////////////////////////////////////////////////
    658658    {
     
    676676            << " | " << alloc_ivt_fsm_str[r_alloc_ivt_fsm.read()]
    677677            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
     678
     679        if ( detailed ) m_trt.print(0);
    678680    }
    679681
     
    40114013
    40124014                        assert( ((p_vci_ixr.rerror.read() & 0x1) == 0) and
    4013                                 "MEMC ERROR in IXR_RSP state: XRAM response error !");
     4015                        "MEMC ERROR in IXR_RSP state: XRAM response error !");
    40144016
    40154017                        if (p_vci_ixr.reop.read())   // PUT
     
    40184020
    40194021#if DEBUG_MEMC_IXR_RSP
    4020                             if (m_debug)
    4021                                 std::cout << "  <MEMC " << name()
    4022                                     << " IXR_RSP_IDLE> Response from XRAM to a put transaction" << std::endl;
     4022if (m_debug)
     4023std::cout << "  <MEMC " << name()
     4024          << " IXR_RSP_IDLE> Response from XRAM to a put transaction" << std::endl;
    40234025#endif
    40244026                        }
     
    40284030
    40294031#if DEBUG_MEMC_IXR_RSP
    4030                             if (m_debug)
    4031                                 std::cout << "  <MEMC " << name()
    4032                                     << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
    4033 #endif
    4034                         }
    4035                     }
    4036                     break;
    4037                 }
    4038                 ////////////////////////
     4032if (m_debug)
     4033std::cout << "  <MEMC " << name()
     4034          << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
     4035#endif
     4036                        }
     4037                    }
     4038                    break;
     4039                }
     4040            ////////////////////////
    40394041            case IXR_RSP_TRT_ERASE:   // erase the entry in the TRT
    4040                 // decrease the line counter if config request
    4041                 {
    4042                     if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
    4043                     {
    4044                         size_t  index = r_ixr_rsp_trt_index.read();
    4045                         if (m_trt.is_config(index)) r_config_rsp_lines = r_config_rsp_lines.read() - 1;
    4046                         m_trt.erase(index);
     4042                                      // decrease the line counter if config request
     4043            {
     4044                if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
     4045                {
     4046                    size_t  index = r_ixr_rsp_trt_index.read();
     4047                    if (m_trt.is_config(index))
     4048                        r_config_rsp_lines = r_config_rsp_lines.read() - 1;
     4049                    m_trt.erase(index);
     4050                    r_ixr_rsp_fsm = IXR_RSP_IDLE;
     4051
     4052#if DEBUG_MEMC_IXR_RSP
     4053if (m_debug)
     4054std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
     4055          << r_ixr_rsp_trt_index.read() << std::endl;
     4056#endif
     4057                }
     4058                break;
     4059            }
     4060            //////////////////////
     4061            case IXR_RSP_TRT_READ:    // write a 64 bits data word in TRT
     4062            {
     4063                if ((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
     4064                {
     4065                    size_t      index    = r_ixr_rsp_trt_index.read();
     4066                    size_t      word     = r_ixr_rsp_cpt.read();
     4067                    bool        eop      = p_vci_ixr.reop.read();
     4068                    wide_data_t data     = p_vci_ixr.rdata.read();
     4069                    bool        error    = ((p_vci_ixr.rerror.read() & 0x1) == 1);
     4070
     4071                    assert(((eop == (word == (m_words-2))) or error) and
     4072                    "MEMC ERROR in IXR_RSP_TRT_READ state : invalid response from XRAM");
     4073
     4074                    m_trt.write_rsp( index, word, data );
     4075
     4076                    r_ixr_rsp_cpt = word + 2;
     4077
     4078                    if (eop )
     4079                    {
     4080                        r_ixr_rsp_to_xram_rsp_rok[r_ixr_rsp_trt_index.read()] = true;
    40474081                        r_ixr_rsp_fsm = IXR_RSP_IDLE;
     4082                    }
    40484083
    40494084#if DEBUG_MEMC_IXR_RSP
    4050                         if (m_debug)
    4051                             std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
    4052                                 << r_ixr_rsp_trt_index.read() << std::endl;
    4053 #endif
    4054                     }
    4055                     break;
    4056                 }
    4057                 //////////////////////
    4058             case IXR_RSP_TRT_READ:    // write a 64 bits data word in TRT
    4059                 {
    4060                     if ((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
    4061                     {
    4062                         size_t      index    = r_ixr_rsp_trt_index.read();
    4063                         size_t      word     = r_ixr_rsp_cpt.read();
    4064                         bool        eop      = p_vci_ixr.reop.read();
    4065                         wide_data_t data     = p_vci_ixr.rdata.read();
    4066                         bool        error    = ((p_vci_ixr.rerror.read() & 0x1) == 1);
    4067 
    4068                         assert(((eop == (word == (m_words-2))) or error) and
    4069                                 "MEMC ERROR in IXR_RSP_TRT_READ state : invalid response from XRAM");
    4070 
    4071                         m_trt.write_rsp( index,
    4072                                 word,
    4073                                 data );
    4074 
    4075                         r_ixr_rsp_cpt = word + 2;
    4076 
    4077                         if (eop )
    4078                         {
    4079                             r_ixr_rsp_to_xram_rsp_rok[r_ixr_rsp_trt_index.read()] = true;
    4080                             r_ixr_rsp_fsm = IXR_RSP_IDLE;
    4081                         }
    4082 
    4083 #if DEBUG_MEMC_IXR_RSP
    4084                         if (m_debug)
    4085                             std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing 2 words in TRT : "
    4086                                 << " index = " << std::dec << index
    4087                                 << " / word = " << word
    4088                                 << " / data = " << std::hex << data << std::endl;
    4089 #endif
    4090                     }
    4091                     break;
    4092                 }
     4085if (m_debug)
     4086std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing 2 words in TRT : "
     4087          << " index = " << std::dec << index
     4088          << " / word = " << word
     4089          << " / data = " << std::hex << data << std::endl;
     4090#endif
     4091                }
     4092                break;
     4093            }
    40934094        } // end swich r_ixr_rsp_fsm
    40944095
Note: See TracChangeset for help on using the changeset viewer.