Ignore:
Timestamp:
Sep 24, 2007, 2:00:35 PM (17 years ago)
Author:
rosiere
Message:

Ajout SystemC read_queue et reservation_station
Ajout port au bloc registerfile_monolithic (à ajouter également au bloc registerfile et registerfile_multi_banked)
Modif param : passage de pointeur (attention, tous les composants n'ont pas été tous modifier)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/SelfTest/src/test.cpp

    r50 r55  
    77 */
    88
    9 #define NB_ITERATION 32
     9#define NB_ITERATION 2
    1010
    1111#include "Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/SelfTest/include/test.h"
    … …  
    1313
    1414void test (string name,
    15            morpheo::behavioural::generic::registerfile::registerfile_monolithic::Parameters param)
     15           morpheo::behavioural::generic::registerfile::registerfile_monolithic::Parameters * _param)
    1616{
    1717  cout << "<" << name << "> : Simulation SystemC" << endl;
    … …  
    1919  try
    2020    {
    21       cout << param.print(1);
    22       param.test();
     21      cout << _param->print(1);
     22      _param->test();
    2323    }
    2424  catch (morpheo::ErrorMorpheo & error)
    … …  
    3333    }
    3434
     35#ifdef STATISTICS
     36  morpheo::behavioural::Parameters_Statistics * _param_stat = new morpheo::behavioural::Parameters_Statistics (5,1000);
     37#endif
    3538  RegisterFile_Monolithic * registerfile = new RegisterFile_Monolithic (name.c_str()
    3639#ifdef STATISTICS
    37                                                                         ,morpheo::behavioural::Parameters_Statistics(5,1000)
     40                                                                        ,_param_stat
    3841#endif
    39                                                                         ,param);
     42                                                                        ,_param);
    4043 
    4144#ifdef SYSTEMC
    … …  
    4649  sc_signal<Tcontrol_t>                    NRESET;
    4750 
    48   sc_signal<Tcontrol_t>                    READ_VAL      [param._nb_port_read];
    49   sc_signal<Tcontrol_t>                    READ_ACK      [param._nb_port_read];
    50   sc_signal<Taddress_t>                    READ_ADDRESS  [param._nb_port_read];
    51   sc_signal<Tdata_t>                       READ_DATA     [param._nb_port_read];
    52 
    53   sc_signal<Tcontrol_t>                    WRITE_VAL     [param._nb_port_write];
    54   sc_signal<Tcontrol_t>                    WRITE_ACK     [param._nb_port_write];
    55   sc_signal<Taddress_t>                    WRITE_ADDRESS [param._nb_port_write];
    56   sc_signal<Tdata_t>                       WRITE_DATA    [param._nb_port_write];
     51  sc_signal<Tcontrol_t>                    READ_VAL      [_param->_nb_port_read];
     52  sc_signal<Tcontrol_t>                    READ_ACK      [_param->_nb_port_read];
     53  sc_signal<Taddress_t>                    READ_ADDRESS  [_param->_nb_port_read];
     54  sc_signal<Tdata_t>                       READ_DATA     [_param->_nb_port_read];
     55
     56  sc_signal<Tcontrol_t>                    WRITE_VAL     [_param->_nb_port_write];
     57  sc_signal<Tcontrol_t>                    WRITE_ACK     [_param->_nb_port_write];
     58  sc_signal<Taddress_t>                    WRITE_ADDRESS [_param->_nb_port_write];
     59  sc_signal<Tdata_t>                       WRITE_DATA    [_param->_nb_port_write];
     60
     61  sc_signal<Tcontrol_t>                    READ_WRITE_VAL     [_param->_nb_port_read_write];
     62  sc_signal<Tcontrol_t>                    READ_WRITE_ACK     [_param->_nb_port_read_write];
     63  sc_signal<Tcontrol_t>                    READ_WRITE_RW      [_param->_nb_port_read_write];
     64  sc_signal<Taddress_t>                    READ_WRITE_ADDRESS [_param->_nb_port_read_write];
     65  sc_signal<Tdata_t>                       READ_WRITE_RDATA   [_param->_nb_port_read_write];
     66  sc_signal<Tdata_t>                       READ_WRITE_WDATA   [_param->_nb_port_read_write];
    5767
    5868  /********************************************************
    … …  
    6575  (*(registerfile->in_NRESET))       (NRESET);
    6676
    67   for (uint32_t i=0; i<param._nb_port_read; i++)
     77  for (uint32_t i=0; i<_param->_nb_port_read; i++)
    6878    {
    6979      (*(registerfile-> in_READ_VAL      [i]))        (READ_VAL      [i]);
    … …  
    7282      (*(registerfile->out_READ_DATA     [i]))        (READ_DATA     [i]);
    7383    }
    74 
    75   for (uint32_t i=0; i<param._nb_port_write; i++)
     84  for (uint32_t i=0; i<_param->_nb_port_write; i++)
    7685    {
    7786      (*(registerfile-> in_WRITE_VAL     [i]))        (WRITE_VAL     [i]);
    … …  
    8089      (*(registerfile-> in_WRITE_DATA    [i]))        (WRITE_DATA    [i]);
    8190    }
     91  for (uint32_t i=0; i<_param->_nb_port_read_write; i++)
     92    {
     93      (*(registerfile-> in_READ_WRITE_VAL     [i])) (READ_WRITE_VAL      [i]);
     94      (*(registerfile->out_READ_WRITE_ACK     [i])) (READ_WRITE_ACK      [i]);
     95      (*(registerfile-> in_READ_WRITE_RW      [i])) (READ_WRITE_RW       [i]);
     96      (*(registerfile-> in_READ_WRITE_ADDRESS [i])) (READ_WRITE_ADDRESS  [i]);
     97      (*(registerfile-> in_READ_WRITE_WDATA   [i])) (READ_WRITE_WDATA    [i]);
     98      (*(registerfile->out_READ_WRITE_RDATA   [i])) (READ_WRITE_RDATA    [i]);
     99    }
    82100 
    83101  cout << "<" << name << "> Start Simulation ............" << endl;
    … …  
    92110  sc_start(0);
    93111 
    94   for (uint32_t i=0; i<param._nb_port_write; i++)
     112  for (uint32_t i=0; i<_param->_nb_port_write; i++)
    95113    WRITE_VAL [i] .write (0);
    96 
    97   for (uint32_t i=0; i<param._nb_port_read; i++)
     114  for (uint32_t i=0; i<_param->_nb_port_read; i++)
    98115    READ_VAL  [i] .write (0);
     116  for (uint32_t i=0; i<_param->_nb_port_read_write; i++)
     117    READ_WRITE_VAL  [i] .write (0);
    99118
    100119  NRESET.write(0);
    … …  
    115134      srand(grain);
    116135
    117       Tdata_t tab [param._nb_word];
    118      
    119       for (uint32_t i=0; i<param._nb_word; i++)
    120         tab[i]= rand()%(1<<(param._size_word-1));
     136      Tdata_t tab [_param->_nb_word];
     137     
     138      for (uint32_t i=0; i<_param->_nb_word; i++)
     139        tab[i]= rand()%(1<<(_param->_size_word-1));
    121140     
    122141      Taddress_t address_next = 0;
    123142      Taddress_t nb_ack = 0;
    124143     
    125       while (nb_ack < param._nb_word)
     144      while (nb_ack < _param->_nb_word)
    126145        {
    127146          cout << "cycle : " << static_cast<uint32_t> (sc_simulation_time()) << endl;
    128147
    129           for (uint32_t num_port=0; num_port < param._nb_port_write; num_port ++)
    130             {
    131               if ((address_next < param._nb_word) and
     148          for (uint32_t num_port=0; num_port < _param->_nb_port_write; num_port ++)
     149            {
     150              if ((address_next < _param->_nb_word) and
    132151                  (WRITE_VAL [num_port].read() == 0))
    133152                {
    … …  
    139158                 
    140159                  // Address can be not a multiple of nb_port_write
    141                   if (address_next >= param._nb_word)
     160                  if (address_next >= _param->_nb_word)
     161                    break;
     162                }
     163            }
     164
     165          for (uint32_t num_port=0; num_port < _param->_nb_port_read_write; num_port ++)
     166            {
     167              if ((address_next < _param->_nb_word) and
     168                  (READ_WRITE_VAL [num_port].read() == 0))
     169                {
     170                  cout << "(" << num_port << ") [" << address_next << "] <= " << tab[address_next] << endl;
     171                 
     172                  READ_WRITE_VAL     [num_port] .write(1);
     173                  READ_WRITE_RW      [num_port] .write(RW_WRITE);
     174                  READ_WRITE_WDATA   [num_port] .write(tab[address_next]);
     175                  READ_WRITE_ADDRESS [num_port] .write(address_next++);
     176                 
     177                  // Address can be not a multiple of nb_port_write
     178                  if (address_next >= _param->_nb_word)
    142179                    break;
    143180                }
    … …  
    147184
    148185          // reset write_val port
    149           for (uint32_t num_port=0; num_port < param._nb_port_write; num_port ++)
     186          for (uint32_t num_port=0; num_port < _param->_nb_port_write; num_port ++)
    150187            {
    151188              if ((WRITE_ACK [num_port].read() == 1) and
    … …  
    156193                }
    157194            }
     195          // reset write_val port
     196          for (uint32_t num_port=0; num_port < _param->_nb_port_read_write; num_port ++)
     197            {
     198              if ((READ_WRITE_ACK [num_port].read() == 1) and
     199                  (READ_WRITE_VAL [num_port].read() == 1))
     200                {
     201                  READ_WRITE_VAL  [num_port] .write(0);
     202                  nb_ack ++;
     203                }
     204            }
    158205
    159206          sc_start(0);
    … …  
    165212      cout << "<" << name << "> 2) Read the RegisterFile (no write)" << endl;
    166213     
    167       Tdata_t read_address [param._nb_port_read];
    168 
    169       while (nb_ack < param._nb_word)
     214      Tdata_t read_address       [_param->_nb_port_read];
     215      Tdata_t read_write_address [_param->_nb_port_read_write];
     216
     217      while (nb_ack < _param->_nb_word)
    170218        {
    171219          cout << "cycle : " << static_cast<uint32_t> (sc_simulation_time()) << endl;
    172220         
    173           for (uint32_t num_port=0; num_port < param._nb_port_read; num_port ++)
    174             {
    175               if ((address_next < param._nb_word) and
     221          for (uint32_t num_port=0; num_port < _param->_nb_port_read; num_port ++)
     222            {
     223              if ((address_next < _param->_nb_word) and
    176224                  (READ_VAL [num_port].read() == 0))
    177225                {
    … …  
    181229                  READ_ADDRESS [num_port].write(read_address [num_port]);
    182230
    183                   if (address_next >= param._nb_word)
    184                     break;
    185                 }
    186             }
     231                  if (address_next >= _param->_nb_word)
     232                    break;
     233                }
     234            }
     235
     236          for (uint32_t num_port=0; num_port < _param->_nb_port_read_write; num_port ++)
     237            {
     238              if ((address_next < _param->_nb_word) and
     239                  (READ_WRITE_VAL [num_port].read() == 0))
     240                {
     241                  read_write_address [num_port] = address_next++;
     242
     243                  READ_WRITE_VAL     [num_port].write(1);
     244                  READ_WRITE_RW      [num_port].write(RW_READ);
     245                  READ_WRITE_ADDRESS [num_port].write(read_write_address [num_port]);
     246
     247                  if (address_next >= _param->_nb_word)
     248                    break;
     249                }
     250            }
     251
    187252
    188253          sc_start(1);
    189254
    190255          // reset write_val port
    191           for (uint32_t num_port=0; num_port < param._nb_port_read; num_port ++)
     256          for (uint32_t num_port=0; num_port < _param->_nb_port_read; num_port ++)
    192257            {
    193258              if ((READ_ACK [num_port].read() == 1) and
    … …  
    199264
    200265                  TEST(Tdata_t,READ_DATA [num_port].read(), tab[read_address [num_port]]);
     266                  nb_ack ++;
     267                }
     268            }
     269
     270          for (uint32_t num_port=0; num_port < _param->_nb_port_read_write; num_port ++)
     271            {
     272              if ((READ_WRITE_ACK [num_port].read() == 1) and
     273                  (READ_WRITE_VAL [num_port].read() == 1))
     274                {
     275                  READ_WRITE_VAL  [num_port] .write(0);
     276
     277                  cout << "(" << num_port << ") [" << read_write_address [num_port] << "] => " << READ_WRITE_RDATA [num_port].read() << endl;
     278
     279                  TEST(Tdata_t,READ_WRITE_RDATA [num_port].read(), tab[read_write_address [num_port]]);
    201280                  nb_ack ++;
    202281                }
Note: See TracChangeset for help on using the changeset viewer.