Ignore:
Timestamp:
May 12, 2010, 7:34:01 PM (14 years ago)
Author:
rosiere
Message:

1) add counters_t type for interface
2) fix in check load in load_store_unit
3) add parameters (but not yet implemented)
4) change environment and add script (distcc_env.sh ...)
5) add warning if an unser change rename flag with l.mtspr instruction
6) ...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_msg_error.cpp

    r128 r138  
    2424    Parameters_test test ("Core");
    2525
    26     // TESTER SI LES VALEURS NE DEPASSE PAS DE L'INTERVALLE AUTORISE
    27 
     26    // Test if value is valid
    2827    {
    2928      // initialisation
    … …  
    191190          uint32_t num_execute_loop = _link_execute_unit_with_load_store_unit [i].first;
    192191          uint32_t num_execute_unit = _link_execute_unit_with_load_store_unit [i].second;
     192
     193          log_printf(TRACE,Core,FUNCTION,"  * _link_execute_unit_with_load_store_unit  [%d] = %d.%d",i,num_execute_loop,num_execute_unit);
    193194
    194195          nb_link_execute_unit [num_execute_loop][num_execute_unit] ++;
    … …  
    224225   
    225226    {
    226       // initialisation
    227       uint32_t nb_link_slot      [_nb_ooo_engine][max<uint32_t>(_nb_inst_issue_slot,_nb_ooo_engine)];
    228       uint32_t nb_link_read_bloc [_nb_read_bloc];
    229  
    230       // initialisation
    231       for (uint32_t i=0; i<_nb_ooo_engine; ++i)
    232         for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
    233           nb_link_slot [i][j] = 0;
     227      bool     read_bloc_link_with_load_store_unit  [_nb_read_bloc];
     228      bool     read_bloc_link_with_functionnal_unit [_nb_read_bloc];
     229      uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
     230     
    234231      for (uint32_t i=0; i<_nb_read_bloc; ++i)
    235         nb_link_read_bloc [i] = 0;
    236 
    237       // set link
    238       for (uint32_t i=0; i<_nb_ooo_engine; ++i)
    239         for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
    240           for (uint32_t k=0; k<_nb_read_bloc; ++k)
    241             if (_table_dispatch [i][j][k])
    242               {
    243                 nb_link_slot      [i][j] ++;
    244                 nb_link_read_bloc [k] ++;
    245               }
    246      
    247       // test
    248       for (uint32_t i=0; i<_nb_ooo_engine; ++i)
    249         for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
    250           if (nb_link_slot [i][j] == 0)
    251             test.error(toString(_("In Out Of Order Engine [%d], the slot issue [%d] is not link with a read_bloc.\n"),i,j));
     232        {
     233          read_bloc_link_with_load_store_unit  [i] = false;
     234          read_bloc_link_with_functionnal_unit [i] = false;
     235        }
     236      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
     237        nb_link_functionnal_unit [i] = 0;
     238     
     239      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
     240        read_bloc_link_with_load_store_unit [_link_read_bloc_with_load_store_unit[i]] = true;
     241     
    252242      for (uint32_t i=0; i<_nb_read_bloc; ++i)
    253         if (nb_link_read_bloc [i] == 0)
    254           test.error(toString(_("Read_bloc [%d] is not link with a issue's slot.\n"),i));
    255     }
    256 
    257     {
    258       uint32_t nb_link_read_bloc        [_nb_read_bloc];
    259       uint32_t nb_link_load_store_unit  [_nb_load_store_unit];
    260       uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
     243        for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
     244          if (_link_read_bloc_and_functionnal_unit [i][j])
     245            {
     246              nb_link_functionnal_unit [j] ++;
     247              read_bloc_link_with_functionnal_unit [i] = true;
     248            }
    261249
    262250      for (uint32_t i=0; i<_nb_read_bloc; ++i)
    263         nb_link_read_bloc [i] = 0;
    264       for (uint32_t i=0; i<_nb_load_store_unit; ++i)
    265         nb_link_load_store_unit [i] = 0;
    266       for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
    267         nb_link_functionnal_unit [i] = 0;
    268 
    269       for (uint32_t i=0; i<_nb_read_bloc; ++i)
    270         {
    271           for (uint32_t j=0; j<_nb_load_store_unit; ++j)
    272             if (_link_read_bloc_and_load_store_unit [i][j])
    273               {
    274                 nb_link_read_bloc        [i] ++;
    275                 nb_link_load_store_unit  [j] ++;
    276               }
    277           for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
    278             if (_link_read_bloc_and_functionnal_unit [i][j])
    279               {
    280                 nb_link_read_bloc        [i] ++;
    281                 nb_link_functionnal_unit [j] ++;
    282               }
    283         }
    284 
    285       for (uint32_t i=0; i<_nb_read_bloc; ++i)
    286         if (nb_link_read_bloc [i] == 0)
    287           test.error(toString(_("Read_bloc [%d] is not link with an execute_unit.\n"),i));
    288       for (uint32_t i=0; i<_nb_load_store_unit; ++i)
    289         if (nb_link_load_store_unit [i] == 0)
    290           test.error(toString(_("load_store_unit [%d] is not link with a read_bloc.\n"),i));
     251        {
     252          if (not read_bloc_link_with_load_store_unit  [i] and
     253              not read_bloc_link_with_functionnal_unit [i])
     254            test.error(toString(_("Read_bloc [%d] is not link with an execute_unit.\n"),i));
     255          if (    read_bloc_link_with_load_store_unit  [i] and
     256                  read_bloc_link_with_functionnal_unit [i])
     257            test.error(toString(_("Read_bloc [%d] is linked with an load store unit and functionnal unit.\n"),i));
     258        }
    291259      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
    292260        if (nb_link_functionnal_unit [i] == 0)
    … …  
    296264    {
    297265      uint32_t nb_link_write_bloc       [_nb_write_bloc];
    298       uint32_t nb_link_load_store_unit  [_nb_load_store_unit];
    299266      uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
    300267
    301268      for (uint32_t i=0; i<_nb_write_bloc; ++i)
    302269        nb_link_write_bloc [i] = 0;
    303       for (uint32_t i=0; i<_nb_load_store_unit; ++i)
    304         nb_link_load_store_unit [i] = 0;
    305270      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
    306271        nb_link_functionnal_unit [i] = 0;
    307272
     273      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
     274        nb_link_write_bloc [_link_write_bloc_with_load_store_unit[i]] = true;
     275
    308276      for (uint32_t i=0; i<_nb_write_bloc; ++i)
    309         {
    310           for (uint32_t j=0; j<_nb_load_store_unit; ++j)
    311             if (_link_write_bloc_and_load_store_unit [i][j])
    312               {
    313                 nb_link_write_bloc       [i] ++;
    314                 nb_link_load_store_unit  [j] ++;
    315               }
    316           for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
    317             if (_link_write_bloc_and_functionnal_unit [i][j])
    318               {
    319                 nb_link_write_bloc       [i] ++;
    320                 nb_link_functionnal_unit [j] ++;
    321               }
    322         }
     277        for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
     278          if (_link_write_bloc_and_functionnal_unit [i][j])
     279            {
     280              nb_link_write_bloc       [i] ++;
     281              nb_link_functionnal_unit [j] ++;
     282            }
    323283
    324284      for (uint32_t i=0; i<_nb_write_bloc; ++i)
    325285        if (nb_link_write_bloc [i] == 0)
    326286          test.error(toString(_("Write_bloc [%d] is not link with an execute_unit.\n"),i));
    327       for (uint32_t i=0; i<_nb_load_store_unit; ++i)
    328         if (nb_link_load_store_unit [i] == 0)
    329           test.error(toString(_("load_store_unit [%d] is not link with a write_bloc.\n"),i));
    330287      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
    331288        if (nb_link_functionnal_unit [i] == 0)
    … …  
    334291
    335292    {
    336       uint32_t nb_link_thread           [_nb_thread];
    337       uint32_t nb_link_load_store_unit  [_nb_load_store_unit];
    338       uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
     293      uint32_t nb_link_thread                      [_nb_thread];
     294      uint32_t nb_link_load_store_unit             [_nb_load_store_unit];
     295      uint32_t nb_link_functionnal_unit            [_nb_functionnal_unit];
     296      bool     link_front_end_with_execute_loop    [_nb_front_end][_nb_execute_loop];
     297      uint32_t nb_link_front_end_with_execute_loop [_nb_front_end];
    339298
    340299      for (uint32_t i=0; i<_nb_thread; ++i)
    … …  
    344303      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
    345304        nb_link_functionnal_unit [i] = 0;
    346      
    347       for (uint32_t i=0; i<_nb_thread; ++i)
    348         {
     305      for (uint32_t i=0; i<_nb_front_end; ++i)
     306        {
     307          nb_link_front_end_with_execute_loop [i] = 0;
     308          for (uint32_t j=0; j<_nb_execute_loop; ++j)
     309            link_front_end_with_execute_loop [i][j] = false;
     310        }
     311
     312      for (uint32_t i=0; i<_nb_thread; ++i)
     313        {
     314          uint32_t num_front_end = _link_context_with_thread [i].first;
     315
    349316          {
    350317            uint32_t num_load_store_unit = _link_load_store_unit_with_thread [i];
     318            uint32_t num_execute_loop    = _link_execute_unit_with_load_store_unit [i].first;
    351319           
    352320            nb_link_thread           [i] ++;
    353321            nb_link_load_store_unit  [num_load_store_unit] ++;
     322
     323            if (not link_front_end_with_execute_loop [num_front_end][num_execute_loop])
     324              nb_link_front_end_with_execute_loop [num_front_end] ++;
     325            link_front_end_with_execute_loop [num_front_end][num_execute_loop] = true;
    354326          }
    355327
    … …  
    357329            if (_link_thread_and_functionnal_unit [i][j])
    358330              {
     331                uint32_t num_execute_loop = _link_execute_unit_with_functionnal_unit [i].first;
     332
    359333                nb_link_thread           [i] ++;
    360334                nb_link_functionnal_unit [j] ++;
     335               
     336                if (not link_front_end_with_execute_loop [num_front_end][num_execute_loop])
     337                  nb_link_front_end_with_execute_loop [num_front_end] ++;
     338                link_front_end_with_execute_loop [num_front_end][num_execute_loop] = true;
    361339              }
    362340        }
    … …  
    371349        if (nb_link_functionnal_unit [i] == 0)
    372350          test.error(toString(_("Functionnal_unit [%d] is not link with a thread.\n"),i));
     351      for (uint32_t i=0; i<_nb_front_end; ++i)
     352        if (nb_link_front_end_with_execute_loop [i] != 1)
     353          test.error(toString(_("Front end [%d] is link with many execute_loop.\n"),i));
    373354    }
    374355   
    … …  
    395376      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
    396377        for (uint32_t j=0; j<_nb_cache_port[i]; ++j)
    397         nb_link_dcache_port [_link_dcache_port_with_load_store_unit[i][j]] ++;
     378          nb_link_dcache_port [_link_dcache_port_with_load_store_unit[i][j]] ++;
    398379     
    399380      for (uint32_t i=0; i<_nb_dcache_port; ++i)
    … …  
    402383    }
    403384
    404 
    405 //   public : pair_dual             * _link_context_with_thread                      ;//[nb_thread]
    406 //   public : pair_dual             * _link_decod_unit_with_decod_bloc               ;//[nb_decod_bloc]
    407 //   public : pair_dual             * _link_rename_unit_with_rename_bloc             ;//[nb_rename_bloc]
    408 //   public : pair_dual             * _link_read_unit_with_read_bloc                 ;//[nb_read_bloc]
    409 //   public : pair_dual             * _link_write_unit_with_write_bloc               ;//[nb_write_bloc]
    410 //   public : pair_dual             * _link_execute_unit_with_functionnal_unit       ;//[nb_functionnal_unit]
    411 //   public : pair_dual             * _link_execute_unit_with_load_store_unit        ;//[nb_load_store_unit]
    412 //   public : uint32_t              * _link_decod_bloc_with_thread                   ;//[nb_thread]
    413 //   public : uint32_t              * _link_rename_bloc_with_front_end               ;//[nb_front_end]
    414 //   public : bool                *** _table_dispatch                                ;//[nb_ooo_engine][nb_inst_issue][nb_read_bloc]
    415 //   public : bool                 ** _link_read_bloc_and_load_store_unit            ;//[nb_read_bloc][nb_load_store_unit]
    416 //   public : bool                 ** _link_read_bloc_and_functionnal_unit           ;//[nb_read_bloc][nb_functionnal_unit]
    417 //   public : bool                 ** _link_write_bloc_and_load_store_unit           ;//[nb_write_bloc][nb_load_store_unit]
    418 //   public : bool                 ** _link_write_bloc_and_functionnal_unit          ;//[nb_write_bloc][nb_functionnal_unit]
    419 //   public : uint32_t              * _link_load_store_unit_with_thread              ;//[nb_thread]
    420 //   public : bool                 ** _link_thread_and_functionnal_unit              ;//[nb_thread][nb_functionnal_unit]
    421 //   public : uint32_t              * _link_icache_port_with_thread                  ;//[nb_thread]
    422 //   public : uint32_t             ** _link_dcache_port_with_load_store_unit         ;//[nb_load_store_unit][nb_cache_port]
    423 
    424385    log_end(Core,FUNCTION);
    425386
Note: See TracChangeset for help on using the changeset viewer.