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

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

1) Fix test in Direction_Glue for Conditionnal Branch
2) Fix Instruction Address Compute
File size: 15.9 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          btb_val              ;
101        Taddress_t          btb_address_src      ;
102        Taddress_t          btb_address_dest     ;
103        Tbranch_condition_t btb_condition        ;
104        Tcontrol_t          dir_val              ;
105        Thistory_t          dir_history          ;
106        Tcontrol_t          ras_val              ;
107        Tcontrol_t          ras_flush            ;
108        Tcontrol_t          ras_push             ;
109        Taddress_t          ras_address          ;
110        Tptr_t              ras_index            ;
111        Tcontrol_t          ras_prediction_ifetch;
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                btb_val               = 0; // don't update btb (is update by the event branch)
136//              btb_address_src       = ;
137//              btb_address_dest      = ;
138//              btb_condition         = ;
139                dir_val               = 0; // don't update btb (is update by the event branch (if conditionnal branch))
140//              dir_history           = ;
141                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
142                ras_flush             = 0;
143                ras_push              = push_ras(condition);
144                ras_address           = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._address_ras;
145                ras_index             = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._index_ras;
146                ras_prediction_ifetch = 1;
147               
148                internal_UPDATE_FROM_UFPT [i] = true;
149                internal_UPDATE_DEPTH     [i] = depth;
150                internal_UPDATE_RAS       [i] = false;
151
152                // Warning : don't update same entry
153                if (depth == reg_UFPT_BOTTOM[context])
154                  ufpt_update [context] = false;
155               
156                tab_ufpt_depth[context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
157              }
158          }
159        else
160          {
161            if (upt_update [context])
162              {
163                // Update Prediction Table
164               
165                Tdepth_t            depth     = tab_upt_depth[context];
166                upt_state_t         state     = reg_UPDATE_PREDICTION_TABLE [context][depth]._state; 
167                Tbranch_condition_t condition = reg_UPDATE_PREDICTION_TABLE [context][depth]._condition; 
168                Tcontrol_t          ifetch    = reg_UPDATE_PREDICTION_TABLE [context][depth]._ifetch_prediction;
169               
170                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
171                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
172                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
173                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
174             
175                Tcontrol_t          state_is_ok_ko           = ((state == UPDATE_PREDICTION_STATE_OK   ) or
176                                                                (state == UPDATE_PREDICTION_STATE_KO   ));
177//                 Tcontrol_t          state_is_event           = ((state == UPDATE_PREDICTION_STATE_KO   ) or
178//                                                                 (state == UPDATE_PREDICTION_STATE_EVENT)//  or
179//                                                                 ((have_event[context])?(state == UPDATE_PREDICTION_STATE_OK):false)
180//                                                                 );
181               
182//                 Tcontrol_t          state_is_event_update    = state_is_event and     need_update(condition);
183//                 Tcontrol_t          state_is_event_no_update = state_is_event and not need_update(condition);
184
185                if (retire_ras_from_upt [context])
186                  {
187//                 val                   = state_is_event_update;
188//                 val_without_ack       = state_is_event_no_update;
189                val                   = ((state == UPDATE_PREDICTION_STATE_KO   ) or
190                                         ((state == UPDATE_PREDICTION_STATE_EVENT) and need_update(condition)));
191                val_without_ack       = ((state == UPDATE_PREDICTION_STATE_EVENT) and not need_update(condition));
192                  }
193                else
194                  {
195                val                   = (state == UPDATE_PREDICTION_STATE_OK);
196                val_without_ack       = false;
197                  }                 
198
199                miss_prediction       = (state != UPDATE_PREDICTION_STATE_OK);
200                direction_good        = reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   ;
201                btb_val               = state_is_ok_ko and update_btb(condition);
202                btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
203                btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
204                btb_condition         = condition;
205                dir_val               = state_is_ok_ko and update_dir(condition) and ifetch; // if not ifetch, then static prediction
206                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history     ;
207                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
208                ras_flush             = (state == UPDATE_PREDICTION_STATE_KO); // miss prediction, RAS is corrupted
209                ras_push              = push_ras(condition);
210                // If corrupt, RAS must be flushed.
211                // Also, if instruction l.jal, l.jalr, push addr+2 (delay slot), else (no flush) restore RAS
212                ras_address           = (ras_flush)?(reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src+2):reg_UPDATE_PREDICTION_TABLE [context][depth]._address_ras;
213                ras_index             = reg_UPDATE_PREDICTION_TABLE [context][depth]._index_ras;
214                ras_prediction_ifetch = ifetch;
215
216                internal_UPDATE_FROM_UFPT [i] = false;
217                internal_UPDATE_DEPTH     [i] = depth;
218                internal_UPDATE_RAS       [i] = retire_ras_from_upt [context];
219
220                // Warning : don't update same entry
221                if (retire_ras_from_upt [context])
222                  {
223                    // Restore RAS.
224                    if ((depth == reg_UPT_BOTTOM[context]) or not (val or val_without_ack))
225                      upt_update [context] = false;
226                   
227                    tab_upt_depth[context] = (depth==0)?(_param->_size_upt_queue[context]-1):(depth-1);
228                  }
229                else
230                  {
231                    if ((depth == reg_UPT_TOP [context]) or not (val or val_without_ack))
232                      upt_update [context] = false;
233                   
234                    tab_upt_depth[context] = (depth+1)%_param->_size_upt_queue[context];
235                  }
236              }
237          }
238       
239        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val             : %d",val    );
240        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val_without_ack : %d",val_without_ack);
241        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_prediction : %d",miss_prediction);
242        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * direction_good  : %d",direction_good );
243        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * btb_val         : %d",btb_val);
244        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * dir_val         : %d",dir_val);
245        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * ras_val         : %d",ras_val);
246
247        internal_UPDATE_VAL             [i] = val;
248        internal_UPDATE_VAL_WITHOUT_ACK [i] = val_without_ack;
249        internal_UPDATE_CONTEXT_ID      [i] = context;
250
251        PORT_WRITE(out_UPDATE_VAL                   [i],internal_UPDATE_VAL [i]);
252        if (val)
253          {
254        if (_param->_have_port_context_id)
255        PORT_WRITE(out_UPDATE_CONTEXT_ID            [i],context              );
256        PORT_WRITE(out_UPDATE_MISS_PREDICTION       [i],miss_prediction      );
257        PORT_WRITE(out_UPDATE_DIRECTION_GOOD        [i],direction_good       );
258        PORT_WRITE(out_UPDATE_BTB_VAL               [i],btb_val              );
259        PORT_WRITE(out_UPDATE_BTB_ADDRESS_SRC       [i],btb_address_src      );
260        PORT_WRITE(out_UPDATE_BTB_ADDRESS_DEST      [i],btb_address_dest     );
261        PORT_WRITE(out_UPDATE_BTB_CONDITION         [i],btb_condition        );
262        PORT_WRITE(out_UPDATE_DIR_VAL               [i],dir_val              );
263        if (_param->_have_port_history)
264        PORT_WRITE(out_UPDATE_DIR_HISTORY           [i],dir_history          );
265        PORT_WRITE(out_UPDATE_RAS_VAL               [i],ras_val              );
266        PORT_WRITE(out_UPDATE_RAS_FLUSH             [i],ras_flush            );
267        PORT_WRITE(out_UPDATE_RAS_PUSH              [i],ras_push             );
268        PORT_WRITE(out_UPDATE_RAS_ADDRESS           [i],ras_address          );
269        PORT_WRITE(out_UPDATE_RAS_INDEX             [i],ras_index            );
270        PORT_WRITE(out_UPDATE_RAS_PREDICTION_IFETCH [i],ras_prediction_ifetch);
271          }
272      }
273   
274    // ===================================================================
275    // =====[ BRANCH_EVENT ]==============================================
276    // ===================================================================
277    for (uint32_t i=0; i<_param->_nb_context; i++)
278      {
279        Tcontrol_t val = (reg_EVENT_STATE [i] == EVENT_STATE_UPDATE_CONTEXT);
280
281        PORT_WRITE(out_BRANCH_EVENT_VAL              [i],val);
282        if (_param->_have_port_depth)
283        PORT_WRITE(out_BRANCH_EVENT_DEPTH            [i],reg_EVENT_DEPTH            [i]);
284        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_SRC      [i],reg_EVENT_ADDRESS_SRC      [i]);
285        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST_VAL [i],reg_EVENT_ADDRESS_DEST_VAL [i]);
286        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST     [i],reg_EVENT_ADDRESS_DEST     [i]);
287
288        internal_BRANCH_EVENT_VAL [i] = val;
289      }
290      }
291
292    log_end(Update_Prediction_Table,FUNCTION);
293  };
294
295}; // end namespace update_prediction_table
296}; // end namespace prediction_unit
297}; // end namespace front_end
298}; // end namespace multi_front_end
299}; // end namespace core
300
301}; // end namespace behavioural
302}; // end namespace morpheo             
303#endif
Note: See TracBrowser for help on using the repository browser.