Ignore:
Timestamp:
May 16, 2009, 4:42:39 PM (15 years ago)
Author:
rosiere
Message:

1) Platforms : add new organization for test
2) Load_Store_Unit : add array to count nb_check in store_queue
3) Issue_queue and Core_Glue : rewrite the issue network
4) Special_Register_Unit : add reset value to register CID
5) Softwares : add multicontext test
6) Softwares : add SPECINT
7) Softwares : add MiBench?
7) Read_queue : inhib access for r0
8) Change Core_Glue (network) - dont yet support priority and load balancing scheme

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/src/Core_Glue_genMealy_issue.cpp

    r115 r117  
    1515namespace core_glue {
    1616
     17  /*
     18      OOO        SLOT     Execute Loop                                 
     19    ---+                      +-----
     20       |  +-----+     +-----+ |     
     21      -+->|     |     |     |-+->   
     22       |  |     |-()->|     | |     
     23      -+->| _ _ |     |     |-+->   
     24       |  | _X_ |-()->|     | |     
     25      -+->|     |     |     | +-----
     26       |  |     |-()->|     |       
     27      -+->|     |     |     | +-----
     28       |  +-----+     |     | |     
     29    ---+  crossbar    | _ _ |-+->   
     30                      | _X_ | |     
     31    ---+              |     |-+->   
     32       |  +-----+     |     | |     
     33      -+->|     |     |     | +-----
     34       |  |     |-()->|     |       
     35      -+->| _ _ |     |     | +-----
     36       |  | _X_ |-()->|     | |     
     37      -+->|     |     |     |-+->   
     38       |  |     |-()->|     | |     
     39      -+->|     |     |     |-+->   
     40       |  +-----+     +-----+ |     
     41    ---+  crossbar   dispatch +-----
     42  */
     43
     44
     45// class num_read_unit_t
     46//   {
     47//   public : const uint32_t num_execute_loop;
     48//   public : const uint32_t num_read_unit;
     49   
     50//   public : num_read_unit_t (uint32_t num_execute_loop,
     51//                             uint32_t num_read_unit) :
     52//     this->num_execute_loop (num_execute_loop),
     53//     this->num_read_unit    (num_read_unit   )
     54//     {};
     55//   }
    1756
    1857#undef  FUNCTION
     
    2362    log_function(Core_Glue,FUNCTION,_name.c_str());
    2463
    25     Tcontrol_t ISSUE_OOO_ENGINE_ACK   [_param->_nb_ooo_engine  ][_param->_max_nb_inst_issue];
    26     Tcontrol_t ISSUE_EXECUTE_LOOP_VAL [_param->_nb_execute_loop][_param->_max_nb_read_unit ];
    27     bool       READ_UNIT_ENABLE       [_param->_nb_execute_loop][_param->_max_nb_read_unit ];
    28 
     64    Tcontrol_t ISSUE_OOO_ENGINE_ACK   [_param->_nb_ooo_engine  ][_param->_max_nb_inst_issue_queue];
     65    Tcontrol_t ISSUE_EXECUTE_LOOP_VAL [_param->_nb_execute_loop][_param->_max_nb_read_unit];
     66    Tcontrol_t READ_UNIT_ENABLE       [_param->_nb_execute_loop][_param->_max_nb_read_unit];
     67    Tcontrol_t SLOT_ENABLE            [_param->_nb_ooo_engine  ][_param->_max_nb_inst_issue_slot];
     68   
    2969    // Init -> all at 0
    3070    for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
    31       for (uint32_t j=0; j<_param->_nb_inst_issue[i]; ++j)
    32         ISSUE_OOO_ENGINE_ACK [i][j] = 0;
     71      {
     72        for (uint32_t j=0; j<_param->_nb_inst_issue_queue[i]; ++j)
     73          ISSUE_OOO_ENGINE_ACK [i][j] = 0;
     74        for (uint32_t j=0; j<_param->_nb_inst_issue_slot[i]; ++j)
     75          SLOT_ENABLE [i][j] = 1;         
     76      }
     77
    3378    for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    3479      for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
    3580        {
    3681          ISSUE_EXECUTE_LOOP_VAL [i][j] = 0;
     82
    3783          // Read unit is enable is signal ack is set
    3884          READ_UNIT_ENABLE       [i][j] = (PORT_READ(in_ISSUE_EXECUTE_LOOP_ACK [i][j]) == 1);
    39           log_printf(TRACE,Core_Glue,FUNCTION,"  * Read_unit [%d][%d] : %d",i,j,READ_UNIT_ENABLE[i][j]);
     85          log_printf(TRACE,Core_Glue,FUNCTION,"  * Read_unit [%d][%d].enable : %d",i,j,READ_UNIT_ENABLE[i][j]);
    4086        }
    4187
     88//     std::list<num_read_unit_t> SLOT_TYPE [_param->_nb_ooo_engine][_param->_max_nb_inst_issue_slot][_param->_nb_type];
     89
     90//     // for each read_unit
     91//     for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
     92//       for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
     93//         // test if this read_unit can receive an instruction
     94//         if (PORT_READ(in_ISSUE_EXECUTE_LOOP_ACK [i][j]) == 1)
     95//           for (uint32_t x=0; x<_nb_ooo_engine; ++x)
     96//             for (uint32_t y=0; y<_nb_inst_issue_slot[y]; ++y)
     97//               // test if can dispatch
     98//               if (_param->_table_dispatch [x][y][i][j])
     99//                 for (uint32_t k=0;k<_param->_nb_type; ++k)
     100//                   // Can receive this type
     101//                   if (_param->_table_dispatch [i][j][k])
     102//                     SLOT_TYPE[x][y][k].push_back(num_read_unit_t(i,j));
     103
     104//     // Select an issue_slot of an ooo_engine
     105//     std::list<generic::priority::select_t> * select_ooo_engine = _priority_ooo_engine->select();
     106//     for (std::list<generic::priority::select_t>::iterator it_ooo_engine=select_ooo_engine->begin();
     107//          it_ooo_engine!=select_ooo_engine->end();
     108//          ++it_ooo_engine)
     109//       {
     110//         // ... get id of the most priotary
     111//         const uint32_t num_ooo_engine      = it_ooo_engine->grp;
     112//         const uint32_t num_inst_issue_slot = it_ooo_engine->elt;
     113
     114//         // Test if this ooo_engine is enable (can be desable if issue in_order)
     115//         if (OOO_ENGINE_ENABLE[num_ooo_engine])
     116//           {
     117
     118//           }
     119//       }
     120
     121    for (uint32_t num_ooo_engine=0; num_ooo_engine<_param->_nb_ooo_engine; ++num_ooo_engine)
     122      for (uint32_t num_inst_issue_queue=0; num_inst_issue_queue<_param->_nb_inst_issue_queue[num_ooo_engine]; ++num_inst_issue_queue)
     123        {
     124          bool find = false;
     125
     126          Tcontrol_t val  = PORT_READ(in_ISSUE_OOO_ENGINE_VAL  [num_ooo_engine][num_inst_issue_queue]);
     127          Ttype_t    type = PORT_READ(in_ISSUE_OOO_ENGINE_TYPE [num_ooo_engine][num_inst_issue_queue]);
     128
     129          log_printf(TRACE,Core_Glue,FUNCTION,"  * num_ooo_engine                : %d",num_ooo_engine      );
     130          log_printf(TRACE,Core_Glue,FUNCTION,"  * num_inst_issue_queue          : %d",num_inst_issue_queue);
     131          log_printf(TRACE,Core_Glue,FUNCTION,"    * val                         : %d",val);
     132          log_printf(TRACE,Core_Glue,FUNCTION,"    * type                        : %d",type);
     133
     134          if (val)
     135            for (uint32_t num_inst_issue_slot=0; num_inst_issue_slot<_param->_nb_inst_issue_slot[num_ooo_engine]; ++num_inst_issue_slot)
     136              {
     137                log_printf(TRACE,Core_Glue,FUNCTION,"    * num_inst_issue_slot         : %d",num_inst_issue_slot);
     138               
     139                // scan all read_unit
     140               
     141                if (SLOT_ENABLE [num_ooo_engine][num_inst_issue_slot])
     142                  for (uint32_t num_execute_loop=0; num_execute_loop<_param->_nb_execute_loop; ++num_execute_loop)
     143                    {
     144                      for (uint32_t num_read_unit=0; num_read_unit<_param->_nb_read_unit[num_execute_loop]; ++num_read_unit)
     145                        {
     146                          Tcontrol_t ack = READ_UNIT_ENABLE [num_execute_loop][num_read_unit];
     147                         
     148                          log_printf(TRACE,Core_Glue,FUNCTION,"      * num_execute_loop          : %d",num_execute_loop);
     149                          log_printf(TRACE,Core_Glue,FUNCTION,"      * num_read_unit             : %d",num_read_unit   );
     150                          log_printf(TRACE,Core_Glue,FUNCTION,"        * read_unit_enable        : %d",ack             );
     151                         
     152                          // test if :
     153                          //  * read_unit can accept an instruction (valid and no previous instruction)
     154                          //  * slot can issue an instruction at this read_unit
     155                          //  * read_unit can accept this type
     156                          if (ack and
     157                              _param->_table_dispatch [num_ooo_engine][num_inst_issue_slot][num_execute_loop][num_read_unit] and
     158                              _param->_table_issue_type [num_execute_loop][num_read_unit][type])
     159                            {
     160                              log_printf(TRACE,Core_Glue,FUNCTION,"  * find !!!");
     161
     162                              // find !
     163                              // Transaction
     164                              READ_UNIT_ENABLE       [num_execute_loop][num_read_unit] = false; // now, this read_unit is busy
     165                              ISSUE_EXECUTE_LOOP_VAL [num_execute_loop][num_read_unit] = 1; // = val
     166                              ISSUE_OOO_ENGINE_ACK   [num_ooo_engine][num_inst_issue_queue] = 1; // = ack
     167                              SLOT_ENABLE            [num_ooo_engine][num_inst_issue_slot]  = false; // now this slot is used
     168                                     
     169                              if (_param->_have_port_context_id)
     170                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_CONTEXT_ID            [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_CONTEXT_ID            [num_ooo_engine][num_inst_issue_queue]));
     171                              if (_param->_have_port_front_end_id)
     172                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_FRONT_END_ID          [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_FRONT_END_ID          [num_ooo_engine][num_inst_issue_queue]));
     173                              if (_param->_have_port_ooo_engine_id)
     174                                {
     175                              Tcontext_t ooo_engine_id = 0;
     176                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OOO_ENGINE_ID         [num_execute_loop][num_read_unit],ooo_engine_id);
     177                                }
     178                              if (_param->_have_port_rob_ptr)
     179                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_PACKET_ID             [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_PACKET_ID             [num_ooo_engine][num_inst_issue_queue]));
     180                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OPERATION             [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_OPERATION             [num_ooo_engine][num_inst_issue_queue]));
     181                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_TYPE                  [num_execute_loop][num_read_unit],type);
     182                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_PTR_WRITE [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_PTR_WRITE [num_ooo_engine][num_inst_issue_queue]));
     183                              if (_param->_have_port_load_queue_ptr)
     184                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_LOAD_QUEUE_PTR_WRITE  [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_LOAD_QUEUE_PTR_WRITE  [num_ooo_engine][num_inst_issue_queue]));
     185                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_HAS_IMMEDIAT          [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_HAS_IMMEDIAT          [num_ooo_engine][num_inst_issue_queue]));
     186                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_IMMEDIAT              [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_IMMEDIAT              [num_ooo_engine][num_inst_issue_queue]));
     187                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RA               [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RA               [num_ooo_engine][num_inst_issue_queue]));
     188                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RA            [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RA            [num_ooo_engine][num_inst_issue_queue]));
     189                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RB               [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RB               [num_ooo_engine][num_inst_issue_queue]));
     190                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RB            [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RB            [num_ooo_engine][num_inst_issue_queue]));
     191                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RC               [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RC               [num_ooo_engine][num_inst_issue_queue]));
     192                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RC            [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RC            [num_ooo_engine][num_inst_issue_queue]));
     193                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_WRITE_RD              [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_WRITE_RD              [num_ooo_engine][num_inst_issue_queue]));
     194                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RD            [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RD            [num_ooo_engine][num_inst_issue_queue]));
     195                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_WRITE_RE              [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_WRITE_RE              [num_ooo_engine][num_inst_issue_queue]));
     196                              PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RE            [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RE            [num_ooo_engine][num_inst_issue_queue]));
     197                             
     198                             
     199                              find = true;
     200                              break;
     201                            }
     202                          //if (find)
     203                          //  break;
     204                        }
     205                      if (find)
     206                        break;
     207                    }
     208                if (find)
     209                  break;
     210              }
     211         
     212          if (_param->_issue_queue_in_order [num_ooo_engine] and
     213              not find and
     214              (num_inst_issue_queue >= _param->_nb_inst_reexecute [num_ooo_engine]))
     215            {
     216              log_printf(TRACE,Core_Glue,FUNCTION,"  * stop scan !!!");
     217             
     218              break; // stop scan
     219            }
     220        }
     221
     222    // Write output
     223    for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
     224      for (uint32_t j=0; j<_param->_nb_inst_issue_queue[i]; ++j)
     225        PORT_WRITE(out_ISSUE_OOO_ENGINE_ACK [i][j], ISSUE_OOO_ENGINE_ACK [i][j]);
     226    for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
     227      for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
     228        PORT_WRITE(out_ISSUE_EXECUTE_LOOP_VAL [i][j], ISSUE_EXECUTE_LOOP_VAL [i][j]);
     229
     230    log_end(Core_Glue,FUNCTION);
     231  };
     232
     233}; // end namespace core_glue
     234}; // end namespace core
     235
     236}; // end namespace behavioural
     237}; // end namespace morpheo             
     238#endif
     239
     240    /*
     241    bool       OOO_ENGINE_ENABLE      [_param->_nb_ooo_engine  ];
     242    Tcontrol_t SLOT_ENABLE            [_param->_nb_ooo_engine  ][_param->_max_nb_inst_issue_slot];
     243    bool       READ_UNIT_ENABLE       [_param->_nb_execute_loop][_param->_max_nb_read_unit];
     244
     245    // Init -> all at 0
     246    for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
     247      {
     248        OOO_ENGINE_ENABLE [i] = true;
     249
     250        for (uint32_t j=0; j<_param->_nb_inst_issue_slot[i]; ++j)
     251          SLOT_ENABLE [i][j] = 1;         
     252      }
     253
     254    for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
     255      for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
     256        {
     257          // Read unit is enable is signal ack is set
     258          READ_UNIT_ENABLE       [i][j] = (PORT_READ(in_ISSUE_EXECUTE_LOOP_ACK [i][j]) == 1);
     259          log_printf(TRACE,Core_Glue,FUNCTION,"  * Read_unit [%d][%d].enable : %d",i,j,READ_UNIT_ENABLE[i][j]);
     260        }
     261
     262
     263    // for each execute_loop
    42264    for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    43265      {
    44         log_printf(TRACE,Core_Glue,FUNCTION,"  * execute_loop [%d]",i);
    45 
    46         // for each issue of each ooo_engine ...
    47         std::list<generic::priority::select_t> * select_ooo_engine = _priority_ooo_engine[i]->select();
    48         for (std::list<generic::priority::select_t>::iterator it_ooo_engine=select_ooo_engine->begin();
    49              it_ooo_engine!=select_ooo_engine->end();
    50              ++it_ooo_engine)
     266        // Scan all read_unit
     267        std::list<generic::priority::select_t> * select_read_unit = _priority_read_unit[i]->select();
     268        for (std::list<generic::priority::select_t>::iterator it_read_unit=select_read_unit->begin();
     269             it_read_unit!=select_read_unit->end();
     270             ++it_read_unit)
    51271          {
    52             // get id
    53             const uint32_t ooo_engine_id  = it_ooo_engine->grp;
    54             const uint32_t num_ooo_engine = _param->_translate_execute_loop_num_ooo_engine [i][ooo_engine_id];
    55             const uint32_t num_inst_issue = it_ooo_engine->elt;
    56 
    57             log_printf(TRACE,Core_Glue,FUNCTION,"    * num_ooo_engine [%d] (id -> %d)",num_ooo_engine, ooo_engine_id);
    58             log_printf(TRACE,Core_Glue,FUNCTION,"    * num_inst_issue          : %d",num_inst_issue);
    59 
    60             Tcontrol_t ooo_engine_val = PORT_READ(in_ISSUE_OOO_ENGINE_VAL [num_ooo_engine][num_inst_issue]);
    61 
    62             log_printf(TRACE,Core_Glue,FUNCTION,"    * ISSUE_OOO_ENGINE_VAL    : %d",ooo_engine_val);
    63 
    64             // test if have a request ?
    65 //          if (ooo_engine_val)
     272            // get the most priotary ...
     273            uint32_t num_read_unit = it_read_unit->grp;
     274           
     275            log_printf(TRACE,Core_Glue,FUNCTION,"  * read_unit [%d][%d]",i,num_read_unit);
     276
     277            // ... and test if this read_unit is valid
     278            if (READ_UNIT_ENABLE [i][num_read_unit])
    66279              {
    67 //              // If ooo_engine can issue instruction on multiple execute_loop
    68 //              if (not ISSUE_OOO_ENGINE_ACK [num_ooo_engine][num_inst_issue])
    69 
    70                 // Scan all read_unit
    71                 std::list<generic::priority::select_t> * select_read_unit = _priority_read_unit[i]->select();
    72                 for (std::list<generic::priority::select_t>::iterator it_read_unit=select_read_unit->begin();
    73                      it_read_unit!=select_read_unit->end();
    74                      ++it_read_unit)
    75                   {
    76                     uint32_t num_read_unit = it_read_unit->grp;
    77                    
    78                     // Test if have an link and read unit is enable
    79                     log_printf(TRACE,Core_Glue,FUNCTION,"      * read_unit             : %d",num_read_unit);
    80                     log_printf(TRACE,Core_Glue,FUNCTION,"        * READ_UNIT_ENABLE    : %d",READ_UNIT_ENABLE [i][num_read_unit]);
    81                     log_printf(TRACE,Core_Glue,FUNCTION,"        * table_dispatch      : %d",_param->_table_dispatch [num_ooo_engine][num_inst_issue][i][num_read_unit]);
    82                    
    83                     Tcontrol_t read_unit_enable = READ_UNIT_ENABLE [i][num_read_unit];
    84 
    85                     // Test if the read_unit is not busy and if an link is between the issue slot and read_unit
    86                     if (read_unit_enable and
    87                         _param->_table_dispatch [num_ooo_engine][num_inst_issue][i][num_read_unit])
    88                       {
    89                         log_printf(TRACE,Core_Glue,FUNCTION,"        * find !!!");
    90                        
    91                         // Transaction
    92                         READ_UNIT_ENABLE       [i][num_read_unit] = false; // now, this read_unit is busy
    93                         ISSUE_EXECUTE_LOOP_VAL [i][num_read_unit] = ooo_engine_val; // = 1
    94                         ISSUE_OOO_ENGINE_ACK   [num_ooo_engine][num_inst_issue] = read_unit_enable; // = 1
    95                        
    96                         if (_param->_have_port_context_id)
    97                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_CONTEXT_ID            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_CONTEXT_ID            [num_ooo_engine][num_inst_issue]));
    98                         if (_param->_have_port_front_end_id)
    99                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_FRONT_END_ID          [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_FRONT_END_ID          [num_ooo_engine][num_inst_issue]));
    100                         if (_param->_have_port_ooo_engine_id)
    101                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OOO_ENGINE_ID         [i][num_read_unit],ooo_engine_id);
    102                         if (_param->_have_port_rob_ptr)
    103                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_PACKET_ID             [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_PACKET_ID             [num_ooo_engine][num_inst_issue]));
    104                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OPERATION             [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_OPERATION             [num_ooo_engine][num_inst_issue]));
    105                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_TYPE                  [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_TYPE                  [num_ooo_engine][num_inst_issue]));
    106                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_PTR_WRITE [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_PTR_WRITE [num_ooo_engine][num_inst_issue]));
    107                         if (_param->_have_port_load_queue_ptr)
    108                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_LOAD_QUEUE_PTR_WRITE  [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_LOAD_QUEUE_PTR_WRITE  [num_ooo_engine][num_inst_issue]));
    109                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_HAS_IMMEDIAT          [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_HAS_IMMEDIAT          [num_ooo_engine][num_inst_issue]));
    110                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_IMMEDIAT              [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_IMMEDIAT              [num_ooo_engine][num_inst_issue]));
    111                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RA               [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RA               [num_ooo_engine][num_inst_issue]));
    112                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RA            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RA            [num_ooo_engine][num_inst_issue]));
    113                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RB               [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RB               [num_ooo_engine][num_inst_issue]));
    114                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RB            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RB            [num_ooo_engine][num_inst_issue]));
    115                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RC               [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RC               [num_ooo_engine][num_inst_issue]));
    116                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RC            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RC            [num_ooo_engine][num_inst_issue]));
    117                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_WRITE_RD              [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_WRITE_RD              [num_ooo_engine][num_inst_issue]));
    118                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RD            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RD            [num_ooo_engine][num_inst_issue]));
    119                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_WRITE_RE              [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_WRITE_RE              [num_ooo_engine][num_inst_issue]));
    120                         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RE            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RE            [num_ooo_engine][num_inst_issue]));
    121 
    122                         break; // find : stop scan read_unit
    123                       }
     280                bool find = false;
     281               
     282                // This read_unit is valid, now find an valid instruction
     283                // for each issue of each ooo_engine ...
     284                std::list<generic::priority::select_t> * select_ooo_engine = _priority_ooo_engine[i]->select();
     285                for (std::list<generic::priority::select_t>::iterator it_ooo_engine=select_ooo_engine->begin();
     286                     it_ooo_engine!=select_ooo_engine->end();
     287                     ++it_ooo_engine)
     288                  {
     289                    // ... get id of the most priotary
     290                    const uint32_t ooo_engine_id       = it_ooo_engine->grp;
     291                    const uint32_t num_ooo_engine      = _param->_translate_execute_loop_num_ooo_engine [i][ooo_engine_id];
     292                    const uint32_t num_inst_issue_slot = it_ooo_engine->elt;
     293                   
     294                    log_printf(TRACE,Core_Glue,FUNCTION,"    * num_ooo_engine [%d (%d)][%d]",num_ooo_engine, ooo_engine_id,num_inst_issue_slot);
     295                   
     296                    if (OOO_ENGINE_ENABLE [num_ooo_engine] and SLOT_ENABLE [num_ooo_engine][num_inst_issue_slot])
     297                      {
     298                        uint32_t num_inst_issue_queue = 0;
     299                        for (; num_inst_issue_queue < _param->_nb_inst_issue_queue [num_ooo_engine]; num_inst_issue_queue ++)
     300                          {
     301                            // Test if this instruction is not previously send at a read_unit
     302                            if (not ISSUE_OOO_ENGINE_ACK [num_ooo_engine][num_inst_issue_queue])
     303                              {
     304                                Tcontrol_t ooo_engine_val = PORT_READ(in_ISSUE_OOO_ENGINE_VAL  [num_ooo_engine][num_inst_issue_queue]);
     305                                Ttype_t    type           = PORT_READ(in_ISSUE_OOO_ENGINE_TYPE [num_ooo_engine][num_inst_issue_queue]);
     306                                // Test if have an link and read unit is enable
     307                                bool can_dispatch   = _param->_table_dispatch [num_ooo_engine][num_inst_issue_slot][i][num_read_unit];
     308                                bool can_issue_type = _param->_table_issue_type [i][num_read_unit][type];
     309                               
     310                                log_printf(TRACE,Core_Glue,FUNCTION,"      * num_ooo_engine_queue  : %d",num_inst_issue_queue);
     311                                log_printf(TRACE,Core_Glue,FUNCTION,"      * type                  : %s",toString(type).c_str());
     312                                log_printf(TRACE,Core_Glue,FUNCTION,"      * ISSUE_OOO_ENGINE_VAL  : %d",ooo_engine_val);
     313                                log_printf(TRACE,Core_Glue,FUNCTION,"      * table_dispatch        : %d",can_dispatch);
     314                                log_printf(TRACE,Core_Glue,FUNCTION,"      * table_issue_type      : %d",can_issue_type);
     315                               
     316                               
     317                                // test if have a request ?
     318                                // and test if have a link between the issue slot and read_unit
     319                                // and if the read_unit accept this instruction's type
     320                                if (ooo_engine_val and
     321                                    can_dispatch   and
     322                                    can_issue_type)
     323                                  {
     324//                                     log_printf(TRACE,Core_Glue,FUNCTION,"          * find !!!");
     325                                   
     326                                    // Transaction
     327                                    READ_UNIT_ENABLE       [i][num_read_unit] = false; // now, this read_unit is busy
     328                                    ISSUE_EXECUTE_LOOP_VAL [i][num_read_unit] = ooo_engine_val;
     329                                    ISSUE_OOO_ENGINE_ACK   [num_ooo_engine][num_inst_issue_queue] = 1;
     330                                    SLOT_ENABLE            [num_ooo_engine][num_inst_issue_slot]  = 0; // now this slot is used
     331                                     
     332                                    if (_param->_have_port_context_id)
     333                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_CONTEXT_ID            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_CONTEXT_ID            [num_ooo_engine][num_inst_issue_queue]));
     334                                    if (_param->_have_port_front_end_id)
     335                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_FRONT_END_ID          [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_FRONT_END_ID          [num_ooo_engine][num_inst_issue_queue]));
     336                                    if (_param->_have_port_ooo_engine_id)
     337                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OOO_ENGINE_ID         [i][num_read_unit],ooo_engine_id);
     338                                    if (_param->_have_port_rob_ptr)
     339                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_PACKET_ID             [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_PACKET_ID             [num_ooo_engine][num_inst_issue_queue]));
     340                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OPERATION             [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_OPERATION             [num_ooo_engine][num_inst_issue_queue]));
     341                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_TYPE                  [i][num_read_unit],type);
     342                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_PTR_WRITE [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_PTR_WRITE [num_ooo_engine][num_inst_issue_queue]));
     343                                    if (_param->_have_port_load_queue_ptr)
     344                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_LOAD_QUEUE_PTR_WRITE  [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_LOAD_QUEUE_PTR_WRITE  [num_ooo_engine][num_inst_issue_queue]));
     345                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_HAS_IMMEDIAT          [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_HAS_IMMEDIAT          [num_ooo_engine][num_inst_issue_queue]));
     346                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_IMMEDIAT              [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_IMMEDIAT              [num_ooo_engine][num_inst_issue_queue]));
     347                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RA               [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RA               [num_ooo_engine][num_inst_issue_queue]));
     348                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RA            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RA            [num_ooo_engine][num_inst_issue_queue]));
     349                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RB               [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RB               [num_ooo_engine][num_inst_issue_queue]));
     350                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RB            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RB            [num_ooo_engine][num_inst_issue_queue]));
     351                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_READ_RC               [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_READ_RC               [num_ooo_engine][num_inst_issue_queue]));
     352                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RC            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RC            [num_ooo_engine][num_inst_issue_queue]));
     353                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_WRITE_RD              [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_WRITE_RD              [num_ooo_engine][num_inst_issue_queue]));
     354                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RD            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RD            [num_ooo_engine][num_inst_issue_queue]));
     355                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_WRITE_RE              [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_WRITE_RE              [num_ooo_engine][num_inst_issue_queue]));
     356                                    PORT_WRITE(out_ISSUE_EXECUTE_LOOP_NUM_REG_RE            [i][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_NUM_REG_RE            [num_ooo_engine][num_inst_issue_queue]));
     357                                   
     358                                    find = true;// find : stop scan read_unit
     359                                  }
     360                              }
     361                            if (find)
     362                              break;
     363                          }
     364
     365                        if (find)
     366                          {
     367                            log_printf(TRACE,Core_Glue,FUNCTION,"    * find !!!");
     368                            break;
     369                          }
     370                        else
     371                          {
     372                            log_printf(TRACE,Core_Glue,FUNCTION,"    * not find !!!");
     373                            log_printf(TRACE,Core_Glue,FUNCTION,"      * issue_queue_in_order: %d",_param->_issue_queue_in_order [num_ooo_engine]);
     374                            log_printf(TRACE,Core_Glue,FUNCTION,"      * num_inst_issue_queue: %d",num_inst_issue_queue);
     375                            log_printf(TRACE,Core_Glue,FUNCTION,"      * nb_inst_reexecute   : %d",_param->_nb_inst_reexecute [num_ooo_engine]);
     376
     377                            if (_param->_issue_queue_in_order [num_ooo_engine] and
     378                                (num_inst_issue_queue >= _param->_nb_inst_reexecute [num_ooo_engine]))
     379                                OOO_ENGINE_ENABLE [num_ooo_engine] = false;
     380                          }
     381                      }
    124382                  }
    125383              }
    126384          }
    127385      }
    128 
    129     // Write output
    130     for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
    131       for (uint32_t j=0; j<_param->_nb_inst_issue[i]; ++j)
    132         PORT_WRITE(out_ISSUE_OOO_ENGINE_ACK [i][j], ISSUE_OOO_ENGINE_ACK [i][j]);
    133     for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    134       for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
    135         PORT_WRITE(out_ISSUE_EXECUTE_LOOP_VAL [i][j], ISSUE_EXECUTE_LOOP_VAL [i][j]);
    136 
    137     log_end(Core_Glue,FUNCTION);
    138   };
    139 
    140 }; // end namespace core_glue
    141 }; // end namespace core
    142 
    143 }; // end namespace behavioural
    144 }; // end namespace morpheo             
    145 #endif
     386    */
     387
Note: See TracChangeset for help on using the changeset viewer.