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/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_function_in_order_genMealy_issue_out.cpp

    r115 r117  
    3030      Tcontrol_t val [_param->_nb_inst_issue];
    3131
     32      uint32_t index=0;
    3233      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
    3334        val [i] = 0;
    3435
     36      //--------------------------------------
    3537      // From Reexecute_queue
     38      //--------------------------------------
    3639
     40      // scan all reexecute_queue slot ...
    3741//       uint32_t num_reexecute_entry = 0;
    3842      for (std::list<entry_t*>::iterator it=_reexecute_queue.begin();
    … …  
    4246          entry_t* entry = (*it);
    4347
    44           for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
    45             // test if no previous transaction and can accept this type
    46             if ((val[i] == 0) and _param->_table_issue_type [i][entry->_type])
    47               {
    48                 // find a issue port
    49                 val [i] = 1;
    50            
    51                 if (_param->_have_port_context_id)
    52                 PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
    53                 if (_param->_have_port_front_end_id)
    54                 PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
    55                 if (_param->_have_port_rob_ptr  )
    56                 PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
    57                 PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
    58                 PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
    59                 PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
    60                 if (_param->_have_port_load_queue_ptr)
    61                 PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
    62                 PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
    63                 PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
    64                 PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
    65                 PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
    66                 PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
    67                 PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
    68                 PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
    69                 PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
    70                 PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
    71                 PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
    72                 PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
    73                 PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
     48          val [index] = 1;
     49             
     50          if (_param->_have_port_context_id)
     51          PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [index], entry->_context_id           );
     52          if (_param->_have_port_front_end_id)
     53          PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [index], entry->_front_end_id         );
     54          if (_param->_have_port_rob_ptr  )
     55          PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [index], entry->_packet_id            );
     56          PORT_WRITE(out_ISSUE_OUT_OPERATION             [index], entry->_operation            );
     57          PORT_WRITE(out_ISSUE_OUT_TYPE                  [index], entry->_type                 );
     58          PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [index], entry->_store_queue_ptr_write);
     59          if (_param->_have_port_load_queue_ptr)
     60          PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [index], entry->_load_queue_ptr_write );
     61          PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [index], entry->_has_immediat         );
     62          PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [index], entry->_immediat             );
     63          PORT_WRITE(out_ISSUE_OUT_READ_RA               [index], entry->_read_ra              );
     64          PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [index], entry->_num_reg_ra           );
     65          PORT_WRITE(out_ISSUE_OUT_READ_RB               [index], entry->_read_rb              );
     66          PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [index], entry->_num_reg_rb           );
     67          PORT_WRITE(out_ISSUE_OUT_READ_RC               [index], entry->_read_rc              );
     68          PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [index], entry->_num_reg_rc           );
     69          PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [index], entry->_write_rd             );
     70          PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [index], entry->_num_reg_rd           );
     71          PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [index], entry->_write_re             );
     72          PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [index], entry->_num_reg_re           );
    7473
    75                 internal_ISSUE_OUT_FROM_REEXECUTE [i] = true;
    76 //              internal_ISSUE_OUT_NUM_BANK       [i] = num_reexecute_entry;
    77                 internal_ISSUE_OUT_ENTRY          [i] = entry;
     74          internal_ISSUE_OUT_FROM_REEXECUTE [index] = true;
     75//        internal_ISSUE_OUT_NUM_BANK       [index] = num_reexecute_entry;
     76          internal_ISSUE_OUT_ENTRY          [index] = entry;
    7877
    79                 break; // stop scan
    80               }
    81 //           num_reexecute_entry ++;
     78          index ++; // next slot
    8279        }
     80     
     81      //--------------------------------------
     82      // From Issue_queue
     83      //--------------------------------------
     84      index = _param->_nb_inst_reexecute;
    8385
    84       // From Issue_queue
     86      log_printf(TRACE,Issue_queue,FUNCTION,"  * From Issue_queue");
     87
     88      // for all instruction in issue_queue head ...
    8589      for (uint32_t i=0; i<_param->_nb_bank; ++i)
    8690        {
    … …  
    8993          log_printf(TRACE,Issue_queue,FUNCTION,"    * Bank [%d]",num_bank);
    9094         
    91           bool find = false;
     95//           bool find = false;
    9296         
    93           // Have instruction ?
     97          // ... test if have an instruction
    9498          if (not _issue_queue [num_bank].empty())
    9599            {
    96100              log_printf(TRACE,Issue_queue,FUNCTION,"      * Not Empty !!!");
    97101
     102              // read instruction
    98103              entry_t* entry = _issue_queue [num_bank].front();
    99104             
    100               // have valid instruction, search a valid issue slot.
    101               for (uint32_t j=0; j<_param->_nb_inst_issue; j++)
    102                 {
    103                   Tcontrol_t issue_ack = PORT_READ(in_ISSUE_OUT_ACK [j]);
     105//               Tcontrol_t issue_ack = PORT_READ(in_ISSUE_OUT_ACK [index]);
     106             
     107              log_printf(TRACE,Issue_queue,FUNCTION,"      * Issue [%d]",index);
     108//               log_printf(TRACE,Issue_queue,FUNCTION,"        * issue_ack            : %d",issue_ack);
     109//            log_printf(TRACE,Issue_queue,FUNCTION,"        * previous transaction : %d",val[index]);
     110//            log_printf(TRACE,Issue_queue,FUNCTION,"        * can issue type       : %d",_param->_table_issue_type [index][entry->_type]);
    104111
    105                   log_printf(TRACE,Issue_queue,FUNCTION,"      * Issue [%d]",j);
    106                   log_printf(TRACE,Issue_queue,FUNCTION,"        * issue_ack            : %d",issue_ack);
    107                   log_printf(TRACE,Issue_queue,FUNCTION,"        * previous transaction : %d",val[j]);
    108                   log_printf(TRACE,Issue_queue,FUNCTION,"        * can issue type       : %d",_param->_table_issue_type [j][entry->_type]);
     112              // in_order : test if find a valid read_unit
     113//               if (issue_ack)
     114//                 {
     115//                log_printf(TRACE,Issue_queue,FUNCTION,"        * find !!!");
     116                 
     117//                   find = true;
     118//                 }
    109119
    110                   // test if no previous transaction and can accept this type
    111                   if (not val[j] and
    112                       _param->_table_issue_type [j][entry->_type] and
    113                       issue_ack)
    114                     {
    115                       log_printf(TRACE,Issue_queue,FUNCTION,"        * find !!!");
    116                      
    117                       // find a issue port
    118                       val [j] = 1;
    119                      
    120                       if (_param->_have_port_context_id)
    121                       PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [j], entry->_context_id           );
    122                       if (_param->_have_port_front_end_id)
    123                       PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [j], entry->_front_end_id         );
    124                       if (_param->_have_port_rob_ptr  )
    125                       PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [j], entry->_packet_id            );
    126                       PORT_WRITE(out_ISSUE_OUT_OPERATION             [j], entry->_operation            );
    127                       PORT_WRITE(out_ISSUE_OUT_TYPE                  [j], entry->_type                 );
    128                       PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [j], entry->_store_queue_ptr_write);
    129                       if (_param->_have_port_load_queue_ptr)
    130                       PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [j], entry->_load_queue_ptr_write );
    131                       PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [j], entry->_has_immediat         );
    132                       PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [j], entry->_immediat             );
    133                       PORT_WRITE(out_ISSUE_OUT_READ_RA               [j], entry->_read_ra              );
    134                       PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [j], entry->_num_reg_ra           );
    135                       PORT_WRITE(out_ISSUE_OUT_READ_RB               [j], entry->_read_rb              );
    136                       PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [j], entry->_num_reg_rb           );
    137                       PORT_WRITE(out_ISSUE_OUT_READ_RC               [j], entry->_read_rc              );
    138                       PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [j], entry->_num_reg_rc           );
    139                       PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [j], entry->_write_rd             );
    140                       PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [j], entry->_num_reg_rd           );
    141                       PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [j], entry->_write_re             );
    142                       PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [j], entry->_num_reg_re           );
    143                      
    144                       internal_ISSUE_OUT_FROM_REEXECUTE [j] = false;
    145                       internal_ISSUE_OUT_NUM_BANK       [j] = num_bank;
    146                       internal_ISSUE_OUT_ENTRY          [j] = entry;
    147                      
    148                       find = true;
    149                       break; // find : stop scan
    150                     }
    151                 }
     120              // find a issue port
     121              val [index] = true; // instruction is valid
     122             
     123              if (_param->_have_port_context_id)
     124              PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [index], entry->_context_id           );
     125              if (_param->_have_port_front_end_id)
     126              PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [index], entry->_front_end_id         );
     127              if (_param->_have_port_rob_ptr  )
     128              PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [index], entry->_packet_id            );
     129              PORT_WRITE(out_ISSUE_OUT_OPERATION             [index], entry->_operation            );
     130              PORT_WRITE(out_ISSUE_OUT_TYPE                  [index], entry->_type                 );
     131              PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [index], entry->_store_queue_ptr_write);
     132              if (_param->_have_port_load_queue_ptr)
     133              PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [index], entry->_load_queue_ptr_write );
     134              PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [index], entry->_has_immediat         );
     135              PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [index], entry->_immediat             );
     136              PORT_WRITE(out_ISSUE_OUT_READ_RA               [index], entry->_read_ra              );
     137              PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [index], entry->_num_reg_ra           );
     138              PORT_WRITE(out_ISSUE_OUT_READ_RB               [index], entry->_read_rb              );
     139              PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [index], entry->_num_reg_rb           );
     140              PORT_WRITE(out_ISSUE_OUT_READ_RC               [index], entry->_read_rc              );
     141              PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [index], entry->_num_reg_rc           );
     142              PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [index], entry->_write_rd             );
     143              PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [index], entry->_num_reg_rd           );
     144              PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [index], entry->_write_re             );
     145              PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [index], entry->_num_reg_re           );
     146             
     147              internal_ISSUE_OUT_FROM_REEXECUTE [index] = false;
     148              internal_ISSUE_OUT_NUM_BANK       [index] = num_bank;
     149              internal_ISSUE_OUT_ENTRY          [index] = entry;
     150
     151              index ++; // next slot
    152152            }
    153153
    154           if (not find)
    155             break; // stop scan (in order)
     154//           if (not find)
     155//             {
     156//            log_printf(TRACE,Issue_queue,FUNCTION,"      * Not find. Stop Scan (in order)");
     157             
     158//               break; // stop scan (in order)
     159//             }
    156160        }
    157 
     161     
     162      // Output
    158163      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
    159164        {
    160165          internal_ISSUE_OUT_VAL [i] = val [i];
    161166          PORT_WRITE(out_ISSUE_OUT_VAL [i], internal_ISSUE_OUT_VAL [i]);
     167
     168//           // Type invalid to the Core_Glue network
     169//           if (not val [i]) // == empty
     170//             PORT_WRITE(out_ISSUE_OUT_TYPE [i], TYPE_INVALID);
    162171        }
    163172    }
Note: See TracChangeset for help on using the changeset viewer.