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) ...

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/src
Files:
3 edited

Legend:

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

    r136 r138  
    1616
    1717  /*
    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 +-----
     18      OOO     Execute Loop                                 
     19    ---+          +-----
     20       |  +-----+ |     
     21      -+->|     |-+->   
     22       |  |     | |     
     23      -+->|     |-+->   
     24       |  |     | |     
     25      -+->|     | +-----
     26       |  |     |       
     27      -+->|     | +-----
     28       |  |     | |     
     29    ---+  | _ _ |-+->   
     30          | _X_ | |     
     31    ---+  |     |-+->   
     32       |  |     | |     
     33      -+->|     | +-----
     34       |  |     |       
     35      -+->|     | +-----
     36       |  |     | |     
     37      -+->|     |-+->   
     38       |  |     | |     
     39      -+->|     |-+->   
     40       |  +-----+ |     
     41    ---+ dispatch +-----
    4242  */
    4343
     
    7575      {
    7676    Tcontrol_t READ_UNIT_ENABLE       [_param->_nb_execute_loop][_param->_max_nb_read_unit];
    77     Tcontrol_t SLOT_ENABLE            [_param->_nb_ooo_engine  ][_param->_max_nb_inst_issue_slot];
    7877   
    7978    // Init -> all at 0
    80     for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
    81       for (uint32_t j=0; j<_param->_nb_inst_issue_slot[i]; ++j)
    82         SLOT_ENABLE [i][j] = 1;         
    83 
    8479    for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    8580      for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
     
    9085        }
    9186
    92 //     std::list<num_read_unit_t> SLOT_TYPE [_param->_nb_ooo_engine][_param->_max_nb_inst_issue_slot][_param->_nb_type];
    93 
    94 //     // for each read_unit
    95 //     for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    96 //       for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
    97 //         // test if this read_unit can receive an instruction
    98 //         if (PORT_READ(in_ISSUE_EXECUTE_LOOP_ACK [i][j]) == 1)
    99 //           for (uint32_t x=0; x<_nb_ooo_engine; ++x)
    100 //             for (uint32_t y=0; y<_nb_inst_issue_slot[y]; ++y)
    101 //               // test if can dispatch
    102 //               if (_param->_table_dispatch [x][y][i][j])
    103 //                 for (uint32_t k=0;k<_param->_nb_type; ++k)
    104 //                   // Can receive this type
    105 //                   if (_param->_table_dispatch [i][j][k])
    106 //                     SLOT_TYPE[x][y][k].push_back(num_read_unit_t(i,j));
    107 
    108 //     // Select an issue_slot of an ooo_engine
    109 //     std::list<generic::priority::select_t> * select_ooo_engine = _priority_ooo_engine->select();
    110 //     for (std::list<generic::priority::select_t>::iterator it_ooo_engine=select_ooo_engine->begin();
    111 //          it_ooo_engine!=select_ooo_engine->end();
    112 //          ++it_ooo_engine)
    113 //       {
    114 //         // ... get id of the most priotary
    115 //         const uint32_t num_ooo_engine      = it_ooo_engine->grp;
    116 //         const uint32_t num_inst_issue_slot = it_ooo_engine->elt;
    117 
    118 //         // Test if this ooo_engine is enable (can be desable if issue in_order)
    119 //         if (OOO_ENGINE_ENABLE[num_ooo_engine])
    120 //           {
    121 
    122 //           }
    123 //       }
    124 
    125 //     for (uint32_t num_ooo_engine=0; num_ooo_engine<_param->_nb_ooo_engine; ++num_ooo_engine)
    126 
    12787    std::list<generic::priority::select_t> * select_ooo_engine = _priority_ooo_engine->select();
    12888    for (std::list<generic::priority::select_t>::iterator it_ooo_engine=select_ooo_engine->begin();
     
    13090         ++it_ooo_engine)
    13191      {
    132         uint32_t num_ooo_engine      = it_ooo_engine->grp;
     92        // select the most priotary
     93        uint32_t num_ooo_engine = it_ooo_engine->grp;
    13394
    13495        for (uint32_t num_inst_issue_queue=0; num_inst_issue_queue<_param->_nb_inst_issue_queue[num_ooo_engine]; ++num_inst_issue_queue)
    13596          {
     97            // init stop condition
    13698            bool find = false;
    13799           
    138             Tcontrol_t val  = PORT_READ(in_ISSUE_OOO_ENGINE_VAL  [num_ooo_engine][num_inst_issue_queue]);
    139             Ttype_t    type = PORT_READ(in_ISSUE_OOO_ENGINE_TYPE [num_ooo_engine][num_inst_issue_queue]);
     100            // Read request information from issue_queue
     101            Tcontrol_t val          = PORT_READ(in_ISSUE_OOO_ENGINE_VAL  [num_ooo_engine][num_inst_issue_queue]);
     102            Ttype_t    type         = PORT_READ(in_ISSUE_OOO_ENGINE_TYPE [num_ooo_engine][num_inst_issue_queue]);
     103            Tcontext_t context_id   = (_param->_have_port_context_id  )?PORT_READ(in_ISSUE_OOO_ENGINE_CONTEXT_ID   [num_ooo_engine][num_inst_issue_queue]):0;
     104            Tcontext_t front_end_id = (_param->_have_port_front_end_id)?PORT_READ(in_ISSUE_OOO_ENGINE_FRONT_END_ID [num_ooo_engine][num_inst_issue_queue]):0;
     105            uint32_t   num_thread    = _param->_translate_num_context_to_num_thread[num_ooo_engine][front_end_id][context_id];
    140106           
    141107            log_printf(TRACE,Core_Glue,FUNCTION,"  * num_ooo_engine                : %d",num_ooo_engine      );
    142108            log_printf(TRACE,Core_Glue,FUNCTION,"  * num_inst_issue_queue          : %d",num_inst_issue_queue);
    143109            log_printf(TRACE,Core_Glue,FUNCTION,"    * val                         : %d",val);
    144             log_printf(TRACE,Core_Glue,FUNCTION,"    * type                        : %d",type);
    145            
     110            log_printf(TRACE,Core_Glue,FUNCTION,"    * type                        : %d",type); 
     111            log_printf(TRACE,Core_Glue,FUNCTION,"    * context_id                  : %d",context_id);
     112            log_printf(TRACE,Core_Glue,FUNCTION,"    * front_end_id                : %d",front_end_id);
     113            log_printf(TRACE,Core_Glue,FUNCTION,"    * num_thread                  : %d",num_thread);
     114         
    146115            if (val)
    147               for (uint32_t num_inst_issue_slot=0; num_inst_issue_slot<_param->_nb_inst_issue_slot[num_ooo_engine]; ++num_inst_issue_slot)
     116              // for each execute_loop
     117              for (uint32_t num_execute_loop=0; num_execute_loop<_param->_nb_execute_loop; ++num_execute_loop)
    148118                {
    149                   log_printf(TRACE,Core_Glue,FUNCTION,"    * num_inst_issue_slot         : %d",num_inst_issue_slot);
    150                  
    151                   // scan all read_unit
    152                  
    153                   if (SLOT_ENABLE [num_ooo_engine][num_inst_issue_slot])
    154                     for (uint32_t num_execute_loop=0; num_execute_loop<_param->_nb_execute_loop; ++num_execute_loop)
    155                       {
    156                         std::list<generic::priority::select_t> * select_read_unit = _priority_read_unit[num_execute_loop]->select();
    157                         for (std::list<generic::priority::select_t>::iterator it_read_unit=select_read_unit->begin();
    158                              it_read_unit!=select_read_unit->end();
    159                              ++it_read_unit)
    160                           {
    161                             // get the most priotary ...
    162                             uint32_t num_read_unit = it_read_unit->grp;
    163                             Tcontrol_t ack = READ_UNIT_ENABLE [num_execute_loop][num_read_unit];
    164                            
    165                             log_printf(TRACE,Core_Glue,FUNCTION,"      * num_execute_loop          : %d",num_execute_loop);
    166                             log_printf(TRACE,Core_Glue,FUNCTION,"      * num_read_unit             : %d",num_read_unit   );
    167                             log_printf(TRACE,Core_Glue,FUNCTION,"        * read_unit_enable        : %d",ack             );
    168                            
    169                             // test if :
    170                             //  * read_unit can accept an instruction (valid and no previous instruction)
    171                             //  * slot can issue an instruction at this read_unit
    172                             //  * read_unit can accept this type
    173                             if (ack and
    174                                 _param->_table_dispatch [num_ooo_engine][num_inst_issue_slot][num_execute_loop][num_read_unit] and
    175                                 _param->_table_issue_type [num_execute_loop][num_read_unit][type])
    176                               {
    177                                 log_printf(TRACE,Core_Glue,FUNCTION,"  * find !!!");
    178                                
    179                                 // find !
    180                                 // Transaction
    181                                 READ_UNIT_ENABLE       [num_execute_loop][num_read_unit] = false; // now, this read_unit is busy
    182                                 ISSUE_EXECUTE_LOOP_VAL [num_execute_loop][num_read_unit] = 1; // = val
    183                                 ISSUE_OOO_ENGINE_ACK   [num_ooo_engine][num_inst_issue_queue] = 1; // = ack
    184                                 SLOT_ENABLE            [num_ooo_engine][num_inst_issue_slot]  = false; // now this slot is used
    185                                      
    186                                 if (_param->_have_port_context_id)
    187                                 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]));
    188                                 if (_param->_have_port_front_end_id)
    189                                 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]));
    190                                 if (_param->_have_port_ooo_engine_id)
    191                                   {
    192                                 Tcontext_t ooo_engine_id = _param->_translate_num_ooo_engine_to_execute_loop_ooo_engine_id [num_ooo_engine][num_execute_loop];
    193                                 PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OOO_ENGINE_ID         [num_execute_loop][num_read_unit],ooo_engine_id);
    194                                   }
    195                                 if (_param->_have_port_rob_ptr)
    196                                 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]));
    197                                 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]));
    198                                 PORT_WRITE(out_ISSUE_EXECUTE_LOOP_TYPE                  [num_execute_loop][num_read_unit],type);
    199                                 PORT_WRITE(out_ISSUE_EXECUTE_LOOP_CANCEL                [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_CANCEL                [num_ooo_engine][num_inst_issue_queue]));
    200                                 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]));
    201                                 PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_PTR_READ  [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_PTR_READ  [num_ooo_engine][num_inst_issue_queue]));
    202                                 PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_EMPTY     [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_EMPTY     [num_ooo_engine][num_inst_issue_queue]));
    203                                 if (_param->_have_port_load_queue_ptr)
    204                                 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]));
    205                                 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]));
    206                                 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]));
    207                                 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]));
    208                                 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]));
    209                                 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]));
    210                                 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]));
    211                                 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]));
    212                                 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]));
    213                                 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]));
    214                                 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]));
    215                                 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]));
    216                                 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]));
    217                              
    218                                
    219                                 find = true;
    220                                 break;
    221                               }
    222                             //if (find)
    223                             //  break;
    224                           }
    225                         if (find)
     119                  // for each read_unit
     120                  std::list<generic::priority::select_t> * select_read_unit = _priority_read_unit[num_execute_loop]->select();
     121                  for (std::list<generic::priority::select_t>::iterator it_read_unit=select_read_unit->begin();
     122                       it_read_unit!=select_read_unit->end();
     123                       ++it_read_unit)
     124                    {
     125                      // get the most priotary ...
     126                      uint32_t num_read_unit = it_read_unit->grp;
     127                      Tcontrol_t ack = READ_UNIT_ENABLE [num_execute_loop][num_read_unit];
     128                     
     129                      log_printf(TRACE,Core_Glue,FUNCTION,"      * num_execute_loop          : %d",num_execute_loop);
     130                      log_printf(TRACE,Core_Glue,FUNCTION,"      * num_read_unit             : %d",num_read_unit   );
     131                      log_printf(TRACE,Core_Glue,FUNCTION,"        * read_unit_enable        : %d",ack             );
     132                     
     133                      // test if :
     134                      //  * read_unit can accept an instruction (valid and no previous instruction)
     135                      //  * read_unit can accept this type
     136                      if (ack and
     137                          _param->_table_issue_type   [num_execute_loop][num_read_unit][type] and
     138                          _param->_table_issue_thread [num_execute_loop][num_read_unit][num_thread])
     139                        {
     140                          log_printf(TRACE,Core_Glue,FUNCTION,"  * find !!!");
     141                         
     142                          // find !
     143                          // Transaction
     144                          find = true;
     145
     146                          READ_UNIT_ENABLE       [num_execute_loop][num_read_unit] = false; // now, this read_unit is busy
     147                          ISSUE_EXECUTE_LOOP_VAL [num_execute_loop][num_read_unit] = 1; // = val
     148                          ISSUE_OOO_ENGINE_ACK   [num_ooo_engine][num_inst_issue_queue] = 1; // = ack
     149                         
     150                          if (_param->_have_port_context_id)
     151                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_CONTEXT_ID            [num_execute_loop][num_read_unit],context_id);
     152                          if (_param->_have_port_front_end_id)
     153                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_FRONT_END_ID          [num_execute_loop][num_read_unit],front_end_id);
     154                          if (_param->_have_port_ooo_engine_id)
     155                            {
     156                          Tcontext_t ooo_engine_id = _param->_translate_num_ooo_engine_to_execute_loop_ooo_engine_id [num_ooo_engine][num_execute_loop];
     157                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OOO_ENGINE_ID         [num_execute_loop][num_read_unit],ooo_engine_id);
     158                            }
     159                          if (_param->_have_port_rob_ptr)
     160                          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]));
     161                          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]));
     162                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_TYPE                  [num_execute_loop][num_read_unit],type);
     163                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_CANCEL                [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_CANCEL                [num_ooo_engine][num_inst_issue_queue]));
     164                          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]));
     165                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_PTR_READ  [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_PTR_READ  [num_ooo_engine][num_inst_issue_queue]));
     166                          PORT_WRITE(out_ISSUE_EXECUTE_LOOP_STORE_QUEUE_EMPTY     [num_execute_loop][num_read_unit],PORT_READ(in_ISSUE_OOO_ENGINE_STORE_QUEUE_EMPTY     [num_ooo_engine][num_inst_issue_queue]));
     167                          if (_param->_have_port_load_queue_ptr)
     168                          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]));
     169                          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]));
     170                          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]));
     171                          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]));
     172                          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]));
     173                          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]));
     174                          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]));
     175                          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]));
     176                          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]));
     177                          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]));
     178                          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]));
     179                          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]));
     180                          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]));
    226181                          break;
    227                       }
     182                        }
     183                      //if (find)
     184                      //  break;
     185                    }
    228186                  if (find)
    229187                    break;
     
    240198          }
    241199      }
    242 
     200   
    243201      }
    244202
     
    260218}; // end namespace morpheo             
    261219#endif
    262 
    263     /*
    264     bool       OOO_ENGINE_ENABLE      [_param->_nb_ooo_engine  ];
    265     Tcontrol_t SLOT_ENABLE            [_param->_nb_ooo_engine  ][_param->_max_nb_inst_issue_slot];
    266     bool       READ_UNIT_ENABLE       [_param->_nb_execute_loop][_param->_max_nb_read_unit];
    267 
    268     // Init -> all at 0
    269     for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
    270       {
    271         OOO_ENGINE_ENABLE [i] = true;
    272 
    273         for (uint32_t j=0; j<_param->_nb_inst_issue_slot[i]; ++j)
    274           SLOT_ENABLE [i][j] = 1;         
    275       }
    276 
    277     for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    278       for (uint32_t j=0; j<_param->_nb_read_unit[i]; ++j)
    279         {
    280           // Read unit is enable is signal ack is set
    281           READ_UNIT_ENABLE       [i][j] = (PORT_READ(in_ISSUE_EXECUTE_LOOP_ACK [i][j]) == 1);
    282           log_printf(TRACE,Core_Glue,FUNCTION,"  * Read_unit [%d][%d].enable : %d",i,j,READ_UNIT_ENABLE[i][j]);
    283         }
    284 
    285 
    286     // for each execute_loop
    287     for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
    288       {
    289         // Scan all read_unit
    290         std::list<generic::priority::select_t> * select_read_unit = _priority_read_unit[i]->select();
    291         for (std::list<generic::priority::select_t>::iterator it_read_unit=select_read_unit->begin();
    292              it_read_unit!=select_read_unit->end();
    293              ++it_read_unit)
    294           {
    295             // get the most priotary ...
    296             uint32_t num_read_unit = it_read_unit->grp;
    297            
    298             log_printf(TRACE,Core_Glue,FUNCTION,"  * read_unit [%d][%d]",i,num_read_unit);
    299 
    300             // ... and test if this read_unit is valid
    301             if (READ_UNIT_ENABLE [i][num_read_unit])
    302               {
    303                 bool find = false;
    304                
    305                 // This read_unit is valid, now find an valid instruction
    306                 // for each issue of each ooo_engine ...
    307                 std::list<generic::priority::select_t> * select_ooo_engine = _priority_ooo_engine[i]->select();
    308                 for (std::list<generic::priority::select_t>::iterator it_ooo_engine=select_ooo_engine->begin();
    309                      it_ooo_engine!=select_ooo_engine->end();
    310                      ++it_ooo_engine)
    311                   {
    312                     // ... get id of the most priotary
    313                     const uint32_t ooo_engine_id       = it_ooo_engine->grp;
    314                     const uint32_t num_ooo_engine      = _param->_translate_execute_loop_num_ooo_engine [i][ooo_engine_id];
    315                     const uint32_t num_inst_issue_slot = it_ooo_engine->elt;
    316                    
    317                     log_printf(TRACE,Core_Glue,FUNCTION,"    * num_ooo_engine [%d (%d)][%d]",num_ooo_engine, ooo_engine_id,num_inst_issue_slot);
    318                    
    319                     if (OOO_ENGINE_ENABLE [num_ooo_engine] and SLOT_ENABLE [num_ooo_engine][num_inst_issue_slot])
    320                       {
    321                         uint32_t num_inst_issue_queue = 0;
    322                         for (; num_inst_issue_queue < _param->_nb_inst_issue_queue [num_ooo_engine]; num_inst_issue_queue ++)
    323                           {
    324                             // Test if this instruction is not previously send at a read_unit
    325                             if (not ISSUE_OOO_ENGINE_ACK [num_ooo_engine][num_inst_issue_queue])
    326                               {
    327                                 Tcontrol_t ooo_engine_val = PORT_READ(in_ISSUE_OOO_ENGINE_VAL  [num_ooo_engine][num_inst_issue_queue]);
    328                                 Ttype_t    type           = PORT_READ(in_ISSUE_OOO_ENGINE_TYPE [num_ooo_engine][num_inst_issue_queue]);
    329                                 // Test if have an link and read unit is enable
    330                                 bool can_dispatch   = _param->_table_dispatch [num_ooo_engine][num_inst_issue_slot][i][num_read_unit];
    331                                 bool can_issue_type = _param->_table_issue_type [i][num_read_unit][type];
    332                                
    333                                 log_printf(TRACE,Core_Glue,FUNCTION,"      * num_ooo_engine_queue  : %d",num_inst_issue_queue);
    334                                 log_printf(TRACE,Core_Glue,FUNCTION,"      * type                  : %s",toString(type).c_str());
    335                                 log_printf(TRACE,Core_Glue,FUNCTION,"      * ISSUE_OOO_ENGINE_VAL  : %d",ooo_engine_val);
    336                                 log_printf(TRACE,Core_Glue,FUNCTION,"      * table_dispatch        : %d",can_dispatch);
    337                                 log_printf(TRACE,Core_Glue,FUNCTION,"      * table_issue_type      : %d",can_issue_type);
    338                                
    339                                
    340                                 // test if have a request ?
    341                                 // and test if have a link between the issue slot and read_unit
    342                                 // and if the read_unit accept this instruction's type
    343                                 if (ooo_engine_val and
    344                                     can_dispatch   and
    345                                     can_issue_type)
    346                                   {
    347 //                                     log_printf(TRACE,Core_Glue,FUNCTION,"          * find !!!");
    348                                    
    349                                     // Transaction
    350                                     READ_UNIT_ENABLE       [i][num_read_unit] = false; // now, this read_unit is busy
    351                                     ISSUE_EXECUTE_LOOP_VAL [i][num_read_unit] = ooo_engine_val;
    352                                     ISSUE_OOO_ENGINE_ACK   [num_ooo_engine][num_inst_issue_queue] = 1;
    353                                     SLOT_ENABLE            [num_ooo_engine][num_inst_issue_slot]  = 0; // now this slot is used
    354                                      
    355                                     if (_param->_have_port_context_id)
    356                                     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]));
    357                                     if (_param->_have_port_front_end_id)
    358                                     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]));
    359                                     if (_param->_have_port_ooo_engine_id)
    360                                     PORT_WRITE(out_ISSUE_EXECUTE_LOOP_OOO_ENGINE_ID         [i][num_read_unit],ooo_engine_id);
    361                                     if (_param->_have_port_rob_ptr)
    362                                     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]));
    363                                     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]));
    364                                     PORT_WRITE(out_ISSUE_EXECUTE_LOOP_TYPE                  [i][num_read_unit],type);
    365                                     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]));
    366                                     if (_param->_have_port_load_queue_ptr)
    367                                     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]));
    368                                     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]));
    369                                     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]));
    370                                     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]));
    371                                     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]));
    372                                     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]));
    373                                     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]));
    374                                     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]));
    375                                     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]));
    376                                     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]));
    377                                     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]));
    378                                     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]));
    379                                     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]));
    380                                    
    381                                     find = true;// find : stop scan read_unit
    382                                   }
    383                               }
    384                             if (find)
    385                               break;
    386                           }
    387 
    388                         if (find)
    389                           {
    390                             log_printf(TRACE,Core_Glue,FUNCTION,"    * find !!!");
    391                             break;
    392                           }
    393                         else
    394                           {
    395                             log_printf(TRACE,Core_Glue,FUNCTION,"    * not find !!!");
    396                             log_printf(TRACE,Core_Glue,FUNCTION,"      * issue_queue_in_order: %d",_param->_issue_queue_in_order [num_ooo_engine]);
    397                             log_printf(TRACE,Core_Glue,FUNCTION,"      * num_inst_issue_queue: %d",num_inst_issue_queue);
    398                             log_printf(TRACE,Core_Glue,FUNCTION,"      * nb_inst_reexecute   : %d",_param->_nb_inst_reexecute [num_ooo_engine]);
    399 
    400                             if (_param->_issue_queue_in_order [num_ooo_engine] and
    401                                 (num_inst_issue_queue >= _param->_nb_inst_reexecute [num_ooo_engine]))
    402                                 OOO_ENGINE_ENABLE [num_ooo_engine] = false;
    403                           }
    404                       }
    405                   }
    406               }
    407           }
    408       }
    409     */
    410 
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/src/Parameters.cpp

    r136 r138  
    3232   uint32_t              * nb_inst_reexecute                    ,//[nb_ooo_engine]
    3333   uint32_t              * nb_inst_issue_queue                  ,//[nb_ooo_engine]
    34   uint32_t              * nb_inst_issue_slot                   ,//[nb_ooo_engine]
     34// uint32_t              * nb_inst_issue_slot                   ,//[nb_ooo_engine]
    3535   uint32_t             ** nb_inst_execute                      ,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
    3636   bool                  * issue_queue_in_order                 ,//[nb_ooo_engine]
     
    4747   Tpriority_t             dispatch_priority                    ,
    4848   Tload_balancing_t       dispatch_load_balancing              ,
    49   bool               **** table_dispatch                       ,//[nb_ooo_engine][nb_inst_issue_slot][execute_loop][nb_read_unit]
     49// bool               **** table_dispatch                       ,//[nb_ooo_engine][nb_inst_issue_slot][execute_loop][nb_read_unit]
    5050   bool                *** table_issue_type                     ,//                                   [execute_loop][nb_read_unit][nb_type]
     51   bool                *** table_issue_thread                   ,//                                   [execute_loop][nb_read_unit][nb_thread]
    5152   uint32_t             ** translate_ooo_engine_num_front_end   ,//[nb_ooo_engine][ooo_engine_nb_front_end]
    5253   uint32_t             ** translate_ooo_engine_num_execute_loop,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
    5354   uint32_t             ** translate_execute_loop_num_ooo_engine,//[nb_execute_loop][execute_loop_nb_ooo_engine]
     55   uint32_t            *** translate_num_context_to_num_thread  ,//[nb_ooo_engine][ooo_engine_nb_front_end][nb_context]
    5456   bool                    is_toplevel)
    5557  {
     
    6971    _nb_inst_reexecute                     = nb_inst_reexecute                    ;
    7072    _nb_inst_issue_queue                   = nb_inst_issue_queue                  ;
    71     _nb_inst_issue_slot                    = nb_inst_issue_slot                   ;
     73//  _nb_inst_issue_slot                    = nb_inst_issue_slot                   ;
    7274    _nb_inst_execute                       = nb_inst_execute                      ;
    7375    _issue_queue_in_order                  = issue_queue_in_order                 ;
     
    7678    _dispatch_priority                     = dispatch_priority                    ;
    7779    _dispatch_load_balancing               = dispatch_load_balancing              ;
    78     _table_dispatch                        = table_dispatch                       ;
     80//  _table_dispatch                        = table_dispatch                       ;
    7981    _table_issue_type                      = table_issue_type                     ;
     82    _table_issue_thread                    = table_issue_thread                   ;
    8083    _translate_ooo_engine_num_front_end    = translate_ooo_engine_num_front_end   ;
    8184    _translate_ooo_engine_num_execute_loop = translate_ooo_engine_num_execute_loop;
    8285    _translate_execute_loop_num_ooo_engine = translate_execute_loop_num_ooo_engine;
     86    _translate_num_context_to_num_thread   = translate_num_context_to_num_thread  ;
    8387
    8488    test();
     
    118122
    119123//  ALLOC2(_execute_loop_nb_inst_insert,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
    120     ALLOC2(_execute_loop_nb_inst_issue_slot ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
    121 
    122     for (uint32_t i=0; i<_nb_execute_loop; ++i)
    123       for (uint32_t j=0; j<_execute_loop_nb_ooo_engine[i]; ++j)
    124         {
    125           uint32_t num_ooo_engine = _translate_execute_loop_num_ooo_engine [i][j];
    126           _execute_loop_nb_inst_issue_slot [i][j] = _nb_inst_issue_slot [num_ooo_engine];
    127 //        _execute_loop_nb_inst_insert     [i][j] = _nb_inst_insert     [num_ooo_engine];
    128         }
     124//  ALLOC2(_execute_loop_nb_inst_issue_slot ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
     125
     126//     for (uint32_t i=0; i<_nb_execute_loop; ++i)
     127//       for (uint32_t j=0; j<_execute_loop_nb_ooo_engine[i]; ++j)
     128//         {
     129//           uint32_t num_ooo_engine = _translate_execute_loop_num_ooo_engine [i][j];
     130//           _execute_loop_nb_inst_issue_slot [i][j] = _nb_inst_issue_slot [num_ooo_engine];
     131//           _execute_loop_nb_inst_insert     [i][j] = _nb_inst_insert     [num_ooo_engine];
     132//         }
    129133
    130134    _max_ooo_engine_nb_inst_branch_complete = max<uint32_t>(_ooo_engine_nb_inst_branch_complete,_nb_ooo_engine);
     
    135139//  _max_nb_inst_insert                     = max<uint32_t>(_nb_inst_insert            ,_nb_ooo_engine);
    136140    _max_nb_inst_issue_queue                = max<uint32_t>(_nb_inst_issue_queue       ,_nb_ooo_engine);
    137     _max_nb_inst_issue_slot                 = max<uint32_t>(_nb_inst_issue_slot        ,_nb_ooo_engine);
     141//  _max_nb_inst_issue_slot                 = max<uint32_t>(_nb_inst_issue_slot        ,_nb_ooo_engine);
    138142    _max_nb_read_unit                       = max<uint32_t>(_nb_read_unit              ,_nb_execute_loop);
    139143
     
    188192    log_begin(Core_Glue,FUNCTION);
    189193
    190     DELETE2(_execute_loop_nb_inst_issue_slot                         ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
     194//  DELETE2(_execute_loop_nb_inst_issue_slot                         ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
    191195//  DELETE2(_execute_loop_nb_inst_insert                             ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
    192196    DELETE2(_translate_num_ooo_engine_to_execute_loop_ooo_engine_id  ,_nb_ooo_engine,_nb_execute_loop);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/src/Parameters_msg_error.cpp

    r120 r138  
    88#include "Behavioural/include/Types.h"
    99#include "Behavioural/Core/Core_Glue/include/Parameters.h"
     10#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Types.h"
    1011#include <sstream>
    1112
     
    5859        }
    5960
     61    {
     62      bool issue_queue_can_ooo [_nb_ooo_engine];
     63      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
     64        issue_queue_can_ooo [i] = true;
     65
     66      for (uint32_t i=0; i<_nb_execute_loop; ++i)
     67        for (uint32_t j=0; j<_execute_loop_nb_ooo_engine[i]; ++j)
     68          {
     69            Tcontext_t num_ooo_engine = _translate_execute_loop_num_ooo_engine [i][j];
     70           
     71            // Test if multiple ooo_engine for this execute loop
     72            if (_execute_loop_nb_ooo_engine[i]>1)
     73              issue_queue_can_ooo [num_ooo_engine] = false;
     74          }
     75
     76      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
     77        if (not _issue_queue_in_order [i] and // out of order
     78            not issue_queue_can_ooo [i])
     79          test.error(toString(_("The scheme of Issue queue in ooo_engine [%d] must be \"%s\" because, the execute loop can be access with multiple ooo_engine (deadlock is possible).\n"),i,toString(core::multi_ooo_engine::ooo_engine::issue_queue::ISSUE_QUEUE_SCHEME_IN_ORDER).c_str()));
     80    }
     81
    6082    if (_dispatch_load_balancing != LOAD_BALANCING_MAXIMUM_FOR_PRIORITY)
    6183      test.error(toString(_("distpatch load_balancing scheme \"%s\" is not yet supported.\n"),toString(_dispatch_load_balancing).c_str()));
Note: See TracChangeset for help on using the changeset viewer.