source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_transition.cpp

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

1) Add new algo in ifetch queue
2) Add Cancel bit
3) new config
  • Property svn:keywords set to Id
File size: 13.2 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id: Functionnal_unit_transition.cpp 136 2009-10-20 18:52:15Z rosiere $
4 *
5 * [ Description ]
6 *
7 */
8
9#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h"
10
11namespace morpheo                    {
12namespace behavioural {
13namespace core {
14namespace multi_execute_loop {
15namespace execute_loop {
16namespace multi_execute_unit {
17namespace execute_unit {
18namespace functionnal_unit {
19
20
21#undef  FUNCTION
22#define FUNCTION "Functionnal_unit::transition"
23  void Functionnal_unit::transition (void)
24  {
25    log_begin(Functionnal_unit,FUNCTION);
26    log_function(Functionnal_unit,FUNCTION,_name.c_str());
27
28    if (PORT_READ(in_NRESET) == 0)
29      {
30        if (_param->_have_pipeline_in)
31        reg_BUSY_IN  = false;
32        reg_BUSY_OUT = false;
33       
34        for (uint32_t i=0; i<_param->_nb_context; i++)
35          for (uint32_t j=0; j<_param->_nb_front_end; j++)
36            for (uint32_t k=0; k<_param->_nb_ooo_engine; k++)
37              {
38//              uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
39//                                                   j,_param->_size_front_end_id,
40//                                                   k,_param->_size_ooo_engine_id);
41               
42                for (uint32_t x=GROUP_CUSTOM_1; x<GROUP_CUSTOM_8; x++)
43                  {
44                    function_execute_end_cycle_t * fct = (_param->_get_custom_information()._get_custom_execute_reset(x));
45                   
46                    if (fct != NULL)
47                      (* fct) (_execute_register[i][j][k], _execute_param);
48                  }
49              }
50
51        _execute_operation_out->_context_id    = 0; // not necessary
52        _execute_operation_out->_front_end_id  = 0; // not necessary
53        _execute_operation_out->_ooo_engine_id = 0; // not necessary
54        _execute_operation_out->_packet_id     = 0; // not necessary
55  //    _execute_operation_out->_operation     = 0; // not necessary
56  //    _execute_operation_out->_type          = 0; // not necessary
57        _execute_operation_out->_cancel        = 0; // not necessary
58        _execute_operation_out->_write_rd      = 0; // not necessary
59        _execute_operation_out->_num_reg_rd    = 0; // not necessary
60        _execute_operation_out->_data_rd       = 0; // not necessary
61        _execute_operation_out->_write_re      = 0; // not necessary
62        _execute_operation_out->_num_reg_re    = 0; // not necessary
63        _execute_operation_out->_data_re       = 0; // not necessary
64        _execute_operation_out->_exception     = 0; // not necessary
65        _execute_operation_out->_no_sequence   = 0; // not necessary
66        _execute_operation_out->_address       = 0; // not necessary
67      }
68    else
69      {
70        // Test if pop an instruction
71        if (internal_EXECUTE_OUT_VAL and PORT_READ(in_EXECUTE_OUT_ACK))
72          {
73            log_printf(TRACE,Functionnal_unit,FUNCTION,"  * EXECUTE_OUT : Transaction Accepted");
74            reg_BUSY_OUT = false;
75          }
76       
77        // Test if can move instruction in pipeline in to pipeline out
78        if (_param->_have_pipeline_in)
79        if (reg_BUSY_IN and not reg_BUSY_OUT)
80          {
81            reg_BUSY_OUT = reg_BUSY_IN;
82            reg_BUSY_IN  = false;
83
84            _execute_operation_out->_timing        = _execute_operation_in->_timing       ;
85            _execute_operation_out->_context_id    = _execute_operation_in->_context_id   ;
86            _execute_operation_out->_front_end_id  = _execute_operation_in->_front_end_id ;
87            _execute_operation_out->_ooo_engine_id = _execute_operation_in->_ooo_engine_id;
88            _execute_operation_out->_packet_id     = _execute_operation_in->_packet_id    ;
89            _execute_operation_out->_operation     = _execute_operation_in->_operation    ;
90            _execute_operation_out->_type          = _execute_operation_in->_type         ;
91            _execute_operation_out->_cancel        = _execute_operation_in->_cancel       ;
92            _execute_operation_out->_has_immediat  = _execute_operation_in->_has_immediat ;
93            _execute_operation_out->_immediat      = _execute_operation_in->_immediat     ;
94            _execute_operation_out->_data_ra       = _execute_operation_in->_data_ra      ;
95            _execute_operation_out->_data_rb       = _execute_operation_in->_data_rb      ;
96            _execute_operation_out->_data_rc       = _execute_operation_in->_data_rc      ;
97            _execute_operation_out->_data_rd       = _execute_operation_in->_data_rd      ;
98            _execute_operation_out->_data_re       = _execute_operation_in->_data_re      ;
99            _execute_operation_out->_write_rd      = _execute_operation_in->_write_rd     ;
100            _execute_operation_out->_num_reg_rd    = _execute_operation_in->_num_reg_rd   ;
101            _execute_operation_out->_write_re      = _execute_operation_in->_write_re     ;
102            _execute_operation_out->_num_reg_re    = _execute_operation_in->_num_reg_re   ;
103            _execute_operation_out->_exception     = _execute_operation_in->_exception    ;
104            _execute_operation_out->_no_sequence   = _execute_operation_in->_no_sequence  ;
105            _execute_operation_out->_address       = _execute_operation_in->_address      ;
106          }
107
108        // Test if push
109        execute_register_t * execute_register = NULL;
110
111        if (PORT_READ(in_EXECUTE_IN_VAL) and internal_EXECUTE_IN_ACK)
112          {
113            log_printf(TRACE,Functionnal_unit,FUNCTION,"  * EXECUTE_IN : Transaction Accepted");
114
115            execute_operation_t * execute_operation;
116
117            if (_param->_have_pipeline_in)
118              {
119            reg_BUSY_IN       = true;
120            execute_operation = _execute_operation_in;
121              }
122            else
123              {
124            reg_BUSY_OUT      = true;
125            execute_operation = _execute_operation_out;
126              }
127
128            Tcontext_t   context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_IN_CONTEXT_ID   ):0;
129            Tcontext_t   front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_IN_FRONT_END_ID ):0;
130            Tcontext_t   ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_IN_OOO_ENGINE_ID):0;
131            Tcontext_t   packet_id     = (_param->_have_port_rob_ptr      )?PORT_READ(in_EXECUTE_IN_PACKET_ID    ):0;
132            Toperation_t operation     = PORT_READ(in_EXECUTE_IN_OPERATION);
133            Ttype_t      type          = PORT_READ(in_EXECUTE_IN_TYPE);
134            Tcontrol_t   cancel        = PORT_READ(in_EXECUTE_IN_CANCEL);
135
136            execute_operation->_context_id    = context_id   ;
137            execute_operation->_front_end_id  = front_end_id ;
138            execute_operation->_ooo_engine_id = ooo_engine_id;
139            execute_operation->_packet_id     = packet_id    ;
140            execute_operation->_operation     = operation    ;
141            execute_operation->_type          = type         ;
142            execute_operation->_cancel        = cancel       ;
143            execute_operation->_has_immediat  = PORT_READ(in_EXECUTE_IN_HAS_IMMEDIAT);
144            execute_operation->_immediat      = PORT_READ(in_EXECUTE_IN_IMMEDIAT    );
145            execute_operation->_data_ra       = PORT_READ(in_EXECUTE_IN_DATA_RA     );
146            execute_operation->_data_rb       = PORT_READ(in_EXECUTE_IN_DATA_RB     );
147            execute_operation->_data_rc       = PORT_READ(in_EXECUTE_IN_DATA_RC     );
148            execute_operation->_write_rd      = PORT_READ(in_EXECUTE_IN_WRITE_RD    );
149            execute_operation->_num_reg_rd    = PORT_READ(in_EXECUTE_IN_NUM_REG_RD  );
150            execute_operation->_data_rd       = 0; // no necessaray
151            execute_operation->_write_re      = PORT_READ(in_EXECUTE_IN_WRITE_RE    );
152            execute_operation->_num_reg_re    = PORT_READ(in_EXECUTE_IN_NUM_REG_RE  );
153            execute_operation->_data_re       = 0; // no necessaray
154            execute_operation->_exception     = 0; // no necessaray
155            execute_operation->_no_sequence   = 0; // no necessaray
156            execute_operation->_address       = 0; // no necessaray
157
158            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * context_id    : %d",execute_operation->_context_id   );
159            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * front_end_id  : %d",execute_operation->_front_end_id );
160            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * ooo_engine_id : %d",execute_operation->_ooo_engine_id);
161            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * packet_id     : %d",execute_operation->_packet_id    );
162            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * operation     : %d",execute_operation->_operation    );
163            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * type          : %s",toString(execute_operation->_type).c_str());
164            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * cancel        : %d",execute_operation->_cancel       );
165            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * has_immediat  : %d",execute_operation->_has_immediat );
166            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * immediat      : %.8x",execute_operation->_immediat     );
167            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_ra       : %.8x",execute_operation->_data_ra      );
168            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rb       : %.8x",execute_operation->_data_rb      );
169            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rc       : %.8x",execute_operation->_data_rc      );
170            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_rd      : %d"  ,execute_operation->_write_rd     );
171            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_rd    : %d"  ,execute_operation->_num_reg_rd   );
172            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_re      : %d"  ,execute_operation->_write_re     );
173            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_re    : %d"  ,execute_operation->_num_reg_re   );
174           
175#ifdef DEBUG_TEST
176            if (type >= _param->_nb_type)
177              throw ERRORMORPHEO(FUNCTION,"Invalid type : '"+toString(type)+"' is higher that _nb_type");
178            if (operation >= _param->_nb_operation)
179              throw ERRORMORPHEO(FUNCTION,"Invalid operation : '"+toString(operation)+"' is higher that _nb_operation");
180#endif
181
182            // execute the operation
183            execute_register = _execute_register[context_id][front_end_id][ooo_engine_id];
184
185            // Test if operation is a custom
186            if (type == TYPE_CUSTOM)
187              {
188//              uint32_t num_thread = get_num_thread(context_id   ,_param->_size_context_id,
189//                                                   front_end_id ,_param->_size_front_end_id,
190//                                                   ooo_engine_id,_param->_size_ooo_engine_id);
191
192                (*(_param->_get_custom_information()._get_custom_execute_genMoore(operation))) (execute_operation, execute_register, _execute_param);
193              }
194            else
195              (*(_function_execute[type][operation])) (execute_operation, execute_register, _execute_param);
196
197
198            log_printf(TRACE,Functionnal_unit,FUNCTION,"    -----------------");
199            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * latence       : %.8x",execute_operation->_timing._latence);
200            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * delay         : %.8x",execute_operation->_timing._delay);
201            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rd       : %.8x",execute_operation->_data_rd    );
202            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_re       : %.8x",execute_operation->_data_re    );
203            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * exception     : %d"  ,execute_operation->_exception  );
204            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * no_sequence   : %d"  ,execute_operation->_no_sequence);
205            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * address       : %.8x (%.8x)",execute_operation->_address,execute_operation->_address<<2);
206
207#ifdef STATISTICS
208            if (usage_is_set(_usage,USE_STATISTICS))
209              {
210                (*_stat_use_functionnal_unit) ++;
211                (*_stat_sum_delay)   += execute_operation->_timing._delay;
212                (*_stat_sum_latence) += execute_operation->_timing._latence;
213              }
214#endif
215          }
216       
217        // End cycle
218        {
219          for (uint32_t i=0; i<_param->_nb_context; i++)
220            for (uint32_t j=0; j<_param->_nb_front_end; j++)
221              for (uint32_t k=0; k<_param->_nb_ooo_engine; k++)
222                {
223//                uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
224//                                                     j,_param->_size_front_end_id,
225//                                                     k,_param->_size_ooo_engine_id);
226
227                  for (uint32_t x=GROUP_CUSTOM_1; x<GROUP_CUSTOM_8; x++)
228                    {
229                      function_execute_end_cycle_t * fct = (_param->_get_custom_information()._get_custom_execute_transition(x));
230                     
231                      if (fct != NULL)
232                        (* fct) (_execute_register[i][j][k], _execute_param);
233                    }
234                }
235
236          // Update status
237          if (execute_register != NULL)
238            {
239              // They have an access
240              execute_register->_i_write_spr = false;
241              execute_register->_i_read_spr  = false;
242            }
243        }
244
245       
246        // each cycle : decrease the latence
247        if (reg_BUSY_OUT and (_execute_operation_out->_timing._latence > 0))
248          _execute_operation_out->_timing._latence --;
249
250#if defined(DEBUG) and DEBUG_Functionnal_unit and (DEBUG >= DEBUG_TRACE)
251        {
252          log_printf(TRACE,Functionnal_unit,FUNCTION,"  * Dump ALU (Functionnal_unit)");
253
254          if (_param->_have_pipeline_in)
255          log_printf(TRACE,Functionnal_unit,FUNCTION,"    * reg_BUSY_IN  : %d",reg_BUSY_IN );
256          log_printf(TRACE,Functionnal_unit,FUNCTION,"    * reg_BUSY_OUT : %d",reg_BUSY_OUT);
257        }
258#endif
259      }
260   
261#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
262    end_cycle ();
263#endif
264
265    log_end(Functionnal_unit,FUNCTION);
266  };
267
268}; // end namespace functionnal_unit
269}; // end namespace execute_unit
270}; // end namespace multi_execute_unit
271}; // end namespace execute_loop
272}; // end namespace multi_execute_loop
273}; // end namespace core
274
275}; // end namespace behavioural
276}; // end namespace morpheo             
277#endif
Note: See TracBrowser for help on using the repository browser.