source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMoore.cpp @ 119

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

1) Prediction unit : static prediction not blocking
File size: 16.5 KB
Line 
1#ifdef SYSTEMC
2/*
3 * $Id$
4 *
5 * [ Description ]
6 *
7 */
8
9#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Update_Prediction_Table.h"
10
11namespace morpheo                    {
12namespace behavioural {
13namespace core {
14namespace multi_front_end {
15namespace front_end {
16namespace prediction_unit {
17namespace update_prediction_table {
18
19
20#undef  FUNCTION
21#define FUNCTION "Update_Prediction_Table::genMoore"
22  void Update_Prediction_Table::genMoore (void)
23  {
24    log_begin(Update_Prediction_Table,FUNCTION);
25    log_function(Update_Prediction_Table,FUNCTION,_name.c_str());
26
27    if (PORT_READ(in_NRESET) == 1)
28      {
29
30    // ===================================================================
31    // =====[ DEPTH ]=====================================================
32    // ===================================================================
33
34    for (uint32_t i=0; i<_param->_nb_context; i++)
35      {
36        // is a valid instruction ?
37        // If DEPTH_CURRENT :
38        // equal at     DEPTH_MIN            -> not speculative
39        // not include ]DEPTH_MIN:DEPTH_MAX] -> previous branch miss
40        //     include ]DEPTH_MIN:DEPTH_MAX] -> speculative
41
42        PORT_WRITE(out_DEPTH_VAL     [i],((reg_UPDATE_PREDICTION_TABLE [i][reg_UPT_TOP [i]]._state == UPDATE_PREDICTION_STATE_EMPTY) 
43                                          and (reg_EVENT_STATE [i] == EVENT_STATE_OK)
44                                          ));
45        if (_param->_have_port_depth)
46          {
47        PORT_WRITE(out_DEPTH_CURRENT [i], reg_UPT_TOP    [i]);
48        PORT_WRITE(out_DEPTH_MIN     [i], reg_UPT_BOTTOM [i]);
49        PORT_WRITE(out_DEPTH_MAX     [i], reg_UPT_TOP    [i]);
50          }
51        PORT_WRITE(out_DEPTH_FULL    [i], not reg_UPT_EMPTY [i] and (reg_UPT_TOP [i] == reg_UPT_BOTTOM [i]));
52
53//         bool empty = reg_UPT_EMPTY [i];
54//      PORT_WRITE(out_DEPTH_MAX     [i], ((empty)?reg_UPT_BOTTOM [i]:((reg_UPT_TOP [i]==0)?(_param->_size_upt_queue[i]-1):(reg_UPT_TOP [i]-1))));
55      }
56
57    // ===================================================================
58    // =====[ UPDATE ]====================================================
59    // ===================================================================
60
61    bool     retire_ras_from_ufpt [_param->_nb_context]; // event ufpt -> restore RAS, else update upt
62    bool     retire_ras_from_upt  [_param->_nb_context]; // event upt  -> restore RAS, else restore others structure
63//  bool     have_event           [_param->_nb_context];
64    bool     ufpt_update          [_param->_nb_context];
65    bool     upt_update           [_param->_nb_context];
66    Tdepth_t tab_ufpt_depth       [_param->_nb_context];
67    Tdepth_t tab_upt_depth        [_param->_nb_context];
68
69    for (uint32_t i=0; i<_param->_nb_context; i++)
70      {
71        event_state_t event_state = reg_EVENT_STATE [i];
72
73        retire_ras_from_ufpt [i] = ((event_state == EVENT_STATE_MISS_FLUSH_UFPT         ) or
74                                    (event_state == EVENT_STATE_MISS_FLUSH_UFPT_AND_UPT ) or
75                                    (event_state == EVENT_STATE_EVENT_FLUSH_UFPT        ) or
76                                    (event_state == EVENT_STATE_EVENT_FLUSH_UFPT_AND_UPT));
77        retire_ras_from_upt  [i] = ((event_state == EVENT_STATE_MISS_FLUSH_UPT) or
78                                    (event_state == EVENT_STATE_EVENT_FLUSH_UPT));
79
80//         have_event           [i] = (event_state == EVENT_STATE_EVENT_FLUSH_UPT);
81
82        ufpt_update          [i] = true;
83        upt_update           [i] = true;
84        tab_ufpt_depth       [i] = reg_UFPT_UPDATE [i];
85        tab_upt_depth        [i] = reg_UPT_UPDATE  [i];
86      }
87
88    for (uint32_t i=0; i<_param->_nb_inst_update; i++)
89      {
90        Tcontext_t          context     = (reg_UPDATE_PRIORITY+i)%_param->_nb_context;
91
92        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE [%d] (genMoore)",i);
93        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context         : %d",context);
94        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * event_state     : %s",toString(reg_EVENT_STATE [context]).c_str());
95
96        Tcontrol_t          val                  = false;
97        Tcontrol_t          val_without_ack      = false;
98        Tcontrol_t          miss_prediction      ;
99        Tcontrol_t          direction_good       ;
100        Tcontrol_t          prediction_ifetch    ;
101        Tcontrol_t          btb_val              ;
102        Taddress_t          btb_address_src      ;
103        Taddress_t          btb_address_dest     ;
104        Tbranch_condition_t btb_condition        ;
105        Tcontrol_t          dir_val              ;
106        Thistory_t          dir_history          ;
107        Tcontrol_t          ras_val              ;
108        Tcontrol_t          ras_flush            ;
109        Tcontrol_t          ras_push             ;
110        Taddress_t          ras_address          ;
111        Tptr_t              ras_index            ;
112
113        // Test if update fetch prediction table need update port
114        if (retire_ras_from_ufpt [context])
115          {
116            if (ufpt_update [context])
117              {
118                // Update Fetch Prediction Table
119                // An update of ufpt is to previous miss. Just restore Return Address Stack
120               
121                Tdepth_t            depth     = tab_ufpt_depth[context];
122                ufpt_state_t        state     = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state; 
123                Tbranch_condition_t condition = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition; 
124               
125                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
126                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
127                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
128                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
129               
130                val                   = (state == UPDATE_FETCH_PREDICTION_STATE_EVENT);
131//              val_without_ack       = not update_ras(condition);
132
133                miss_prediction       = 1;
134//              direction_good        = ;
135                prediction_ifetch     = 1;
136                btb_val               = 0; // don't update btb (is update by the event branch)
137//              btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
138//              btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
139//              btb_condition         = condition;
140                dir_val               = update_ras(condition);
141                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history;
142                // repop/ repush data -> don't corrupt ras
143                ras_val               = update_ras(condition); 
144                ras_flush             = 0;
145                ras_push              = push_ras(condition);
146                ras_address           = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._address_ras;
147                ras_index             = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._index_ras;
148               
149                internal_UPDATE_FROM_UFPT [i] = true;
150                internal_UPDATE_DEPTH     [i] = depth;
151                internal_UPDATE_RAS       [i] = false;
152
153                // Warning : don't update same entry
154                if (depth == reg_UFPT_BOTTOM[context])
155                  ufpt_update [context] = false;
156               
157                tab_ufpt_depth[context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
158              }
159          }
160        else
161          {
162            if (upt_update [context])
163              {
164                // Update Prediction Table
165               
166                Tdepth_t            depth     = tab_upt_depth[context];
167                upt_state_t         state     = reg_UPDATE_PREDICTION_TABLE [context][depth]._state; 
168                Tbranch_condition_t condition = reg_UPDATE_PREDICTION_TABLE [context][depth]._condition; 
169                Tcontrol_t          ifetch    = reg_UPDATE_PREDICTION_TABLE [context][depth]._ifetch_prediction;
170               
171                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
172                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
173                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
174                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
175             
176                Tcontrol_t          state_is_ok_ko           = ((state == UPDATE_PREDICTION_STATE_OK   ) or
177                                                                (state == UPDATE_PREDICTION_STATE_KO   ));
178//                 Tcontrol_t          state_is_event           = ((state == UPDATE_PREDICTION_STATE_KO   ) or
179//                                                                 (state == UPDATE_PREDICTION_STATE_EVENT)//  or
180//                                                                 ((have_event[context])?(state == UPDATE_PREDICTION_STATE_OK):false)
181//                                                                 );
182               
183//                 Tcontrol_t          state_is_event_update    = state_is_event and     need_update(condition);
184//                 Tcontrol_t          state_is_event_no_update = state_is_event and not need_update(condition);
185
186                if (retire_ras_from_upt [context])
187                  {
188//                 val                   = state_is_event_update;
189//                 val_without_ack       = state_is_event_no_update;
190                val                   = ((state == UPDATE_PREDICTION_STATE_KO   ) or
191                                         ((state == UPDATE_PREDICTION_STATE_EVENT) and need_update(condition)));
192                val_without_ack       = ((state == UPDATE_PREDICTION_STATE_EVENT) and not need_update(condition));
193                  }
194                else
195                  {
196                val                   = (state == UPDATE_PREDICTION_STATE_OK);
197                val_without_ack       = false;
198                  }                 
199
200                miss_prediction       = (state != UPDATE_PREDICTION_STATE_OK);
201                direction_good        = reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   ;
202                prediction_ifetch     = ifetch;
203                btb_val               = state_is_ok_ko and update_btb(condition);
204                btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
205                btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
206                btb_condition         = condition;
207                dir_val               = // state_is_ok_ko and
208                                        update_dir(condition); // if not ifetch, then static prediction
209                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history     ;
210                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
211                ras_flush             = (state == UPDATE_PREDICTION_STATE_KO); // miss prediction, RAS is corrupted
212                ras_push              = push_ras(condition);
213                // If corrupt, RAS must be flushed.
214                // Also, if instruction l.jal, l.jalr, push addr+2 (delay slot), else (no flush) restore RAS
215                ras_address           = (ras_flush)?(reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src+2):reg_UPDATE_PREDICTION_TABLE [context][depth]._address_ras;
216                ras_index             = reg_UPDATE_PREDICTION_TABLE [context][depth]._index_ras;
217
218                internal_UPDATE_FROM_UFPT [i] = false;
219                internal_UPDATE_DEPTH     [i] = depth;
220                internal_UPDATE_RAS       [i] = retire_ras_from_upt [context];
221
222                // Warning : don't update same entry
223                if (retire_ras_from_upt [context])
224                  {
225                    // Restore RAS.
226                    if ((depth == reg_UPT_BOTTOM[context]) or not (val or val_without_ack))
227                      upt_update [context] = false;
228                   
229                    tab_upt_depth[context] = (depth==0)?(_param->_size_upt_queue[context]-1):(depth-1);
230                  }
231                else
232                  {
233                    if ((depth == reg_UPT_TOP [context]) or not (val or val_without_ack))
234                      upt_update [context] = false;
235                   
236                    tab_upt_depth[context] = (depth+1)%_param->_size_upt_queue[context];
237                  }
238              }
239          }
240       
241        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val             : %d",val    );
242        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val_without_ack : %d",val_without_ack);
243        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_prediction : %d",miss_prediction);
244        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * direction_good  : %d",direction_good );
245        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * btb_val         : %d",btb_val);
246        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * dir_val         : %d",dir_val);
247        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * ras_val         : %d",ras_val);
248
249        internal_UPDATE_VAL             [i] = val;
250        internal_UPDATE_VAL_WITHOUT_ACK [i] = val_without_ack;
251        internal_UPDATE_CONTEXT_ID      [i] = context;
252
253        PORT_WRITE(out_UPDATE_VAL                   [i],internal_UPDATE_VAL [i]);
254        if (val)
255          {
256        if (_param->_have_port_context_id)
257        PORT_WRITE(out_UPDATE_CONTEXT_ID            [i],context              );
258        PORT_WRITE(out_UPDATE_MISS_PREDICTION       [i],miss_prediction      );
259        PORT_WRITE(out_UPDATE_DIRECTION_GOOD        [i],direction_good       );
260        PORT_WRITE(out_UPDATE_PREDICTION_IFETCH     [i],prediction_ifetch    );
261        PORT_WRITE(out_UPDATE_BTB_VAL               [i],btb_val              );
262        PORT_WRITE(out_UPDATE_BTB_ADDRESS_SRC       [i],btb_address_src      );
263        PORT_WRITE(out_UPDATE_BTB_ADDRESS_DEST      [i],btb_address_dest     );
264        PORT_WRITE(out_UPDATE_BTB_CONDITION         [i],btb_condition        );
265        PORT_WRITE(out_UPDATE_DIR_VAL               [i],dir_val              );
266        if (_param->_have_port_history)
267        PORT_WRITE(out_UPDATE_DIR_HISTORY           [i],dir_history          );
268        PORT_WRITE(out_UPDATE_RAS_VAL               [i],ras_val              );
269        PORT_WRITE(out_UPDATE_RAS_FLUSH             [i],ras_flush            );
270        PORT_WRITE(out_UPDATE_RAS_PUSH              [i],ras_push             );
271        PORT_WRITE(out_UPDATE_RAS_ADDRESS           [i],ras_address          );
272        PORT_WRITE(out_UPDATE_RAS_INDEX             [i],ras_index            );
273          }
274      }
275   
276    // ===================================================================
277    // =====[ BRANCH_EVENT ]==============================================
278    // ===================================================================
279    for (uint32_t i=0; i<_param->_nb_context; i++)
280      {
281        Tcontrol_t val = (reg_EVENT_STATE [i] == EVENT_STATE_UPDATE_CONTEXT);
282
283        PORT_WRITE(out_BRANCH_EVENT_VAL              [i],val);
284        if (_param->_have_port_depth)
285        PORT_WRITE(out_BRANCH_EVENT_DEPTH            [i],reg_EVENT_DEPTH            [i]);
286        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_SRC      [i],reg_EVENT_ADDRESS_SRC      [i]);
287        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST_VAL [i],reg_EVENT_ADDRESS_DEST_VAL [i]);
288        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST     [i],reg_EVENT_ADDRESS_DEST     [i]);
289        PORT_WRITE(out_BRANCH_EVENT_CAN_CONTINUE     [i],reg_EVENT_CAN_CONTINUE     [i]);
290       
291        internal_BRANCH_EVENT_VAL [i] = val;
292      }
293      }
294    else
295      {
296        for (uint32_t i=0; i<_param->_nb_inst_update; i++)
297          {
298            internal_UPDATE_VAL             [i] = 0;
299            internal_UPDATE_VAL_WITHOUT_ACK [i] = 0;
300          }
301        for (uint32_t i=0; i<_param->_nb_context; i++)
302          {
303            internal_BRANCH_EVENT_VAL       [i] = 0;
304          }
305      }
306
307
308    log_end(Update_Prediction_Table,FUNCTION);
309  };
310
311}; // end namespace update_prediction_table
312}; // end namespace prediction_unit
313}; // end namespace front_end
314}; // end namespace multi_front_end
315}; // end namespace core
316
317}; // end namespace behavioural
318}; // end namespace morpheo             
319#endif
Note: See TracBrowser for help on using the repository browser.