Ignore:
Timestamp:
Oct 15, 2014, 11:41:49 AM (10 years ago)
Author:
meunier
Message:

Trunk:

  • Cosmetic in mem_cache_directory.h and xram_transaction.h
  • Renamed mem_cache param dspin_in_width and dspin_out_width to memc_dspin_in_width and memc_dspin_out_width (because of a bug in soclib-cc ?). Should have updated these names in the .sd or .py files of all platforms
  • Updated the scripts for tsar_generic_xbar to take into account the ideal write-through + added a graph in create_graphs.py
Location:
trunk/modules/vci_mem_cache/caba/source
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/vci_mem_cache/caba/source/include/mem_cache_directory.h

    r753 r836  
    1212namespace soclib { namespace caba {
    1313
    14   using namespace sc_core;
    15 
    16   ////////////////////////////////////////////////////////////////////////
    17   //                    A LRU entry
    18   ////////////////////////////////////////////////////////////////////////
    19   class LruEntry {
     14using namespace sc_core;
     15
     16////////////////////////////////////////////////////////////////////////
     17//                    A LRU entry
     18////////////////////////////////////////////////////////////////////////
     19class LruEntry {
    2020
    2121    public:
    2222
    23       bool recent;           
    24 
    25       void init()
    26       {
    27         recent=false;
    28       }
    29 
    30   }; // end class LruEntry
    31 
    32   ////////////////////////////////////////////////////////////////////////
    33   //                    An Owner
    34   ////////////////////////////////////////////////////////////////////////
    35   class Owner{
    36    
     23        bool recent;           
     24
     25        void init()
     26        {
     27            recent = false;
     28        }
     29
     30}; // end class LruEntry
     31
     32////////////////////////////////////////////////////////////////////////
     33//                    An Owner
     34////////////////////////////////////////////////////////////////////////
     35class Owner{
     36
    3737    public:
    38     // Fields
    39       bool      inst;       // Is the owner an ICache ?
    40       size_t    srcid;      // The SRCID of the owner
    41 
    42     ////////////////////////
    43     // Constructors
    44     ////////////////////////
    45       Owner(bool  i_inst,
    46             size_t i_srcid)
    47       {
    48         inst    = i_inst;
    49         srcid  = i_srcid;
    50       }
    51 
    52       Owner(const Owner &a)
    53       {
    54         inst    = a.inst;
    55         srcid  = a.srcid;
    56       }
    57 
    58       Owner()
    59       {
    60         inst    = false;
    61         srcid  = 0;
    62       }
    63       // end constructors
    64 
    65   }; // end class Owner
    66 
    67 
    68   ////////////////////////////////////////////////////////////////////////
    69   //                    A directory entry                               
    70   ////////////////////////////////////////////////////////////////////////
    71   class DirectoryEntry {
     38        // Fields
     39        bool   inst;  // Is the owner an ICache ?
     40        size_t srcid; // The SRCID of the owner
     41
     42        ////////////////////////
     43        // Constructors
     44        ////////////////////////
     45        Owner(bool i_inst,
     46                size_t i_srcid)
     47        {
     48            inst  = i_inst;
     49            srcid = i_srcid;
     50        }
     51
     52        Owner(const Owner &a)
     53        {
     54            inst  = a.inst;
     55            srcid = a.srcid;
     56        }
     57
     58        Owner()
     59        {
     60            inst  = false;
     61            srcid = 0;
     62        }
     63        // end constructors
     64
     65}; // end class Owner
     66
     67
     68////////////////////////////////////////////////////////////////////////
     69//                    A directory entry                               
     70////////////////////////////////////////////////////////////////////////
     71class DirectoryEntry {
    7272
    7373    typedef uint32_t tag_t;
    … …  
    7575    public:
    7676
    77     bool    valid;                  // entry valid
    78     bool    is_cnt;                 // directory entry is in counter mode
    79     bool    dirty;                  // entry dirty
    80     bool    lock;                   // entry locked
    81     tag_t   tag;                    // tag of the entry
    82     size_t  count;                  // number of copies
    83     Owner   owner;                  // an owner of the line
    84     size_t  ptr;                    // pointer to the next owner
     77    bool    valid;  // entry valid
     78    bool    is_cnt; // directory entry is in counter mode
     79    bool    dirty;  // entry dirty
     80    bool    lock;   // entry locked
     81    tag_t   tag;    // tag of the entry
     82    size_t  count;  // number of copies
     83    Owner   owner;  // an owner of the line
     84    size_t  ptr;    // pointer to the next owner
    8585
    8686    DirectoryEntry()
    8787    {
    88       valid         = false;
    89       is_cnt        = false;
    90       dirty         = false;
    91       lock          = false;
    92       tag           = 0;
    93       count         = 0;
    94       owner.inst    = 0;
    95       owner.srcid  = 0;
    96       ptr           = 0;
     88        valid       = false;
     89        is_cnt      = false;
     90        dirty       = false;
     91        lock        = false;
     92        tag         = 0;
     93        count       = 0;
     94        owner.inst  = 0;
     95        owner.srcid = 0;
     96        ptr         = 0;
    9797    }
    9898
    9999    DirectoryEntry(const DirectoryEntry &source)
    100100    {
    101       valid         = source.valid;
    102       is_cnt        = source.is_cnt;
    103       dirty         = source.dirty;
    104       lock          = source.lock;
    105       tag           = source.tag;
    106       count         = source.count;
    107       owner         = source.owner;
    108       ptr           = source.ptr;
     101        valid  = source.valid;
     102        is_cnt = source.is_cnt;
     103        dirty  = source.dirty;
     104        lock   = source.lock;
     105        tag    = source.tag;
     106        count  = source.count;
     107        owner  = source.owner;
     108        ptr    = source.ptr;
    109109    }         
    110110
    … …  
    114114    void init()
    115115    {
    116       valid     = false;
    117       is_cnt    = false;
    118       dirty     = false;
    119       lock      = false;
    120       count     = 0;
     116        valid  = false;
     117        is_cnt = false;
     118        dirty  = false;
     119        lock   = false;
     120        count  = 0;
    121121    }
    122122
    … …  
    126126    void copy(const DirectoryEntry &source)
    127127    {
    128       valid         = source.valid;
    129       is_cnt    = source.is_cnt;
    130       dirty         = source.dirty;
    131       lock          = source.lock;
    132       tag           = source.tag;
    133       count     = source.count;
    134       owner     = source.owner;
    135       ptr       = source.ptr;
     128        valid  = source.valid;
     129        is_cnt = source.is_cnt;
     130        dirty  = source.dirty;
     131        lock   = source.lock;
     132        tag    = source.tag;
     133        count  = source.count;
     134        owner  = source.owner;
     135        ptr    = source.ptr;
    136136    }
    137137
    … …  
    141141    void print()
    142142    {
    143       std::cout << "Valid = " << valid
    144                 << " ; IS COUNT = " << is_cnt
    145                 << " ; Dirty = " << dirty
    146                 << " ; Lock = " << lock
    147                 << " ; Tag = " << std::hex << tag << std::dec
    148                 << " ; Count = " << count
    149                 << " ; Owner = " << owner.srcid
    150                 << " " << owner.inst
    151                 << " ; Pointer = " << ptr << std::endl;
     143        std::cout << "Valid = " << valid
     144            << " ; IS COUNT = " << is_cnt
     145            << " ; Dirty = " << dirty
     146            << " ; Lock = " << lock
     147            << " ; Tag = " << std::hex << tag << std::dec
     148            << " ; Count = " << count
     149            << " ; Owner = " << owner.srcid
     150            << " " << owner.inst
     151            << " ; Pointer = " << ptr << std::endl;
    152152    }
    153153
    154   }; // end class DirectoryEntry
    155 
    156   ////////////////////////////////////////////////////////////////////////
    157   //                       The directory 
    158   ////////////////////////////////////////////////////////////////////////
    159   class CacheDirectory {
     154}; // end class DirectoryEntry
     155
     156////////////////////////////////////////////////////////////////////////
     157//                       The directory 
     158////////////////////////////////////////////////////////////////////////
     159class CacheDirectory {
    160160
    161161    typedef sc_dt::sc_uint<40> addr_t;
    … …  
    166166
    167167    // Directory constants
    168     size_t                                      m_ways;
    169     size_t                                      m_sets;
    170     size_t                                      m_words;
    171     size_t                                      m_width;
    172     uint32_t                lfsr;
     168    size_t   m_ways;
     169    size_t   m_sets;
     170    size_t   m_words;
     171    size_t   m_width;
     172    uint32_t lfsr;
    173173
    174174    // the directory & lru tables
    175     DirectoryEntry                              **m_dir_tab;
    176     LruEntry                                    **m_lru_tab;
     175    DirectoryEntry ** m_dir_tab;
     176    LruEntry       ** m_lru_tab;
    177177
    178178    public:
    … …  
    181181    // Constructor
    182182    ////////////////////////
    183     CacheDirectory( size_t ways, size_t sets, size_t words, size_t address_width)       
    184     {
    185       m_ways  = ways;
    186       m_sets  = sets;
    187       m_words = words;
    188       m_width = address_width;
    189       lfsr = -1;
    190 
    191       m_dir_tab = new DirectoryEntry*[sets];
    192       for ( size_t i=0; i<sets; i++ ) {
    193         m_dir_tab[i] = new DirectoryEntry[ways];
    194         for ( size_t j=0 ; j<ways ; j++) m_dir_tab[i][j].init();
    195       }
    196       m_lru_tab = new LruEntry*[sets];
    197       for ( size_t i=0; i<sets; i++ ) {
    198         m_lru_tab[i] = new LruEntry[ways];
    199         for ( size_t j=0 ; j<ways ; j++) m_lru_tab[i][j].init();
    200       }
     183    CacheDirectory( size_t ways, size_t sets, size_t words, size_t address_width)   
     184    {
     185        m_ways  = ways;
     186        m_sets  = sets;
     187        m_words = words;
     188        m_width = address_width;
     189        lfsr = -1;
     190
     191        m_dir_tab = new DirectoryEntry*[sets];
     192        for (size_t i = 0; i < sets; i++ ) {
     193            m_dir_tab[i] = new DirectoryEntry[ways];
     194            for (size_t j = 0; j < ways; j++) m_dir_tab[i][j].init();
     195        }
     196        m_lru_tab = new LruEntry*[sets];
     197        for (size_t i = 0; i < sets; i++) {
     198            m_lru_tab[i] = new LruEntry[ways];
     199            for (size_t j = 0; j < ways; j++) m_lru_tab[i][j].init();
     200        }
    201201    } // end constructor
    202202
    … …  
    206206    ~CacheDirectory()
    207207    {
    208       for(size_t i=0 ; i<m_sets ; i++){
    209         delete [] m_dir_tab[i];
    210         delete [] m_lru_tab[i];
    211       }
    212       delete [] m_dir_tab;
    213       delete [] m_lru_tab;
     208        for(size_t i = 0; i < m_sets; i++){
     209            delete [] m_dir_tab[i];
     210            delete [] m_lru_tab[i];
     211        }
     212        delete [] m_dir_tab;
     213        delete [] m_lru_tab;
    214214    } // end destructor
    215215
    … …  
    230230#undef L2
    231231
    232         bool hit       = false;
    233         for ( size_t i=0 ; i<m_ways ; i++ )
    234         {
    235             bool equal = ( m_dir_tab[set][i].tag == tag );
     232        bool hit = false;
     233        for (size_t i = 0; i < m_ways; i++ )
     234        {
     235            bool equal = (m_dir_tab[set][i].tag == tag);
    236236            bool valid = m_dir_tab[set][i].valid;
    237237            hit        = equal && valid;
    238             if ( hit )
    239             {                   
     238            if (hit)
     239            {           
    240240                way = i;
    241241                break;
    242242            }
    243243        }
    244         if ( hit )
     244        if (hit)
    245245        {
    246246            m_lru_tab[set][way].recent = true;
    … …  
    257257    // way arguments.
    258258    /////////////////////////////////////////////////////////////////////
    259     void inval( const size_t &way, const size_t &set )
     259    void inval(const size_t &way, const size_t &set)
    260260    {
    261261        m_dir_tab[set][way].init();
    … …  
    269269    // The function returns a copy of a (valid or invalid) entry 
    270270    /////////////////////////////////////////////////////////////////////
    271     DirectoryEntry read_neutral( const addr_t &address,
    272                                  size_t*      ret_way,
    273                                  size_t*      ret_set )
     271    DirectoryEntry read_neutral(const addr_t &address,
     272            size_t * ret_way,
     273            size_t * ret_set )
    274274    {
    275275
    276276#define L2 soclib::common::uint32_log2
    277         size_t set = (size_t)(address >> (L2(m_words) + 2)) & (m_sets - 1);
    278         tag_t  tag = (tag_t)(address >> (L2(m_sets) + L2(m_words) + 2));
     277        size_t set = (size_t) (address >> (L2(m_words) + 2)) & (m_sets - 1);
     278        tag_t  tag = (tag_t) (address >> (L2(m_sets) + L2(m_words) + 2));
    279279#undef L2
    280280
    281         for ( size_t way = 0 ; way < m_ways ; way++ )
    282         {
    283             bool equal = ( m_dir_tab[set][way].tag == tag );
     281        for (size_t way = 0; way < m_ways; way++)
     282        {
     283            bool equal = (m_dir_tab[set][way].tag == tag);
    284284            bool valid = m_dir_tab[set][way].valid;
    285             if ( equal and valid )
     285            if (equal and valid)
    286286            {
    287287                *ret_set = set;
    … …  
    301301    // - entry : the entry value
    302302    /////////////////////////////////////////////////////////////////////
    303     void write( const size_t         &set,
    304                 const size_t         &way,
    305                 const DirectoryEntry &entry)
    306     {
    307       assert( (set<m_sets)
    308           && "Cache Directory write : The set index is invalid");
    309       assert( (way<m_ways)
    310           && "Cache Directory write : The way index is invalid");
    311 
    312       // update Directory
    313       m_dir_tab[set][way].copy(entry);
    314 
    315       // update LRU bits
    316       bool all_recent = true;
    317       for ( size_t i=0 ; i<m_ways ; i++ )
    318       {
    319           if ( i != way ) all_recent = m_lru_tab[set][i].recent && all_recent;
    320       }
    321       if ( all_recent )
    322       {
    323           for( size_t i=0 ; i<m_ways ; i++ ) m_lru_tab[set][i].recent = false;
    324       }
    325       else
    326       {
    327           m_lru_tab[set][way].recent = true;
    328       }
     303    void write(const size_t &set,
     304               const size_t &way,
     305               const DirectoryEntry &entry)
     306    {
     307        assert((set < m_sets) && "Cache Directory write : The set index is invalid");
     308        assert((way < m_ways) && "Cache Directory write : The way index is invalid");
     309
     310        // update Directory
     311        m_dir_tab[set][way].copy(entry);
     312
     313        // update LRU bits
     314        bool all_recent = true;
     315        for (size_t i = 0; i < m_ways; i++)
     316        {
     317            if (i != way) all_recent = m_lru_tab[set][i].recent && all_recent;
     318        }
     319        if (all_recent)
     320        {
     321            for (size_t i = 0; i < m_ways; i++) m_lru_tab[set][i].recent = false;
     322        }
     323        else
     324        {
     325            m_lru_tab[set][way].recent = true;
     326        }
    329327    } // end write()
    330328
    … …  
    337335    void print(const size_t &set, const size_t &way)
    338336    {
    339       std::cout << std::dec << " set : " << set << " ; way : " << way << " ; " ;
    340       m_dir_tab[set][way].print();
     337        std::cout << std::dec << " set : " << set << " ; way : " << way << " ; " ;
     338        m_dir_tab[set][way].print();
    341339    } // end print()
    342340
    … …  
    349347    DirectoryEntry select(const size_t &set, size_t &way)
    350348    {
    351         assert( (set < m_sets)
    352           && "Cache Directory : (select) The set index is invalid");
     349        assert((set < m_sets)
     350                && "Cache Directory : (select) The set index is invalid");
    353351
    354352        // looking for an empty slot
    355         for(size_t i=0; i<m_ways; i++)
    356         {
    357             if( not m_dir_tab[set][i].valid )
    358             {
    359                 way=i;
     353        for (size_t i = 0; i < m_ways; i++)
     354        {
     355            if (not m_dir_tab[set][i].valid)
     356            {
     357                way = i;
    360358                return DirectoryEntry(m_dir_tab[set][way]);
    361359            }
    … …  
    369367
    370368        // looking for a not locked and not recently used entry
    371         for(size_t i=0; i<m_ways; i++)
    372         {
    373             if((not m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock) )
    374             {
    375                 way=i;
     369        for (size_t i = 0; i < m_ways; i++)
     370        {
     371            if ((not m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock))
     372            {
     373                way = i;
    376374                return DirectoryEntry(m_dir_tab[set][way]);
    377375            }
    … …  
    379377
    380378        // looking for a locked not recently used entry
    381         for(size_t i=0; i<m_ways; i++)
    382         {
    383             if( (not m_lru_tab[set][i].recent) && (m_dir_tab[set][i].lock))
    384             {
    385                 way=i;
     379        for (size_t i = 0; i < m_ways; i++)
     380        {
     381            if ((not m_lru_tab[set][i].recent) && (m_dir_tab[set][i].lock))
     382            {
     383                way = i;
    386384                return DirectoryEntry(m_dir_tab[set][way]);
    387385            }
    … …  
    389387
    390388        // looking for a recently used entry not locked
    391         for(size_t i=0; i<m_ways; i++)
    392         {
    393             if( (m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock))
    394             {
    395                 way=i;
     389        for (size_t i = 0; i < m_ways; i++)
     390        {
     391            if ((m_lru_tab[set][i].recent) && (not m_dir_tab[set][i].lock))
     392            {
     393                way = i;
    396394                return DirectoryEntry(m_dir_tab[set][way]);
    397395            }
    … …  
    404402
    405403    /////////////////////////////////////////////////////////////////////
    406     //          Global initialisation function
     404    //         Global initialisation function
    407405    /////////////////////////////////////////////////////////////////////
    408406    void init()
    409407    {
    410       for ( size_t set=0 ; set<m_sets ; set++ )
    411       {
    412         for ( size_t way=0 ; way<m_ways ; way++ )
    413         {
    414           m_dir_tab[set][way].init();
    415           m_lru_tab[set][way].init();
    416         }
    417       }
     408        for (size_t set = 0; set < m_sets; set++)
     409        {
     410            for (size_t way = 0; way < m_ways; way++)
     411            {
     412                m_dir_tab[set][way].init();
     413                m_lru_tab[set][way].init();
     414            }
     415        }
    418416    } // end init()
    419417
    420   }; // end class CacheDirectory
    421 
    422   ///////////////////////////////////////////////////////////////////////
    423   //                    A Heap Entry
    424   ///////////////////////////////////////////////////////////////////////
    425   class HeapEntry{
     418}; // end class CacheDirectory
     419
     420///////////////////////////////////////////////////////////////////////
     421//                    A Heap Entry
     422///////////////////////////////////////////////////////////////////////
     423class HeapEntry{
    426424
    427425    public:
    428     // Fields of the entry
    429       Owner     owner;
    430       size_t    next;
    431 
    432     ////////////////////////
    433     // Constructor
    434     ////////////////////////
    435       HeapEntry()
    436       :owner(false,0)
    437       {
    438         next = 0;
    439       } // end constructor
    440 
    441     ////////////////////////
    442     // Constructor
    443     ////////////////////////
    444       HeapEntry(const HeapEntry &entry)
    445       {
    446         owner.inst  = entry.owner.inst;
    447         owner.srcid = entry.owner.srcid;
    448         next           = entry.next;
    449       } // end constructor
    450 
    451     /////////////////////////////////////////////////////////////////////
    452     // The copy() function copies an existing source entry to a target
    453     /////////////////////////////////////////////////////////////////////
    454       void copy(const HeapEntry &entry)
    455       {
    456         owner.inst     = entry.owner.inst;
    457         owner.srcid    = entry.owner.srcid;
    458         next           = entry.next;
    459       } // end copy()
    460 
    461     ////////////////////////////////////////////////////////////////////
    462     // The print() function prints the entry
    463     ////////////////////////////////////////////////////////////////////
    464       void print(){
    465         std::cout
    466         << " -- owner.inst     : " << std::dec << owner.inst << std::endl
    467         << " -- owner.srcid    : " << std::dec << owner.srcid << std::endl
    468         << " -- next           : " << std::dec << next << std::endl;
    469 
    470       } // end print()
    471 
    472   }; // end class HeapEntry
    473 
    474   ////////////////////////////////////////////////////////////////////////
    475   //                        The Heap
    476   ////////////////////////////////////////////////////////////////////////
    477   class HeapDirectory{
    478    
     426        // Fields of the entry
     427        Owner  owner;
     428        size_t next;
     429
     430        ////////////////////////
     431        // Constructor
     432        ////////////////////////
     433        HeapEntry()
     434            :owner(false, 0)
     435        {
     436            next = 0;
     437        } // end constructor
     438
     439        ////////////////////////
     440        // Constructor
     441        ////////////////////////
     442        HeapEntry(const HeapEntry &entry)
     443        {
     444            owner.inst  = entry.owner.inst;
     445            owner.srcid = entry.owner.srcid;
     446            next        = entry.next;
     447        } // end constructor
     448
     449        /////////////////////////////////////////////////////////////////////
     450        // The copy() function copies an existing source entry to a target
     451        /////////////////////////////////////////////////////////////////////
     452        void copy(const HeapEntry &entry)
     453        {
     454            owner.inst     = entry.owner.inst;
     455            owner.srcid    = entry.owner.srcid;
     456            next           = entry.next;
     457        } // end copy()
     458
     459        ////////////////////////////////////////////////////////////////////
     460        // The print() function prints the entry
     461        ////////////////////////////////////////////////////////////////////
     462        void print() {
     463            std::cout
     464                << " -- owner.inst     : " << std::dec << owner.inst << std::endl
     465                << " -- owner.srcid    : " << std::dec << owner.srcid << std::endl
     466                << " -- next           : " << std::dec << next << std::endl;
     467
     468        } // end print()
     469
     470}; // end class HeapEntry
     471
     472////////////////////////////////////////////////////////////////////////
     473//                        The Heap
     474////////////////////////////////////////////////////////////////////////
     475class HeapDirectory{
     476
    479477    private:
    480     // Registers and the heap
    481       size_t    ptr_free;
    482       bool      full;
    483       HeapEntry *m_heap_tab;
    484 
    485     // Constants for debugging purpose
    486       size_t    tab_size;
     478        // Registers and the heap
     479        size_t ptr_free;
     480        bool   full;
     481        HeapEntry * m_heap_tab;
     482
     483        // Constants for debugging purpose
     484        size_t    tab_size;
    487485
    488486    public:
    489     ////////////////////////
    490     // Constructor
    491     ////////////////////////
    492       HeapDirectory(uint32_t size){
    493         assert(size>0 && "Memory Cache, HeapDirectory constructor : invalid size");
    494         ptr_free    = 0;
    495         full        = false;
    496         m_heap_tab  = new HeapEntry[size];
    497         tab_size    = size;
    498       } // end constructor
    499 
    500     /////////////////
    501     // Destructor
    502     /////////////////
    503       ~HeapDirectory(){
    504         delete [] m_heap_tab;
    505       } // end destructor
    506 
    507     /////////////////////////////////////////////////////////////////////
    508     //          Global initialisation function
    509     /////////////////////////////////////////////////////////////////////
    510       void init(){
    511         ptr_free=0;
    512         full=false;
    513         for(size_t i=0; i< tab_size-1;i++){
    514           m_heap_tab[i].next = i+1;
    515         }
    516         m_heap_tab[tab_size-1].next = tab_size-1;
    517         return;
    518       }
    519 
    520     /////////////////////////////////////////////////////////////////////
    521     // The print() function prints a selected directory entry
    522     // Arguments :
    523     // - ptr : the pointer to the entry to print
    524     /////////////////////////////////////////////////////////////////////
    525       void print(const size_t &ptr){
    526         std::cout << "Heap, printing the entry : " << std::dec << ptr << std::endl;
    527         m_heap_tab[ptr].print();
    528       } // end print()
    529 
    530     /////////////////////////////////////////////////////////////////////
    531     // The print_list() function prints a list from selected directory entry
    532     // Arguments :
    533     // - ptr : the pointer to the first entry to print
    534     /////////////////////////////////////////////////////////////////////
    535       void print_list(const size_t &ptr){
    536         bool end = false;
    537         size_t ptr_temp = ptr;
    538         std::cout << "Heap, printing the list from : " << std::dec << ptr << std::endl;
    539         while(!end){
    540             m_heap_tab[ptr_temp].print();
    541             if(ptr_temp == m_heap_tab[ptr_temp].next) end = true;
    542             ptr_temp = m_heap_tab[ptr_temp].next;
    543         }
    544       } // end print_list()
    545 
    546     /////////////////////////////////////////////////////////////////////
    547     // The is_full() function return true if the heap is full.
    548     /////////////////////////////////////////////////////////////////////
    549       bool is_full(){
    550         return full;
    551       } // end is_full()
    552 
    553     /////////////////////////////////////////////////////////////////////
    554     // The next_free_ptr() function returns the pointer
    555     // to the next free entry.
    556     /////////////////////////////////////////////////////////////////////
    557       size_t next_free_ptr(){
    558         return ptr_free;
    559       } // end next_free_ptr()
    560 
    561     /////////////////////////////////////////////////////////////////////
    562     // The next_free_entry() function returns
    563     // a copy of the next free entry.
    564     /////////////////////////////////////////////////////////////////////
    565       HeapEntry next_free_entry(){
    566         return HeapEntry(m_heap_tab[ptr_free]);
    567       } // end next_free_entry()
    568    
    569     /////////////////////////////////////////////////////////////////////
    570     // The write_free_entry() function modify the next free entry.
    571     // Arguments :
    572     // - entry : the entry to write
    573     /////////////////////////////////////////////////////////////////////
    574       void write_free_entry(const HeapEntry &entry){
    575         m_heap_tab[ptr_free].copy(entry);
    576       } // end write_free_entry()
    577 
    578     /////////////////////////////////////////////////////////////////////
    579     // The write_free_ptr() function writes the pointer
    580     // to the next free entry
    581     /////////////////////////////////////////////////////////////////////
    582       void write_free_ptr(const size_t &ptr){
    583         assert( (ptr<tab_size) && "HeapDirectory error : try to write a wrong free pointer");
    584         ptr_free = ptr;
    585       } // end write_free_ptr()
    586 
    587     /////////////////////////////////////////////////////////////////////
    588     // The set_full() function sets the full bit (to true).
    589     /////////////////////////////////////////////////////////////////////
    590       void set_full(){
    591         full = true;
    592       } // end set_full()
    593 
    594     /////////////////////////////////////////////////////////////////////
    595     // The unset_full() function unsets the full bit (to false).
    596     /////////////////////////////////////////////////////////////////////
    597       void unset_full(){
    598         full = false;
    599       } // end unset_full()
    600 
    601     /////////////////////////////////////////////////////////////////////
    602     // The read() function returns a copy of
    603     // the entry pointed by the argument
    604     // Arguments :
    605     //  - ptr : the pointer to the entry to read
    606     /////////////////////////////////////////////////////////////////////
    607       HeapEntry read(const size_t &ptr){
    608         assert( (ptr<tab_size) && "HeapDirectory error : try to write a wrong free pointer");
    609         return HeapEntry(m_heap_tab[ptr]);
    610       } // end read()
    611 
    612     /////////////////////////////////////////////////////////////////////
    613     // The write() function writes an entry in the heap
    614     // Arguments :
    615     //  - ptr : the pointer to the entry to replace
    616     //  - entry : the entry to write
    617     /////////////////////////////////////////////////////////////////////
    618       void write(const size_t &ptr, const HeapEntry &entry){
    619         assert( (ptr<tab_size) && "HeapDirectory error : try to write a wrong free pointer");
    620         m_heap_tab[ptr].copy(entry);
    621       } // end write()
    622 
    623   }; // end class HeapDirectory
    624 
    625   ////////////////////////////////////////////////////////////////////////
    626   //                        Cache Data
    627   ////////////////////////////////////////////////////////////////////////
    628   class CacheData
    629   {
     487        ////////////////////////
     488        // Constructor
     489        ////////////////////////
     490        HeapDirectory(uint32_t size) {
     491            assert(size > 0 && "Memory Cache, HeapDirectory constructor : invalid size");
     492            ptr_free    = 0;
     493            full        = false;
     494            m_heap_tab  = new HeapEntry[size];
     495            tab_size    = size;
     496        } // end constructor
     497
     498        /////////////////
     499        // Destructor
     500        /////////////////
     501        ~HeapDirectory() {
     502            delete [] m_heap_tab;
     503        } // end destructor
     504
     505        /////////////////////////////////////////////////////////////////////
     506        //         Global initialisation function
     507        /////////////////////////////////////////////////////////////////////
     508        void init() {
     509            ptr_free = 0;
     510            full = false;
     511            for (size_t i = 0; i< tab_size - 1; i++){
     512                m_heap_tab[i].next = i + 1;
     513            }
     514            m_heap_tab[tab_size - 1].next = tab_size - 1;
     515            return;
     516        }
     517
     518        /////////////////////////////////////////////////////////////////////
     519        // The print() function prints a selected directory entry
     520        // Arguments :
     521        // - ptr : the pointer to the entry to print
     522        /////////////////////////////////////////////////////////////////////
     523        void print(const size_t &ptr) {
     524            std::cout << "Heap, printing the entry : " << std::dec << ptr << std::endl;
     525            m_heap_tab[ptr].print();
     526        } // end print()
     527
     528        /////////////////////////////////////////////////////////////////////
     529        // The print_list() function prints a list from selected directory entry
     530        // Arguments :
     531        // - ptr : the pointer to the first entry to print
     532        /////////////////////////////////////////////////////////////////////
     533        void print_list(const size_t &ptr) {
     534            bool end = false;
     535            size_t ptr_temp = ptr;
     536            std::cout << "Heap, printing the list from : " << std::dec << ptr << std::endl;
     537            while (!end){
     538                m_heap_tab[ptr_temp].print();
     539                if (ptr_temp == m_heap_tab[ptr_temp].next) {
     540                    end = true;
     541                }
     542                ptr_temp = m_heap_tab[ptr_temp].next;
     543            }
     544        } // end print_list()
     545
     546        /////////////////////////////////////////////////////////////////////
     547        // The is_full() function return true if the heap is full.
     548        /////////////////////////////////////////////////////////////////////
     549        bool is_full() {
     550            return full;
     551        } // end is_full()
     552
     553        /////////////////////////////////////////////////////////////////////
     554        // The next_free_ptr() function returns the pointer
     555        // to the next free entry.
     556        /////////////////////////////////////////////////////////////////////
     557        size_t next_free_ptr() {
     558            return ptr_free;
     559        } // end next_free_ptr()
     560
     561        /////////////////////////////////////////////////////////////////////
     562        // The next_free_entry() function returns
     563        // a copy of the next free entry.
     564        /////////////////////////////////////////////////////////////////////
     565        HeapEntry next_free_entry() {
     566            return HeapEntry(m_heap_tab[ptr_free]);
     567        } // end next_free_entry()
     568
     569        /////////////////////////////////////////////////////////////////////
     570        // The write_free_entry() function modify the next free entry.
     571        // Arguments :
     572        // - entry : the entry to write
     573        /////////////////////////////////////////////////////////////////////
     574        void write_free_entry(const HeapEntry &entry){
     575            m_heap_tab[ptr_free].copy(entry);
     576        } // end write_free_entry()
     577
     578        /////////////////////////////////////////////////////////////////////
     579        // The write_free_ptr() function writes the pointer
     580        // to the next free entry
     581        /////////////////////////////////////////////////////////////////////
     582        void write_free_ptr(const size_t &ptr){
     583            assert((ptr < tab_size) && "HeapDirectory error : try to write a wrong free pointer");
     584            ptr_free = ptr;
     585        } // end write_free_ptr()
     586
     587        /////////////////////////////////////////////////////////////////////
     588        // The set_full() function sets the full bit (to true).
     589        /////////////////////////////////////////////////////////////////////
     590        void set_full() {
     591            full = true;
     592        } // end set_full()
     593
     594        /////////////////////////////////////////////////////////////////////
     595        // The unset_full() function unsets the full bit (to false).
     596        /////////////////////////////////////////////////////////////////////
     597        void unset_full() {
     598            full = false;
     599        } // end unset_full()
     600
     601        /////////////////////////////////////////////////////////////////////
     602        // The read() function returns a copy of
     603        // the entry pointed by the argument
     604        // Arguments :
     605        //  - ptr : the pointer to the entry to read
     606        /////////////////////////////////////////////////////////////////////
     607        HeapEntry read(const size_t &ptr) {
     608            assert((ptr < tab_size) && "HeapDirectory error : try to write a wrong free pointer");
     609            return HeapEntry(m_heap_tab[ptr]);
     610        } // end read()
     611
     612        /////////////////////////////////////////////////////////////////////
     613        // The write() function writes an entry in the heap
     614        // Arguments :
     615        //  - ptr : the pointer to the entry to replace
     616        //  - entry : the entry to write
     617        /////////////////////////////////////////////////////////////////////
     618        void write(const size_t &ptr, const HeapEntry &entry) {
     619            assert((ptr < tab_size) && "HeapDirectory error : try to write a wrong free pointer");
     620            m_heap_tab[ptr].copy(entry);
     621        } // end write()
     622
     623}; // end class HeapDirectory
     624
     625////////////////////////////////////////////////////////////////////////
     626//                        Cache Data
     627////////////////////////////////////////////////////////////////////////
     628class CacheData
     629{
    630630    private:
    631       const uint32_t m_sets;
    632       const uint32_t m_ways;
    633       const uint32_t m_words;
    634 
    635       uint32_t *** m_cache_data;
     631        const uint32_t m_sets;
     632        const uint32_t m_ways;
     633        const uint32_t m_words;
     634
     635        uint32_t *** m_cache_data;
    636636
    637637    public:
    638638
    639       ///////////////////////////////////////////////////////
    640       CacheData(uint32_t ways, uint32_t sets, uint32_t words)
    641         : m_sets(sets), m_ways(ways), m_words(words)
    642       {
    643           m_cache_data = new uint32_t ** [ways];
    644           for ( size_t i=0 ; i < ways ; i++ )
    645           {
    646               m_cache_data[i] = new uint32_t * [sets];
    647           }
    648           for ( size_t i=0; i<ways; i++ )
    649           {
    650               for ( size_t j=0; j<sets; j++ )
    651               {
    652                   m_cache_data[i][j] = new uint32_t [words];
    653                   // Init to avoid potential errors from memory checkers
    654                   std::memset(m_cache_data[i][j], 0, sizeof(uint32_t) * words);
    655               }
    656           }
    657       }
    658       ////////////
    659       ~CacheData()
    660       {
    661           for(size_t i=0; i<m_ways ; i++)
    662           {
    663               for(size_t j=0; j<m_sets ; j++)
    664               {
    665                   delete [] m_cache_data[i][j];
    666               }
    667           }
    668           for(size_t i=0; i<m_ways ; i++)
    669           {
    670               delete [] m_cache_data[i];
    671           }
    672           delete [] m_cache_data;
    673       }
    674       //////////////////////////////////////////
    675       uint32_t read ( const uint32_t &way,
    676                       const uint32_t &set,
    677                       const uint32_t &word) const
    678       {
    679           assert((set  < m_sets ) && "Cache data error: Trying to read a wrong set" );
    680           assert((way  < m_ways ) && "Cache data error: Trying to read a wrong way" );
    681           assert((word < m_words) && "Cache data error: Trying to read a wrong word");
    682 
    683           return m_cache_data[way][set][word];
    684       }
    685       //////////////////////////////////////////
    686       void read_line( const uint32_t &way,
    687                       const uint32_t &set,
    688                       sc_core::sc_signal<uint32_t> * cache_line)
    689       {
    690           assert((set < m_sets ) && "Cache data error: Trying to read a wrong set" );
    691           assert((way < m_ways ) && "Cache data error: Trying to read a wrong way" );
    692 
    693           for (uint32_t word=0; word<m_words; word++)
    694               cache_line[word].write(m_cache_data[way][set][word]);
    695       }
    696       /////////////////////////////////////////
    697       void write ( const uint32_t &way,
    698                    const uint32_t &set,
    699                    const uint32_t &word,
    700                    const uint32_t &data,
    701                    const uint32_t &be = 0xF)
    702       {
    703 
    704           assert((set  < m_sets ) && "Cache data error: Trying to write a wrong set" );
    705           assert((way  < m_ways ) && "Cache data error: Trying to write a wrong way" );
    706           assert((word < m_words) && "Cache data error: Trying to write a wrong word");
    707           assert((be  <= 0xF    ) && "Cache data error: Trying to write a wrong be");
    708 
    709           if (be == 0x0) return;
    710 
    711           if (be == 0xF)
    712           {
    713               m_cache_data[way][set][word] = data;
    714               return;
    715           }
    716 
    717           uint32_t mask = 0;
    718           if  (be & 0x1) mask = mask | 0x000000FF;
    719           if  (be & 0x2) mask = mask | 0x0000FF00;
    720           if  (be & 0x4) mask = mask | 0x00FF0000;
    721           if  (be & 0x8) mask = mask | 0xFF000000;
    722 
    723           m_cache_data[way][set][word] =
    724               (data & mask) | (m_cache_data[way][set][word] & ~mask);
    725       }
    726   }; // end class CacheData
     639        ///////////////////////////////////////////////////////
     640        CacheData(uint32_t ways, uint32_t sets, uint32_t words)
     641            : m_sets(sets), m_ways(ways), m_words(words)
     642        {
     643            m_cache_data = new uint32_t ** [ways];
     644            for (size_t i = 0; i < ways; i++)
     645            {
     646                m_cache_data[i] = new uint32_t * [sets];
     647            }
     648            for (size_t i = 0; i < ways; i++)
     649            {
     650                for (size_t j = 0; j < sets; j++)
     651                {
     652                    m_cache_data[i][j] = new uint32_t[words];
     653                    // Init to avoid potential errors from memory checkers
     654                    std::memset(m_cache_data[i][j], 0, sizeof(uint32_t) * words);
     655                }
     656            }
     657        }
     658        ////////////
     659        ~CacheData()
     660        {
     661            for (size_t i = 0; i < m_ways; i++)
     662            {
     663                for (size_t j = 0; j < m_sets; j++)
     664                {
     665                    delete [] m_cache_data[i][j];
     666                }
     667            }
     668            for (size_t i = 0; i < m_ways; i++)
     669            {
     670                delete [] m_cache_data[i];
     671            }
     672            delete [] m_cache_data;
     673        }
     674        //////////////////////////////////////////
     675        uint32_t read (const uint32_t &way,
     676                const uint32_t &set,
     677                const uint32_t &word) const
     678        {
     679            assert((set  < m_sets)  && "Cache data error: Trying to read a wrong set" );
     680            assert((way  < m_ways)  && "Cache data error: Trying to read a wrong way" );
     681            assert((word < m_words) && "Cache data error: Trying to read a wrong word");
     682
     683            return m_cache_data[way][set][word];
     684        }
     685        //////////////////////////////////////////
     686        void read_line(const uint32_t &way,
     687                const uint32_t &set,
     688                sc_core::sc_signal<uint32_t> * cache_line)
     689        {
     690            assert((set < m_sets) && "Cache data error: Trying to read a wrong set" );
     691            assert((way < m_ways) && "Cache data error: Trying to read a wrong way" );
     692
     693            for (uint32_t word = 0; word < m_words; word++) {
     694                cache_line[word].write(m_cache_data[way][set][word]);
     695            }
     696        }
     697        /////////////////////////////////////////
     698        void write (const uint32_t &way,
     699                const uint32_t &set,
     700                const uint32_t &word,
     701                const uint32_t &data,
     702                const uint32_t &be = 0xF)
     703        {
     704
     705            assert((set  < m_sets)  && "Cache data error: Trying to write a wrong set" );
     706            assert((way  < m_ways)  && "Cache data error: Trying to write a wrong way" );
     707            assert((word < m_words) && "Cache data error: Trying to write a wrong word");
     708            assert((be  <= 0xF)     && "Cache data error: Trying to write a wrong be");
     709
     710            if (be == 0x0) return;
     711
     712            if (be == 0xF)
     713            {
     714                m_cache_data[way][set][word] = data;
     715                return;
     716            }
     717
     718            uint32_t mask = 0;
     719            if (be & 0x1) mask = mask | 0x000000FF;
     720            if (be & 0x2) mask = mask | 0x0000FF00;
     721            if (be & 0x4) mask = mask | 0x00FF0000;
     722            if (be & 0x8) mask = mask | 0xFF000000;
     723
     724            m_cache_data[way][set][word] =
     725                (data & mask) | (m_cache_data[way][set][word] & ~mask);
     726        }
     727}; // end class CacheData
    727728
    728729}} // end namespaces

  • trunk/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r752 r836  
    6464  template<typename vci_param_int,
    6565           typename vci_param_ext,
    66            size_t   dspin_in_width,
    67            size_t   dspin_out_width>
     66           size_t   memc_dspin_in_width,
     67           size_t   memc_dspin_out_width>
    6868    class VciMemCache
    6969    : public soclib::caba::BaseModule
    … …  
    470470      soclib::caba::VciTarget<vci_param_int>      p_vci_tgt;
    471471      soclib::caba::VciInitiator<vci_param_ext>   p_vci_ixr;
    472       soclib::caba::DspinInput<dspin_in_width>    p_dspin_p2m;
    473       soclib::caba::DspinOutput<dspin_out_width>  p_dspin_m2p;
    474       soclib::caba::DspinOutput<dspin_out_width>  p_dspin_clack;
     472      soclib::caba::DspinInput<memc_dspin_in_width>    p_dspin_p2m;
     473      soclib::caba::DspinOutput<memc_dspin_out_width>  p_dspin_m2p;
     474      soclib::caba::DspinOutput<memc_dspin_out_width>  p_dspin_clack;
    475475
    476476#if MONITOR_MEMCACHE_FSM == 1

  • trunk/modules/vci_mem_cache/caba/source/include/xram_transaction.h

    r601 r836  
    1515class TransactionTabEntry
    1616{
    17     typedef sc_dt::sc_uint<64>    wide_data_t;
    18     typedef sc_dt::sc_uint<40>    addr_t;
    19     typedef uint32_t              data_t;
    20     typedef uint32_t              be_t;
     17    typedef sc_dt::sc_uint<64> wide_data_t;
     18    typedef sc_dt::sc_uint<40> addr_t;
     19    typedef uint32_t data_t;
     20    typedef uint32_t be_t;
    2121
    2222    public:
    23     bool                        valid;              // entry valid
    24     bool                        xram_read;          // read request to XRAM
    25     addr_t              nline;              // index (zy) of the requested line
    26     size_t                  srcid;          // processor requesting the transaction
    27     size_t                  trdid;          // processor requesting the transaction
    28     size_t                  pktid;          // processor requesting the transaction
    29     bool                        proc_read;          // read request from processor
    30     size_t                  read_length;    // length of the read (for the response)
    31     size_t                  word_index;         // index of the first read word (for response)
    32     std::vector<data_t> wdata;          // write buffer (one cache line)
    33     std::vector<be_t>   wdata_be;       // be for each data in the write buffer
    34     bool                rerror;         // error returned by xram
    35     data_t              ll_key;         // LL key returned by the llsc_global_table
    36     bool                config;         // transaction required by CONFIG FSM
     23    bool   valid;                 // entry valid
     24    bool   xram_read;             // read request to XRAM
     25    addr_t nline;                 // index (zy) of the requested line
     26    size_t srcid;                 // processor requesting the transaction
     27    size_t trdid;                 // processor requesting the transaction
     28    size_t pktid;                 // processor requesting the transaction
     29    bool   proc_read;             // read request from processor
     30    size_t read_length;           // length of the read (for the response)
     31    size_t word_index;            // index of the first read word (for response)
     32    std::vector<data_t> wdata;    // write buffer (one cache line)
     33    std::vector<be_t>   wdata_be; // be for each data in the write buffer
     34    bool    rerror;               // error returned by xram
     35    data_t  ll_key;               // LL key returned by the llsc_global_table
     36    bool    config;               // transaction required by CONFIG FSM
    3737
    3838    /////////////////////////////////////////////////////////////////////
    … …  
    4141    void init()
    4242    {
    43         valid           = false;
    44         rerror      = false;
    45         config      = false;
     43        valid  = false;
     44        rerror = false;
     45        config = false;
    4646    }
    4747
    … …  
    5252    void alloc(size_t n_words)
    5353    {
    54         wdata_be.reserve( (int)n_words );
    55         wdata.reserve( (int)n_words );
    56         for(size_t i=0; i<n_words; i++)
     54        wdata_be.reserve((int) n_words);
     55        wdata.reserve((int) n_words);
     56        for (size_t i = 0; i < n_words; i++)
    5757        {
    5858            wdata_be.push_back(0);
    … …  
    6666    void copy(const TransactionTabEntry &source)
    6767    {
    68         valid       = source.valid;
    69         xram_read       = source.xram_read;
    70         nline       = source.nline;
    71         srcid       = source.srcid;
    72         trdid       = source.trdid;
    73         pktid       = source.pktid;
    74         proc_read       = source.proc_read;
     68        valid       = source.valid;
     69        xram_read   = source.xram_read;
     70        nline       = source.nline;
     71        srcid       = source.srcid;
     72        trdid       = source.trdid;
     73        pktid       = source.pktid;
     74        proc_read   = source.proc_read;
    7575        read_length = source.read_length;
    76         word_index      = source.word_index;
     76        word_index  = source.word_index;
    7777        wdata_be.assign(source.wdata_be.begin(),source.wdata_be.end());
    7878        wdata.assign(source.wdata.begin(),source.wdata.end());
    … …  
    8585    // The print() function prints the entry identified by "index".
    8686    ////////////////////////////////////////////////////////////////////
    87     void print( size_t index, size_t mode )
     87    void print(size_t index, size_t mode)
    8888    {
    8989        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 )
     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)
    9797        {
    9898            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;
     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;
    104104            std::cout << "        wdata = ";
    105             for(size_t i=0; i<wdata.size() ; i++)
     105            for (size_t i = 0; i < wdata.size(); i++)
    106106            {
    107107                std::cout << std::hex << wdata[i] << " / ";
    … …  
    112112
    113113    /////////////////////////////////////////////////////////////////////
    114     //          Constructors
     114    //         Constructors
    115115    /////////////////////////////////////////////////////////////////////
    116116
    … …  
    126126    TransactionTabEntry(const TransactionTabEntry &source)
    127127    {
    128         valid       = source.valid;
    129         xram_read       = source.xram_read;
    130         nline       = source.nline;
    131         srcid       = source.srcid;
    132         trdid       = source.trdid;
    133         pktid       = source.pktid;
    134         proc_read       = source.proc_read;
     128        valid       = source.valid;
     129        xram_read   = source.xram_read;
     130        nline       = source.nline;
     131        srcid       = source.srcid;
     132        trdid       = source.trdid;
     133        pktid       = source.pktid;
     134        proc_read   = source.proc_read;
    135135        read_length = source.read_length;
    136         word_index      = source.word_index;
    137         wdata_be.assign(source.wdata_be.begin(),source.wdata_be.end());
    138         wdata.assign(source.wdata.begin(),source.wdata.end()); 
     136        word_index  = source.word_index;
     137        wdata_be.assign(source.wdata_be.begin(), source.wdata_be.end());
     138        wdata.assign(source.wdata.begin(), source.wdata.end());   
    139139        rerror      = source.rerror;
    140140        ll_key      = source.ll_key;
    … …  
    149149class TransactionTab
    150150{
    151     typedef sc_dt::sc_uint<64>    wide_data_t;
    152     typedef sc_dt::sc_uint<40>    addr_t;
    153     typedef uint32_t              data_t;
    154     typedef uint32_t              be_t;
     151    typedef sc_dt::sc_uint<64> wide_data_t;
     152    typedef sc_dt::sc_uint<40> addr_t;
     153    typedef uint32_t           data_t;
     154    typedef uint32_t           be_t;
    155155
    156156    private:
    157     const std::string tab_name;                // the name for logs
    158     size_t            size_tab;                // the size of the tab
     157    const std::string tab_name; // the name for logs
     158    size_t size_tab; // the size of the tab
    159159
    160160    data_t be_to_mask(be_t be)
    161161    {
    162162        data_t ret = 0;
    163         if ( be&0x1 ) {
     163        if (be & 0x1) {
    164164            ret = ret | 0x000000FF;
    165165        }
    166         if ( be&0x2 ) {
     166        if (be & 0x2) {
    167167            ret = ret | 0x0000FF00;
    168168        }
    169         if ( be&0x4 ) {
     169        if (be & 0x4) {
    170170            ret = ret | 0x00FF0000;
    171171        }
    172         if ( be&0x8 ) {
     172        if (be & 0x8) {
    173173            ret = ret | 0xFF000000;
    174174        }
    … …  
    177177
    178178    public:
    179     TransactionTabEntry *tab;      // The transaction tab
    180 
    181     ////////////////////////////////////////////////////////////////////
    182     //          Constructors
     179    TransactionTabEntry * tab; // The transaction tab
     180
     181    ////////////////////////////////////////////////////////////////////
     182    //        Constructors
    183183    ////////////////////////////////////////////////////////////////////
    184184    TransactionTab()
    185185    {
    186         size_tab=0;
    187         tab=NULL;
     186        size_tab = 0;
     187        tab = NULL;
    188188    }
    189189
    190190    TransactionTab(const std::string &name,
    191                    size_t            n_entries,
    192                    size_t            n_words )
    193     : tab_name( name ),
    194       size_tab( n_entries )
     191            size_t n_entries,
     192            size_t n_words)
     193        : tab_name(name),
     194        size_tab(n_entries)
    195195    {
    196196        tab = new TransactionTabEntry[size_tab];
    197         for ( size_t i=0; i<size_tab; i++)
     197        for (size_t i = 0; i < size_tab; i++)
    198198        {
    199199            tab[i].alloc(n_words);
    … …  
    217217    void init()
    218218    {
    219         for ( size_t i=0; i<size_tab; i++)
     219        for (size_t i = 0; i < size_tab; i++)
    220220        {
    221221            tab[i].init();
    … …  
    226226    // Detailed content if detailed argument is non zero.
    227227    /////////////////////////////////////////////////////////////////////
    228     void print( size_t detailed = 0 )
     228    void print(size_t detailed = 0)
    229229    {
    230230        std::cout << "  < TRT content in " <<  tab_name << " >" << std::endl;
    231         for ( size_t id = 0 ; id < size_tab ; id++ )
     231        for (size_t id = 0; id < size_tab; id++)
    232232        {
    233233            tab[id].print( id , detailed );
    … …  
    241241    TransactionTabEntry read(const size_t index)
    242242    {
    243         assert( (index < size_tab) and
    244         "MEMC ERROR: Invalid Transaction Tab Entry");
     243        assert((index < size_tab) and "MEMC ERROR: Invalid Transaction Tab Entry");
    245244
    246245        return tab[index];
    … …  
    252251    // The function returns true if the transaction tab is full
    253252    /////////////////////////////////////////////////////////////////////
    254     bool full(size_t &index)
    255     {
    256         for(size_t i=0; i<size_tab; i++)
    257         {
    258             if(!tab[i].valid)
     253    bool full(size_t & index)
     254    {
     255        for (size_t i = 0; i < size_tab; i++)
     256        {
     257            if (!tab[i].valid)
    259258            {
    260                 index=i;
    261                 return false;   
     259                index = i;
     260                return false;   
    262261            }
    263262        }
    … …  
    274273    bool hit_read(const addr_t nline,size_t &index)
    275274    {
    276         for(size_t i=0; i<size_tab; i++)
    277         {
    278             if((tab[i].valid && (nline==tab[i].nline)) && (tab[i].xram_read))
     275        for (size_t i = 0; i < size_tab; i++)
     276        {
     277            if ((tab[i].valid && (nline == tab[i].nline)) && (tab[i].xram_read))
    279278            {
    280                 index=i;
    281                 return true;   
     279                index = i;
     280                return true;   
    282281            }
    283282        }
    … …  
    293292    bool hit_write(const addr_t nline)
    294293    {
    295         for(size_t i=0; i<size_tab; i++)
    296         {
    297             if(tab[i].valid && (nline==tab[i].nline) && !(tab[i].xram_read))
     294        for (size_t i = 0; i < size_tab; i++)
     295        {
     296            if (tab[i].valid && (nline == tab[i].nline) && !(tab[i].xram_read))
    298297            {
    299                 return true;   
     298                return true;   
    300299            }
    301300        }
    … …  
    312311    /////////////////////////////////////////////////////////////////////
    313312    void write_data_mask(const size_t index,
    314             const std::vector<be_t> &be,
    315             const std::vector<data_t> &data)
     313            const std::vector<be_t> & be,
     314            const std::vector<data_t> & data)
    316315    {
    317316        assert( (index < size_tab) and
    318         "MEMC ERROR: The selected entry is out of range in TRT write_data_mask()");
    319 
    320         assert( (be.size()==tab[index].wdata_be.size()) and
    321         "MEMC ERROR: Bad be size in TRT write_data_mask()");
    322 
    323         assert( (data.size()==tab[index].wdata.size()) and
    324         "MEMC ERROR: Bad data size in TRT write_data_mask()");
    325 
    326         for(size_t i=0; i<tab[index].wdata_be.size() ; i++)
     317                "MEMC ERROR: The selected entry is out of range in TRT write_data_mask()");
     318
     319        assert( (be.size() == tab[index].wdata_be.size()) and
     320                "MEMC ERROR: Bad be size in TRT write_data_mask()");
     321
     322        assert( (data.size() == tab[index].wdata.size()) and
     323                "MEMC ERROR: Bad data size in TRT write_data_mask()");
     324
     325        for (size_t i = 0; i < tab[index].wdata_be.size(); i++)
    327326        {
    328327            tab[index].wdata_be[i] = tab[index].wdata_be[i] | be[i];
    … …  
    358357            const size_t read_length,
    359358            const size_t word_index,
    360             const std::vector<be_t> &data_be,
    361             const std::vector<data_t> &data,
     359            const std::vector<be_t> & data_be,
     360            const std::vector<data_t> & data,
    362361            const data_t ll_key = 0,
    363362            const bool config = false)
    364363    {
    365         assert( (index < size_tab) and
    366         "MEMC ERROR: The selected entry is out of range in TRT set()");
    367 
    368         assert( (data_be.size()==tab[index].wdata_be.size()) and
    369         "MEMC ERROR: Bad data_be argument in TRT set()");
    370 
    371         assert( (data.size()==tab[index].wdata.size()) and
    372         "MEMC ERROR: Bad data argument in TRT set()");
    373 
    374         tab[index].valid                = true;
    375         tab[index].xram_read        = xram_read;
    376         tab[index].nline                = nline;
    377         tab[index].srcid                = srcid;
    378         tab[index].trdid                = trdid;
    379         tab[index].pktid                = pktid;
    380         tab[index].proc_read        = proc_read;
    381         tab[index].read_length      = read_length;
    382         tab[index].word_index       = word_index;
    383         tab[index].ll_key           = ll_key;
    384         tab[index].config           = config;
    385         for(size_t i=0; i<tab[index].wdata.size(); i++)
    386         {
    387             tab[index].wdata_be[i]    = data_be[i];
    388             tab[index].wdata[i]       = data[i];
     364        assert((index < size_tab) and
     365                "MEMC ERROR: The selected entry is out of range in TRT set()");
     366
     367        assert((data_be.size()==tab[index].wdata_be.size()) and
     368                "MEMC ERROR: Bad data_be argument in TRT set()");
     369
     370        assert((data.size()==tab[index].wdata.size()) and
     371                "MEMC ERROR: Bad data argument in TRT set()");
     372
     373        tab[index].valid       = true;
     374        tab[index].xram_read   = xram_read;
     375        tab[index].nline       = nline;
     376        tab[index].srcid       = srcid;
     377        tab[index].trdid       = trdid;
     378        tab[index].pktid       = pktid;
     379        tab[index].proc_read   = proc_read;
     380        tab[index].read_length = read_length;
     381        tab[index].word_index  = word_index;
     382        tab[index].ll_key      = ll_key;
     383        tab[index].config      = config;
     384        for (size_t i = 0; i < tab[index].wdata.size(); i++)
     385        {
     386            tab[index].wdata_be[i] = data_be[i];
     387            tab[index].wdata[i]    = data[i];
    389388        }
    390389    }
    … …  
    399398    // - data  : 64 bits value (first data right)
    400399    /////////////////////////////////////////////////////////////////////
    401     void write_rsp(const size_t      index,
    402                    const size_t      word,
    403                    const wide_data_t data,
    404                    const bool        rerror)
    405     {
    406         data_t  value;
    407         data_t  mask;
    408 
    409         assert( (index < size_tab) and
    410         "MEMC ERROR: The selected entry is out of range in TRT write_rsp()");
    411 
    412         assert( (word < tab[index].wdata_be.size()) and
    413         "MEMC ERROR: Bad word index in TRT write_rsp()");
    414 
    415         assert( (tab[index].valid) and
    416         "MEMC ERROR: TRT entry not valid in TRT write_rsp()");
    417 
    418         assert( (tab[index].xram_read ) and
    419         "MEMC ERROR: TRT entry is not a GET in TRT write_rsp()");
    420 
    421         if ( rerror )
     400    void write_rsp(const size_t index,
     401            const size_t        word,
     402            const wide_data_t  data,
     403            const bool          rerror)
     404    {
     405        data_t value;
     406        data_t mask;
     407
     408        assert((index < size_tab) and
     409                "MEMC ERROR: The selected entry is out of range in TRT write_rsp()");
     410
     411        assert((word < tab[index].wdata_be.size()) and
     412                "MEMC ERROR: Bad word index in TRT write_rsp()");
     413
     414        assert((tab[index].valid) and
     415                "MEMC ERROR: TRT entry not valid in TRT write_rsp()");
     416
     417        assert((tab[index].xram_read ) and
     418                "MEMC ERROR: TRT entry is not a GET in TRT write_rsp()");
     419
     420        if (rerror)
    422421        {
    423422            tab[index].rerror = true;
    … …  
    426425
    427426        // first 32 bits word
    428         value = (data_t)data;
     427        value = (data_t) data;
    429428        mask  = be_to_mask(tab[index].wdata_be[word]);
    430429        tab[index].wdata[word] = (tab[index].wdata[word] & mask) | (value & ~mask);
    431430
    432431        // second 32 bits word
    433         value = (data_t)(data>>32);
    434         mask  = be_to_mask(tab[index].wdata_be[word+1]);
    435         tab[index].wdata[word+1] = (tab[index].wdata[word+1] & mask) | (value & ~mask);
     432        value = (data_t) (data >> 32);
     433        mask  = be_to_mask(tab[index].wdata_be[word + 1]);
     434        tab[index].wdata[word + 1] = (tab[index].wdata[word + 1] & mask) | (value & ~mask);
    436435    }
    437436    /////////////////////////////////////////////////////////////////////
    … …  
    443442    {
    444443        assert( (index < size_tab) and
    445         "MEMC ERROR: The selected entry is out of range in TRT erase()");
    446 
    447         tab[index].valid        = false;
    448         tab[index].rerror   = false;
     444                "MEMC ERROR: The selected entry is out of range in TRT erase()");
     445
     446        tab[index].valid  = false;
     447        tab[index].rerror = false;
    449448    }
    450449    /////////////////////////////////////////////////////////////////////
    … …  
    456455    {
    457456        assert( (index < size_tab) and
    458         "MEMC ERROR: The selected entry is out of range in TRT is_config()");
     457                "MEMC ERROR: The selected entry is out of range in TRT is_config()");
    459458
    460459        return tab[index].config;

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

    r811 r836  
    319319    template<typename vci_param_int, \
    320320    typename vci_param_ext, \
    321     size_t dspin_in_width,  \
    322     size_t dspin_out_width> x \
    323     VciMemCache<vci_param_int, vci_param_ext, dspin_in_width, dspin_out_width>
     321    size_t memc_dspin_in_width,  \
     322    size_t memc_dspin_out_width> x \
     323    VciMemCache<vci_param_int, vci_param_ext, memc_dspin_in_width, memc_dspin_out_width>
    324324
    325325    using namespace soclib::common;
Note: See TracChangeset for help on using the changeset viewer.