source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_transition.cpp @ 76

Last change on this file since 76 was 76, checked in by rosiere, 16 years ago

Add new component : Read_unit (no tested)
Change functionnal_unit : now use type and operation to execute the good function
Change New_Component's script
File size: 11.0 KB
Line 
1#ifdef SYSTEMC
2//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
3/*
4 * $Id$
5 *
6 * [ Description ]
7 *
8 */
9
10#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Reservation_station.h"
11
12namespace morpheo                    {
13namespace behavioural {
14namespace core {
15namespace multi_execute_loop {
16namespace execute_loop {
17namespace multi_read_unit {
18namespace read_unit {
19namespace reservation_station {
20
21#ifdef  SYSTEMC_VHDL_COMPATIBILITY
22#define dump_queue() \
23  do\
24  {\
25   log_printf(TRACE,Reservation_station,FUNCTION," * dump queue");\
26   log_printf(TRACE,Reservation_station,FUNCTION,"   * nb_elt : %d",_queue_nb_elt);\
27   for (uint32_t j=0;j<_param->_size_queue; j++)\
28   {\
29     cout << "\t"\
30          << "[" << j << "] "\
31          << "{" << _queue[j]._rob_id << " - "<< _queue[j]._context_id << "} " << " - "<< _queue[j]._front_end_id << "} " << " - "<< _queue[j]._ooo_engine_id << "} "\
32          << _queue[j]._data_ra_val << ", "\
33          << _queue[j]._num_reg_ra  << " - "\
34          << _queue[j]._data_rb_val << ","\
35          << _queue[j]._num_reg_rb  << " - "\
36          << _queue[j]._data_rc_val << ","\
37          << _queue[j]._num_reg_rc  \
38          << endl;\
39    }\
40  } while (0)
41#else
42#define dump_queue() \
43  do\
44  {\
45   log_printf(TRACE,Reservation_station,FUNCTION," * dump queue");\
46   log_printf(TRACE,Reservation_station,FUNCTION,"   * nb_elt : %d",_queue_nb_elt);\
47   for (uint32_t j=0;j<_param->_size_queue; j++)\
48   {\
49     cout << "\t"\
50          << "[" << (*_queue_control)[j] << "] "\
51          << "{" << _queue[(*_queue_control)[j]]._rob_id << " - "<< _queue[(*_queue_control)[j]]._context_id << "} " << " - "<< _queue[(*_queue_control)[j]]._front_end_id << "} " << " - "<< _queue[(*_queue_control)[j]]._ooo_engine_id << "} "\
52          << _queue[(*_queue_control)[j]]._data_ra_val << ", "\
53          << _queue[(*_queue_control)[j]]._num_reg_ra  << " - "\
54          << _queue[(*_queue_control)[j]]._data_rb_val << ","\
55          << _queue[(*_queue_control)[j]]._num_reg_rb  << " - "\
56          << _queue[(*_queue_control)[j]]._data_rc_val << ","\
57          << _queue[(*_queue_control)[j]]._num_reg_rc  \
58          << endl;\
59    }\
60  } while (0)
61#endif
62
63#undef  FUNCTION
64#define FUNCTION "Reservation_station::transition"
65  void Reservation_station::transition (void)
66  {
67    log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
68
69    if (PORT_READ(in_NRESET) == 0)
70      {
71#ifdef  SYSTEMC_VHDL_COMPATIBILITY
72        for (uint32_t i=0; i<_param->_size_queue; i++)
73          _queue_valid [i] = false;
74#else
75        _queue_control->clear();
76#endif
77      }
78    else
79      {
80        // ***** POP from reservation station
81
82        // scan in reverse order, because when we pop the queue there are an auto reorder
83        //for (int32_t i=(static_cast<int32_t>(_queue_control->nb_elt()))-1;i>=0; i--)
84        for (int32_t i=(static_cast<int32_t>(_param->_nb_inst_retire))-1;i>=0; i--)
85          {
86            if ((    internal_RETIRE_VAL [i]  == 1) and
87                (PORT_READ(in_RETIRE_ACK [i]) == 1))
88              {
89                //uint32_t index = (*_queue_control)[i];
90
91                log_printf(NONE,Reservation_station,FUNCTION,"POP  [%d]",i);
92
93                uint32_t index  = internal_RETIRE_SLOT[i];
94
95#ifdef  SYSTEMC_VHDL_COMPATIBILITY
96                _queue_valid [index] = false;
97#else
98                _queue_control->pop(index);
99#endif
100//              cout << "========== Transition : " << endl
101//                   << " * i           : " << i << endl
102//                   << " * index       : " << index << endl;
103
104                log_printf(NONE,Reservation_station,FUNCTION," * index         : %d",index);
105              }
106          }
107       
108//      dump_queue();
109
110        // ***** Bypass
111        // Note : we can take this sequence code before the PUSH in the queue, because read_queue make the bypass !!!
112       
113        // scan all entry
114        for (uint32_t i=0; 
115#ifdef  SYSTEMC_VHDL_COMPATIBILITY
116             i<_param->_size_queue;
117#else
118             i<_queue_control->nb_elt();
119#endif
120             i++)
121          {
122            uint32_t index;
123#ifdef  SYSTEMC_VHDL_COMPATIBILITY
124            index = i;
125#else
126            index = (*_queue_control)[i];
127#endif
128
129            // ***** bypass - gpr_write
130            for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
131              {
132                bool cmp;
133                if (_param->_have_port_ooo_engine_id)
134                  cmp = (PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID [j]) == _queue[index]._ooo_engine_id);
135                else
136                  cmp = true;
137
138                if ((PORT_READ(in_GPR_WRITE_VAL        [j]) == 1) and cmp)
139                  {
140                    if (PORT_READ(in_GPR_WRITE_NUM_REG [j]) == _queue[index]._num_reg_ra)
141                      {
142                        log_printf(TRACE,Reservation_station,FUNCTION," -> GPR_WRITE     [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
143                        _queue[index]._data_ra_val = 1;
144                        _queue[index]._data_ra     = PORT_READ(in_GPR_WRITE_DATA [j]);
145                      }
146                    if (PORT_READ(in_GPR_WRITE_NUM_REG [j]) == _queue[index]._num_reg_rb)
147                      {
148                        log_printf(TRACE,Reservation_station,FUNCTION," -> GPR_WRITE     [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
149                        _queue[index]._data_rb_val = 1;
150                        _queue[index]._data_rb     = PORT_READ(in_GPR_WRITE_DATA [j]);
151                      }
152                  }
153              }
154            // ***** bypass - spr_write
155            for (uint32_t j=0; j<_param->_nb_spr_write; j++)
156              {
157                bool cmp;
158                if (_param->_have_port_ooo_engine_id)
159                  cmp = (PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID [j]) == _queue[index]._ooo_engine_id);
160                else
161                  cmp = true;
162               
163                if ((PORT_READ(in_SPR_WRITE_VAL           [j]) == 1) and
164                    cmp and
165                    (PORT_READ(in_SPR_WRITE_NUM_REG       [j]) == _queue[index]._num_reg_rc))
166                  {
167                    log_printf(TRACE,Reservation_station,FUNCTION," -> SPR_WRITE     [%d] - Hit queue[%d]-SPR_RC[%d]",i,index,_queue[index]._num_reg_rc);
168                    _queue[index]._data_rc_val = 1;
169                    _queue[index]._data_rc     = PORT_READ(in_SPR_WRITE_DATA [j]);
170                  }
171              }
172            // ***** bypass - bypass_write
173            for (uint32_t j=0; j<_param->_nb_bypass_write; j++)
174              {
175                bool cmp;
176                if (_param->_have_port_ooo_engine_id)
177                  cmp = (PORT_READ(in_BYPASS_WRITE_OOO_ENGINE_ID [j]) == _queue[index]._ooo_engine_id);
178                else
179                  cmp = true;
180
181                if (cmp)
182                  {
183                    if (PORT_READ(in_BYPASS_WRITE_GPR_VAL    [j]) == 1)
184                      {
185                    if (PORT_READ(in_BYPASS_WRITE_GPR_NUM_REG[j]) == _queue[index]._num_reg_ra)
186                      {
187                        log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_WRITE  [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
188                        _queue[index]._data_ra_val = 1;
189                        _queue[index]._data_ra     = PORT_READ(in_BYPASS_WRITE_GPR_DATA [j]);
190                      }
191                    if (PORT_READ(in_BYPASS_WRITE_GPR_NUM_REG [j]) == _queue[index]._num_reg_rb)
192                      {
193                        log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_WRITE  [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
194                        _queue[index]._data_rb_val = 1;
195                        _queue[index]._data_rb     = PORT_READ(in_BYPASS_WRITE_GPR_DATA [j]);
196                      }
197                      }
198                    if ((PORT_READ(in_BYPASS_WRITE_SPR_VAL    [j]) == 1) and
199                        (PORT_READ(in_BYPASS_WRITE_SPR_NUM_REG[j]) == _queue[index]._num_reg_rc))
200                      {
201                        log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_WRITE  [%d] - Hit queue[%d]-SPR_RC[%d]",i,index,_queue[index]._num_reg_rc);
202                        _queue[index]._data_rc_val = 1;
203                        _queue[index]._data_rc     = PORT_READ(in_BYPASS_WRITE_SPR_DATA [j]);
204                      }
205                  }
206              }
207            // ***** bypass - bypass_memory
208            for (uint32_t j=0; j<_param->_nb_bypass_memory; j++)
209              {
210                bool cmp;
211                if (_param->_have_port_ooo_engine_id)
212                  cmp = (PORT_READ(in_BYPASS_MEMORY_OOO_ENGINE_ID [j]) == _queue[index]._ooo_engine_id);
213                else
214                  cmp = true;
215
216                if ((PORT_READ(in_BYPASS_MEMORY_VAL           [j]) == 1) and cmp)
217                  {
218                    if (PORT_READ(in_BYPASS_MEMORY_NUM_REG [j]) == _queue[index]._num_reg_ra)
219                      {
220                        log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_MEMORY [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
221                        _queue[index]._data_ra_val = 1;
222                        _queue[index]._data_ra     = PORT_READ(in_BYPASS_MEMORY_DATA [j]);
223                      }
224                    if (PORT_READ(in_BYPASS_MEMORY_NUM_REG [j]) == _queue[index]._num_reg_rb)
225                      {
226                        log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_MEMORY [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
227                        _queue[index]._data_rb_val = 1;
228                        _queue[index]._data_rb     = PORT_READ(in_BYPASS_MEMORY_DATA [j]);
229                      }
230                  }
231              }
232          }
233        // ***** PUSH to reservation station
234        if ((PORT_READ(in_INSERT_VAL) == 1) and
235            (    internal_INSERT_ACK  == 1))
236          {
237            log_printf(TRACE,Reservation_station,FUNCTION,"PUSH");
238
239            // Write in reservation station
240            uint32_t index;
241
242#ifdef  SYSTEMC_VHDL_COMPATIBILITY
243            index = internal_INSERT_SLOT;
244            _queue_valid [internal_INSERT_SLOT] = true;
245#else
246            index = _queue_control->push();
247#endif
248            log_printf(TRACE,Reservation_station,FUNCTION," * index         : %d",index);
249
250            if (_param->_have_port_context_id)
251            _queue[index]._context_id      = PORT_READ(in_INSERT_CONTEXT_ID     );
252            if (_param->_have_port_front_end_id)
253            _queue[index]._front_end_id    = PORT_READ(in_INSERT_FRONT_END_ID   );
254            if (_param->_have_port_ooo_engine_id)
255            _queue[index]._ooo_engine_id   = PORT_READ(in_INSERT_OOO_ENGINE_ID  );
256            if (_param->_have_port_rob_id)
257            _queue[index]._rob_id          = PORT_READ(in_INSERT_ROB_ID         );
258            _queue[index]._operation       = PORT_READ(in_INSERT_OPERATION      );
259            _queue[index]._type            = PORT_READ(in_INSERT_TYPE           );
260            _queue[index]._store_queue_ptr_write = PORT_READ(in_INSERT_STORE_QUEUE_PTR_WRITE);
261            _queue[index]._load_queue_ptr_write  = PORT_READ(in_INSERT_LOAD_QUEUE_PTR_WRITE );
262            _queue[index]._has_immediat    = PORT_READ(in_INSERT_HAS_IMMEDIAT   );
263            _queue[index]._immediat        = PORT_READ(in_INSERT_IMMEDIAT       );
264//          _queue[index]._read_ra         = PORT_READ(in_INSERT_READ_RA        );
265            _queue[index]._num_reg_ra      = PORT_READ(in_INSERT_NUM_REG_RA     );
266            _queue[index]._data_ra_val     = PORT_READ(in_INSERT_DATA_RA_VAL    );
267            _queue[index]._data_ra         = PORT_READ(in_INSERT_DATA_RA        );
268//          _queue[index]._read_rb         = PORT_READ(in_INSERT_READ_RB        );
269            _queue[index]._num_reg_rb      = PORT_READ(in_INSERT_NUM_REG_RB     );
270            _queue[index]._data_rb_val     = PORT_READ(in_INSERT_DATA_RB_VAL    );
271            _queue[index]._data_rb         = PORT_READ(in_INSERT_DATA_RB        );
272//          _queue[index]._read_rc         = PORT_READ(in_INSERT_READ_RC        );
273            _queue[index]._num_reg_rc      = PORT_READ(in_INSERT_NUM_REG_RC     );
274            _queue[index]._data_rc_val     = PORT_READ(in_INSERT_DATA_RC_VAL    );
275            _queue[index]._data_rc         = PORT_READ(in_INSERT_DATA_RC        );
276            _queue[index]._write_rd        = PORT_READ(in_INSERT_WRITE_RD       );
277            _queue[index]._num_reg_rd      = PORT_READ(in_INSERT_NUM_REG_RD     );
278            _queue[index]._write_re        = PORT_READ(in_INSERT_WRITE_RE       );
279            _queue[index]._num_reg_re      = PORT_READ(in_INSERT_NUM_REG_RE     );
280//          dump_queue();
281          }
282      }
283
284    end_cycle ();
285
286    log_printf(FUNC,Reservation_station,FUNCTION,"End");
287  };
288
289}; // end namespace reservation_station
290}; // end namespace read_unit
291}; // end namespace multi_read_unit
292}; // end namespace execute_loop
293}; // end namespace multi_execute_loop
294}; // end namespace core
295
296}; // end namespace behavioural
297}; // end namespace morpheo             
298#endif
299//#endif
Note: See TracBrowser for help on using the repository browser.