source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_function_in_order_genMealy_issue_out.cpp @ 111

Last change on this file since 111 was 111, checked in by rosiere, 15 years ago

1) Decod_queue : multi implementation (one_fifo, multi_fifo)
2) Issue_queue : multi implementation (in_order, out_of_order)
3) Direction : Add Meta predictor
4) Context_State : re add Branch_complete, More priority to Load miss (is not speculative)
5) Return_Address_Stack : update reg_PREDICT pointer on decod miss prediction
6) UPT : Fix bug in multi event
7) Prediction_glue : in read_stack case, insert in UPT pc_next
8) Rename select : when rob have an event (need flush), read_r{a,b,c} and write_r{d,e} is set at 0
  • Property svn:keywords set to Id
File size: 8.1 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id: Issue_queue_function_in_order_genMealy_issue_out.cpp 111 2009-02-27 18:37:40Z rosiere $
4 *
5 * [ Description ]
6 *
7 */
8
9#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Issue_queue.h"
10
11namespace morpheo                    {
12namespace behavioural {
13namespace core {
14namespace multi_ooo_engine {
15namespace ooo_engine {
16namespace issue_queue {
17
18
19#undef  FUNCTION
20#define FUNCTION "Issue_queue::function_in_order_genMealy_issue_out"
21  void Issue_queue::function_in_order_genMealy_issue_out (void)
22  {
23    log_begin(Issue_queue,FUNCTION);
24    log_function(Issue_queue,FUNCTION,_name.c_str());
25
26    // ===================================================================
27    // =====[ ISSUE_OUT ]=================================================
28    // ===================================================================
29    {
30      Tcontrol_t val [_param->_nb_inst_issue];
31
32      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
33        val [i] = 0;
34
35      // From Reexecute_queue
36
37//       uint32_t num_reexecute_entry = 0;
38      for (std::list<entry_t*>::iterator it=_reexecute_queue.begin();
39           it!=_reexecute_queue.end();
40           ++it)
41        {
42          entry_t* entry = (*it);
43
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           );
74
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;
78
79                break; // stop scan
80              }
81//           num_reexecute_entry ++;
82        }
83
84      // From Issue_queue
85      for (uint32_t i=0; i<_param->_nb_bank; ++i)
86        {
87          uint32_t num_bank=(reg_NUM_BANK_HEAD+i)%_param->_nb_bank;
88         
89          log_printf(TRACE,Issue_queue,FUNCTION,"    * Bank [%d]",num_bank);
90         
91          bool find = false;
92         
93          // Have instruction ?
94          if (not _issue_queue [num_bank].empty())
95            {
96              log_printf(TRACE,Issue_queue,FUNCTION,"      * Not Empty !!!");
97
98              entry_t* entry = _issue_queue [num_bank].front();
99             
100              for (uint32_t j=0; j<_param->_nb_inst_issue; j++)
101                {
102                  log_printf(TRACE,Issue_queue,FUNCTION,"    * Issue [%d]",j);
103                  log_printf(TRACE,Issue_queue,FUNCTION,"      * issue_ack            : %d",PORT_READ(in_ISSUE_OUT_ACK [j]));
104                  log_printf(TRACE,Issue_queue,FUNCTION,"      * previous transaction : %d",val[j]);
105                  log_printf(TRACE,Issue_queue,FUNCTION,"      * can issue type       : %d",_param->_table_issue_type [j][entry->_type]);
106
107                  // test if no previous transaction and can accept this type
108                  if ((val[j] == 0) and
109                      _param->_table_issue_type [j][entry->_type] and
110                      PORT_READ(in_ISSUE_OUT_ACK [j]))
111                    {
112                      log_printf(TRACE,Issue_queue,FUNCTION,"    * find : %d",j);
113                     
114                      // find a issue port
115                      val [j] = 1;
116                     
117                      if (_param->_have_port_context_id)
118                      PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [j], entry->_context_id           );
119                      if (_param->_have_port_front_end_id)
120                      PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [j], entry->_front_end_id         );
121                      if (_param->_have_port_rob_ptr  )
122                      PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [j], entry->_packet_id            );
123                      PORT_WRITE(out_ISSUE_OUT_OPERATION             [j], entry->_operation            );
124                      PORT_WRITE(out_ISSUE_OUT_TYPE                  [j], entry->_type                 );
125                      PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [j], entry->_store_queue_ptr_write);
126                      if (_param->_have_port_load_queue_ptr)
127                      PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [j], entry->_load_queue_ptr_write );
128                      PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [j], entry->_has_immediat         );
129                      PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [j], entry->_immediat             );
130                      PORT_WRITE(out_ISSUE_OUT_READ_RA               [j], entry->_read_ra              );
131                      PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [j], entry->_num_reg_ra           );
132                      PORT_WRITE(out_ISSUE_OUT_READ_RB               [j], entry->_read_rb              );
133                      PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [j], entry->_num_reg_rb           );
134                      PORT_WRITE(out_ISSUE_OUT_READ_RC               [j], entry->_read_rc              );
135                      PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [j], entry->_num_reg_rc           );
136                      PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [j], entry->_write_rd             );
137                      PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [j], entry->_num_reg_rd           );
138                      PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [j], entry->_write_re             );
139                      PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [j], entry->_num_reg_re           );
140                     
141                      internal_ISSUE_OUT_FROM_REEXECUTE [j] = false;
142                      internal_ISSUE_OUT_NUM_BANK       [j] = num_bank;
143                      internal_ISSUE_OUT_ENTRY          [j] = entry;
144                     
145                      find = true;
146                      break; // find : stop scan
147                    }
148                }
149            }
150
151          if (not find)
152            break; // stop scan (in order)
153        }
154
155      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
156        {
157          internal_ISSUE_OUT_VAL [i] = val [i];
158          PORT_WRITE(out_ISSUE_OUT_VAL [i], internal_ISSUE_OUT_VAL [i]);
159        }
160    }
161
162    log_end(Issue_queue,FUNCTION);
163  };
164
165}; // end namespace issue_queue
166}; // end namespace ooo_engine
167}; // end namespace multi_ooo_engine
168}; // end namespace core
169
170}; // end namespace behavioural
171}; // end namespace morpheo             
172#endif
Note: See TracBrowser for help on using the repository browser.