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 @ 118

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

1) Stat List : scan all queue to find free register
2) Write_queue : test "genMealy" add bypass [0]
3) Functionnal_unit : add const parameters to add or not the pipeline_in
4) Load Store Unit : if load make an exception, free nb_check
5) Debug, change test to add model

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