source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_genMealy.cpp @ 124

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

1) Add test and configuration
2) Fix Bug
3) Add log file in load store unit
4) Fix Bug in environment
  • Property svn:keywords set to Id
File size: 15.9 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id: Decod_genMealy.cpp 124 2009-06-17 12:11:25Z rosiere $
4 *
5 * [ Description ]
6 *
7 */
8
9#include "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Decod.h"
10
11namespace morpheo                    {
12namespace behavioural {
13namespace core {
14namespace multi_front_end {
15namespace front_end {
16namespace decod_unit {
17namespace decod {
18
19
20#undef  FUNCTION
21#define FUNCTION "Decod::genMealy"
22  void Decod::genMealy (void)
23  {
24    log_begin(Decod,FUNCTION);
25    log_function(Decod,FUNCTION,_name.c_str());
26
27    if (PORT_READ(in_NRESET))
28      {
29    //-----------------------------------
30    // Initialization
31    //-----------------------------------
32    Tcontrol_t context_event_val = false;
33    Tcontrol_t ifetch_ack [_param->_nb_context][_param->_max_nb_inst_fetch];
34    for (uint32_t i=0; i<_param->_nb_context; i++)
35      for (uint32_t j=0; j<_param->_nb_inst_fetch[i]; j++)
36        ifetch_ack [i][j] = false;
37
38    Tcontrol_t predict_val [_param->_nb_inst_decod];
39    Tcontrol_t decod_val   [_param->_nb_inst_decod];
40    for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
41      {
42        decod_val   [i] = false;
43        predict_val [i] = false;
44      }
45
46    Tcontrol_t can_continue      [_param->_nb_context];
47    Tcontrol_t have_decod_branch [_param->_nb_context];
48
49    Tcontext_t      CONTEXT_EVENT_CONTEXT_ID    = 0;
50    Tdepth_t        CONTEXT_EVENT_DEPTH         = 0;
51    Tevent_type_t   CONTEXT_EVENT_TYPE          = 0;
52    Tcontrol_t      CONTEXT_EVENT_IS_DELAY_SLOT = 0;
53    Tgeneral_data_t CONTEXT_EVENT_ADDRESS       = 0;
54    Tgeneral_data_t CONTEXT_EVENT_ADDRESS_EPCR  = 0;
55
56    for (uint32_t i=0; i<_param->_nb_context; i++)
57      {
58        internal_CONTEXT_HAVE_TRANSACTION [i] = false;
59        internal_CONTEXT_ADDRESS_PREVIOUS [i] = reg_CONTEXT_ADDRESS_PREVIOUS [i];
60        internal_CONTEXT_IS_DELAY_SLOT    [i] = reg_CONTEXT_IS_DELAY_SLOT    [i];
61       
62        can_continue                      [i] = PORT_READ(in_CONTEXT_DECOD_ENABLE [i]);
63        have_decod_branch                 [i] = false;
64      }
65   
66    //-----------------------------------
67    // Loop of decod
68    //-----------------------------------
69    // scan all decod "slot_out"
70    std::list<generic::priority::select_t> * select = _priority->select();
71    std::list<generic::priority::select_t>::iterator it=select->begin();
72    for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
73      {
74        log_printf(TRACE,Decod,FUNCTION,"  * DECOD [%d]",i);   
75
76        bool ifetch_val = false;
77        while ((it != select->end())    and  // have a no scanned "slot_in" ?
78//             (decod_val [i] == false) and  // have not a previous selected entry?
79               (ifetch_val    == false) and  // not find ifetch instruction valid
80               (context_event_val == false)) // Have not a context_event (spr_access, exception, ...)
81          {
82//          predict_val [i] = false;
83
84            Tcontext_t x = it->grp;
85            uint32_t   y = it->elt;
86
87            log_printf(TRACE,Decod,FUNCTION,"    * IFETCH [%d][%d]",x,y);   
88            log_printf(TRACE,Decod,FUNCTION,"      * in_IFETCH_VAL          : %d",PORT_READ(in_IFETCH_VAL [x][y]));
89            log_printf(TRACE,Decod,FUNCTION,"      * can_continue           : %d",can_continue [x]               );
90
91            // Test if this instruction is valid
92            if ((PORT_READ(in_IFETCH_VAL [x][y]) == 1) and // entry is valid
93                (can_continue [x]                == 1))    // context can decod instruction (have not a previous event)
94              {
95                log_printf(TRACE,Decod,FUNCTION,"      * decod_ack              : %d",PORT_READ(in_DECOD_ACK [i]));
96
97                ifetch_val        = true;
98                decod_val  [i]    = true;                        // fetch_val and decod_enable
99                ifetch_ack [x][y] = PORT_READ(in_DECOD_ACK [i]); // fetch_val and decod_enable and decod_ack
100
101                Tgeneral_data_t addr = PORT_READ(in_IFETCH_ADDRESS [x])+y;
102
103                _decod_instruction->_instruction      = PORT_READ(in_IFETCH_INSTRUCTION [x][y]);
104                _decod_instruction->_context_id       = x;
105                _decod_instruction->_address_previous = internal_CONTEXT_ADDRESS_PREVIOUS [x];
106                _decod_instruction->_address          = addr; //Compute the current address
107                _decod_instruction->_address_next     = addr+1;
108                _decod_instruction->_is_delay_slot    = internal_CONTEXT_IS_DELAY_SLOT [x];
109
110                // Test IFetch exception
111                Texception_t ifetch_exception = PORT_READ(in_IFETCH_EXCEPTION [x]);
112
113                if (ifetch_exception == EXCEPTION_IFETCH_NONE)
114                  {
115                    // Decod !
116                    log_printf(TRACE,Decod,FUNCTION,"      * address                : %.8x (%.8x)",addr,(addr<<2));
117                    log_printf(TRACE,Decod,FUNCTION,"      * is_delay_slot          : %d",internal_CONTEXT_IS_DELAY_SLOT [x]);
118                   
119                    instruction_decod (_decod_instruction, _decod_param[x]);
120
121                    log_printf(TRACE,Decod,FUNCTION,"      * address_next           : %.8x (%.8x)",_decod_instruction->_address_next,(_decod_instruction->_address_next<<2));
122                  }
123                else
124                  {
125                    // No decod : nop
126                    instruction_l_nop (_decod_instruction, _decod_param[x]);
127
128                    _decod_instruction->_exception_use = EXCEPTION_USE_NONE;
129                    _decod_instruction->_exception     = exception_ifetch_to_exception_decod(ifetch_exception);
130                   
131                    // INSTRUCTION_TLB 
132                    // INSTRUCTION_PAGE
133                    // BUS_ERROR       
134                    if (_decod_instruction->_is_delay_slot)
135                      _decod_instruction->_address_next       = _decod_instruction->_address_previous;
136                    else
137                      _decod_instruction->_address_next       = _decod_instruction->_address;
138                   
139                    _decod_instruction->_event_type         = EVENT_TYPE_EXCEPTION;
140                  }
141
142                Ttype_t      type      = _decod_instruction->_type;
143                // Depth current. If have decod a branch and i can continue : depth = depth_next
144                Tdepth_t     depth     = (_param->_have_port_depth)?PORT_READ(in_CONTEXT_DEPTH [x]):0;
145
146                if ((_param->_nb_branch_speculated[x] > 0) and have_decod_branch [x])
147                  depth = (depth+1)%_param->_nb_branch_speculated[x];
148               
149                if (_param->_have_port_context_id)
150                PORT_WRITE(out_DECOD_CONTEXT_ID    [i], x);
151                if (_param->_have_port_depth)
152                PORT_WRITE(out_DECOD_DEPTH         [i], depth);
153                PORT_WRITE(out_DECOD_TYPE          [i], type);
154                PORT_WRITE(out_DECOD_OPERATION     [i], _decod_instruction->_operation     );
155                PORT_WRITE(out_DECOD_NO_EXECUTE    [i], _decod_instruction->_no_execute    );
156                PORT_WRITE(out_DECOD_IS_DELAY_SLOT [i], _decod_instruction->_is_delay_slot );
157#ifdef DEBUG
158                PORT_WRITE(out_DECOD_ADDRESS       [i], addr);
159#endif
160//                 if ((type == TYPE_BRANCH) and
161//                     ((_decod_instruction->_branch_condition = BRANCH_CONDITION_FLAG_SET) or
162//                      (_decod_instruction->_branch_condition = BRANCH_CONDITION_FLAG_UNSET)))
163//                 PORT_WRITE(out_DECOD_ADDRESS_NEXT  [i], _decod_instruction->_address+2);
164//                 else
165                PORT_WRITE(out_DECOD_ADDRESS_NEXT  [i], _decod_instruction->_address_next  );
166                PORT_WRITE(out_DECOD_HAS_IMMEDIAT  [i], _decod_instruction->_has_immediat  );
167                PORT_WRITE(out_DECOD_IMMEDIAT      [i], _decod_instruction->_immediat      );
168                PORT_WRITE(out_DECOD_READ_RA       [i], _decod_instruction->_read_ra       );
169                PORT_WRITE(out_DECOD_NUM_REG_RA    [i], _decod_instruction->_num_reg_ra    );
170                PORT_WRITE(out_DECOD_READ_RB       [i], _decod_instruction->_read_rb       );
171                PORT_WRITE(out_DECOD_NUM_REG_RB    [i], _decod_instruction->_num_reg_rb    );
172                PORT_WRITE(out_DECOD_READ_RC       [i], _decod_instruction->_read_rc       );
173                PORT_WRITE(out_DECOD_NUM_REG_RC    [i], _decod_instruction->_num_reg_rc    );
174                PORT_WRITE(out_DECOD_WRITE_RD      [i],(_decod_instruction->_num_reg_rd!=0)?_decod_instruction->_write_rd:0);
175                PORT_WRITE(out_DECOD_NUM_REG_RD    [i], _decod_instruction->_num_reg_rd    );
176                PORT_WRITE(out_DECOD_WRITE_RE      [i], _decod_instruction->_write_re      );
177                PORT_WRITE(out_DECOD_NUM_REG_RE    [i], _decod_instruction->_num_reg_re    );
178                PORT_WRITE(out_DECOD_EXCEPTION_USE [i], _decod_instruction->_exception_use );
179//              PORT_WRITE(out_DECOD_EXCEPTION     [i], _decod_instruction->_exception     );
180
181                // Branch predictor can accept : the depth is valid
182                log_printf(TRACE,Decod,FUNCTION,"      * context_depth_val      : %d",PORT_READ(in_CONTEXT_DEPTH_VAL [x]));
183                decod_val   [i]    &= PORT_READ(in_CONTEXT_DEPTH_VAL [x]);
184                ifetch_ack  [x][y] &= PORT_READ(in_CONTEXT_DEPTH_VAL [x]);
185
186                if (type == TYPE_BRANCH)
187                  {
188                    log_printf(TRACE,Decod,FUNCTION,"      * Instruction is branch");
189                    log_printf(TRACE,Decod,FUNCTION,"        * predict_val       : %d",ifetch_ack [x][y]);
190                    log_printf(TRACE,Decod,FUNCTION,"        * predict_ack       : %d",PORT_READ(in_PREDICT_ACK [i]));
191                                                         
192                    log_printf(TRACE,Decod,FUNCTION,"        * address src       : %.8x (%.8x)",_decod_instruction->_address     ,_decod_instruction->_address     <<2);
193                    log_printf(TRACE,Decod,FUNCTION,"        * address dest      : %.8x (%.8x)",_decod_instruction->_address_next,_decod_instruction->_address_next<<2);
194                   
195                    // test if have already decod an branch : one branch per context
196                    predict_val [i]     = not have_decod_branch [x] and ifetch_ack  [x][y] // and decod_val [i]
197                      ;
198                    decod_val   [i]    &= not have_decod_branch [x] and PORT_READ(in_PREDICT_ACK [i]);// predict_ack and fetch_val and decod_enable                 
199                    ifetch_ack  [x][y] &= not have_decod_branch [x] and PORT_READ(in_PREDICT_ACK [i]);// predict_ack and fetch_val and decod_enable and decod_ack
200               
201                    // can continue is set if direction is "not take" (also, continue is sequential order)
202
203//                  can_continue [x] = false; // one branch per context, the DS don't execute
204                    can_continue [x]&= PORT_READ(in_PREDICT_CAN_CONTINUE [i]); // one branch per context, the DS don't execute
205                    have_decod_branch [x] = true;
206                   
207                    log_printf(TRACE,Decod,FUNCTION,"      * predict_can_continue   : %d",PORT_READ(in_PREDICT_CAN_CONTINUE [i]));
208                  }
209
210                if (_param->_have_port_context_id)
211                PORT_WRITE(out_PREDICT_CONTEXT_ID                  [i],x);
212                PORT_WRITE(out_PREDICT_MATCH_INST_IFETCH_PTR       [i],y == ((_param->_have_port_inst_ifetch_ptr)?PORT_READ(in_IFETCH_INST_IFETCH_PTR [x]):0));
213                PORT_WRITE(out_PREDICT_BRANCH_STATE                [i],PORT_READ(in_IFETCH_BRANCH_STATE                [x]));
214                if (_param->_have_port_depth)
215                PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i],PORT_READ(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [x]));
216                PORT_WRITE(out_PREDICT_BRANCH_CONDITION            [i],_decod_instruction->_branch_condition  );
217//              PORT_WRITE(out_PREDICT_BRANCH_STACK_WRITE          [i],_decod_instruction->_branch_stack_write);
218                PORT_WRITE(out_PREDICT_BRANCH_DIRECTION            [i],_decod_instruction->_branch_direction  );
219                PORT_WRITE(out_PREDICT_ADDRESS_SRC                 [i],_decod_instruction->_address           );
220                PORT_WRITE(out_PREDICT_ADDRESS_DEST                [i],_decod_instruction->_address_next      );
221
222                Tevent_type_t event_type = _decod_instruction->_event_type;
223                if (event_type != EVENT_TYPE_NONE)
224                  {
225                    log_printf(TRACE,Decod,FUNCTION,"      * Instruction make an EVENT (%s)",toString(event_type).c_str());
226                    log_printf(TRACE,Decod,FUNCTION,"        * context_event_ack : %d",PORT_READ(in_CONTEXT_EVENT_ACK));
227
228                    // speculative jump at the exception handler
229                    // if type = TYPE_BRANCH, also event_type == EVENT_TYPE_NONE
230                    context_event_val   = ifetch_ack  [x][y] // and decod_val [i]
231                      ;
232                    decod_val   [i]    &= PORT_READ(in_CONTEXT_EVENT_ACK);// context_event_ack and fetch_val and decod_enable             
233                    ifetch_ack  [x][y] &= PORT_READ(in_CONTEXT_EVENT_ACK);// context_event_ack and fetch_val and decod_enable and decod_ack
234
235                    CONTEXT_EVENT_CONTEXT_ID    = x;
236                    CONTEXT_EVENT_DEPTH         = depth;
237                    CONTEXT_EVENT_TYPE          = _decod_instruction->_event_type;
238                    CONTEXT_EVENT_IS_DELAY_SLOT = _decod_instruction->_is_delay_slot;
239                    CONTEXT_EVENT_ADDRESS       = _decod_instruction->_address;
240                    CONTEXT_EVENT_ADDRESS_EPCR  = _decod_instruction->_address_next ;
241               
242                  }
243
244                // fetch_ack =
245                //   ((event_type == EVENT_TYPE_NONE) or ((event_type != EVENT_TYPE_NONE) and context_event_ack)) and
246                //   ((type       == TYPE_BRANCH    ) or ((type       != TYPE_BRANCH    ) and predict_ack      )) and
247                //   fetch_val and decod_ack and decod_enable and true (is decod_val)
248
249                // To compute the "next previous" address
250                Tcontrol_t have_transaction = ifetch_ack [x][y];
251
252                internal_CONTEXT_HAVE_TRANSACTION [x] |= have_transaction;
253                if (have_transaction)
254                  {
255                    internal_CONTEXT_ADDRESS_PREVIOUS [x] = addr;
256                    internal_CONTEXT_IS_DELAY_SLOT    [x] = (type == TYPE_BRANCH); // next is a delay slot if current have branch type
257                  }
258
259                can_continue [x] &= have_transaction; // to have a in order decod !!! if a previous instruction can decod, also next instruction can't decod.
260
261                log_printf(TRACE,Decod,FUNCTION,"      * have_transaction       : %d",have_transaction);
262
263              }
264
265            log_printf(TRACE,Decod,FUNCTION,"    - num_(decod, context, fetch) : %d %d %d",i, x, y);
266            log_printf(TRACE,Decod,FUNCTION,"      - ifetch_ack             : %d",ifetch_ack  [x][y]);
267            log_printf(TRACE,Decod,FUNCTION,"      - context_event_val      : %d",context_event_val );
268            log_printf(TRACE,Decod,FUNCTION,"      - predict_val            : %d",predict_val [i]   );
269            log_printf(TRACE,Decod,FUNCTION,"      - decod_val              : %d",decod_val   [i]   );
270           
271            it ++;
272          }
273      }
274
275    //-----------------------------------
276    // Write output
277    //-----------------------------------
278
279    for (uint32_t i=0; i<_param->_nb_context; i++)
280      for (uint32_t j=0; j<_param->_nb_inst_fetch[i]; j++)
281        PORT_WRITE(out_IFETCH_ACK [i][j], ifetch_ack [i][j]);
282
283    PORT_WRITE(out_CONTEXT_EVENT_VAL, context_event_val);
284    if (_param->_have_port_context_id)
285    PORT_WRITE(out_CONTEXT_EVENT_CONTEXT_ID   , CONTEXT_EVENT_CONTEXT_ID   );
286    if (_param->_have_port_depth)
287    PORT_WRITE(out_CONTEXT_EVENT_DEPTH        , CONTEXT_EVENT_DEPTH        );
288    PORT_WRITE(out_CONTEXT_EVENT_TYPE         , CONTEXT_EVENT_TYPE         );
289    PORT_WRITE(out_CONTEXT_EVENT_IS_DELAY_SLOT, CONTEXT_EVENT_IS_DELAY_SLOT);
290    PORT_WRITE(out_CONTEXT_EVENT_ADDRESS      , CONTEXT_EVENT_ADDRESS      );
291    PORT_WRITE(out_CONTEXT_EVENT_ADDRESS_EPCR , CONTEXT_EVENT_ADDRESS_EPCR );
292
293    for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
294      {
295        PORT_WRITE(out_PREDICT_VAL [i], predict_val [i]);
296        PORT_WRITE(out_DECOD_VAL   [i], decod_val   [i]);
297       
298#ifdef STATISTICS
299        internal_DECOD_VAL [i] = decod_val [i];
300#endif
301      }
302      }
303    else
304      {
305    for (uint32_t i=0; i<_param->_nb_context; i++)
306      {
307        internal_CONTEXT_HAVE_TRANSACTION [i] = false;
308//      internal_CONTEXT_ADDRESS_PREVIOUS [i] = reg_CONTEXT_ADDRESS_PREVIOUS [i];
309//      internal_CONTEXT_IS_DELAY_SLOT    [i] = reg_CONTEXT_IS_DELAY_SLOT    [i];
310      for (uint32_t j=0; j<_param->_nb_inst_fetch[i]; j++)
311        PORT_WRITE(out_IFETCH_ACK [i][j], 0);
312      }
313
314    PORT_WRITE(out_CONTEXT_EVENT_VAL, 0);
315
316    for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
317      {
318        PORT_WRITE(out_PREDICT_VAL [i], 0);
319        PORT_WRITE(out_DECOD_VAL   [i], 0);
320
321#ifdef STATISTICS
322        internal_DECOD_VAL [i] = 0;
323#endif
324      }
325      }
326
327    log_end(Decod,FUNCTION);
328  };
329
330}; // end namespace decod
331}; // end namespace decod_unit
332}; // end namespace front_end
333}; // end namespace multi_front_end
334}; // end namespace core
335
336}; // end namespace behavioural
337}; // end namespace morpheo             
338#endif
Note: See TracBrowser for help on using the repository browser.