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

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

1) Bug fix : Load Miss Speculation (in Commit_unit, Update Prediction Table and Context State)
2) Change address, in rob write address_next.
3) Move Meta_Predictor in save directory
File size: 15.3 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                  }
190                else
191                  {
192                val                   = (state == UPDATE_PREDICTION_STATE_OK);
193                val_without_ack       = false;
194                  }                 
195
196                miss_prediction       = (state != UPDATE_PREDICTION_STATE_OK);
197                direction_good        = reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   ;
198                btb_val               = state_is_ok_ko and update_btb(condition);
199                btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
200                btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
201                btb_condition         = condition;
202                dir_val               = state_is_ok_ko and update_dir(condition) and ifetch; // if not ifetch, then static prediction
203                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history     ;
204                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
205                ras_flush             = (state == UPDATE_PREDICTION_STATE_KO); // miss prediction, RAS is corrupted
206                ras_push              = push_ras(condition);
207                ras_address           = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_ras;
208                ras_index             = reg_UPDATE_PREDICTION_TABLE [context][depth]._index_ras;
209                ras_prediction_ifetch = ifetch;
210
211                internal_UPDATE_FROM_UFPT [i] = false;
212                internal_UPDATE_DEPTH     [i] = depth;
213                internal_UPDATE_RAS       [i] = retire_ras_from_upt [context];
214
215                // Warning : don't update same entry
216                if (retire_ras_from_upt [context])
217                  {
218                    // Restore RAS.
219                    if ((depth == reg_UPT_BOTTOM[context]) or not (val or val_without_ack))
220                      upt_update [context] = false;
221                   
222                    tab_upt_depth[context] = (depth==0)?(_param->_size_upt_queue[context]-1):(depth-1);
223                  }
224                else
225                  {
226                    if ((depth == reg_UPT_TOP [context]) or not (val or val_without_ack))
227                      upt_update [context] = false;
228                   
229                    tab_upt_depth[context] = (depth+1)%_param->_size_upt_queue[context];
230                  }
231              }
232          }
233       
234        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val             : %d",val    );
235        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val_without_ack : %d",val_without_ack);
236        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_prediction : %d",miss_prediction);
237        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * direction_good  : %d",direction_good );
238        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * btb_val         : %d",btb_val);
239        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * dir_val         : %d",dir_val);
240        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * ras_val         : %d",ras_val);
241
242        internal_UPDATE_VAL             [i] = val;
243        internal_UPDATE_VAL_WITHOUT_ACK [i] = val_without_ack;
244        internal_UPDATE_CONTEXT_ID      [i] = context;
245
246        PORT_WRITE(out_UPDATE_VAL                   [i],internal_UPDATE_VAL [i]);
247        if (val)
248          {
249        if (_param->_have_port_context_id)
250        PORT_WRITE(out_UPDATE_CONTEXT_ID            [i],context              );
251        PORT_WRITE(out_UPDATE_MISS_PREDICTION       [i],miss_prediction      );
252        PORT_WRITE(out_UPDATE_DIRECTION_GOOD        [i],direction_good       );
253        PORT_WRITE(out_UPDATE_BTB_VAL               [i],btb_val              );
254        PORT_WRITE(out_UPDATE_BTB_ADDRESS_SRC       [i],btb_address_src      );
255        PORT_WRITE(out_UPDATE_BTB_ADDRESS_DEST      [i],btb_address_dest     );
256        PORT_WRITE(out_UPDATE_BTB_CONDITION         [i],btb_condition        );
257        PORT_WRITE(out_UPDATE_DIR_VAL               [i],dir_val              );
258        if (_param->_have_port_history)
259        PORT_WRITE(out_UPDATE_DIR_HISTORY           [i],dir_history          );
260        PORT_WRITE(out_UPDATE_RAS_VAL               [i],ras_val              );
261        PORT_WRITE(out_UPDATE_RAS_FLUSH             [i],ras_flush            );
262        PORT_WRITE(out_UPDATE_RAS_PUSH              [i],ras_push             );
263        PORT_WRITE(out_UPDATE_RAS_ADDRESS           [i],ras_address          );
264        PORT_WRITE(out_UPDATE_RAS_INDEX             [i],ras_index            );
265        PORT_WRITE(out_UPDATE_RAS_PREDICTION_IFETCH [i],ras_prediction_ifetch);
266          }
267      }
268   
269    // ===================================================================
270    // =====[ BRANCH_EVENT ]==============================================
271    // ===================================================================
272    for (uint32_t i=0; i<_param->_nb_context; i++)
273      {
274        Tcontrol_t val = (reg_EVENT_STATE [i] == EVENT_STATE_UPDATE_CONTEXT);
275
276        PORT_WRITE(out_BRANCH_EVENT_VAL              [i],val);
277        if (_param->_have_port_depth)
278        PORT_WRITE(out_BRANCH_EVENT_DEPTH            [i],reg_EVENT_DEPTH            [i]);
279        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_SRC      [i],reg_EVENT_ADDRESS_SRC      [i]);
280        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST_VAL [i],reg_EVENT_ADDRESS_DEST_VAL [i]);
281        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST     [i],reg_EVENT_ADDRESS_DEST     [i]);
282
283        internal_BRANCH_EVENT_VAL [i] = val;
284      }
285      }
286
287    log_end(Update_Prediction_Table,FUNCTION);
288  };
289
290}; // end namespace update_prediction_table
291}; // end namespace prediction_unit
292}; // end namespace front_end
293}; // end namespace multi_front_end
294}; // end namespace core
295
296}; // end namespace behavioural
297}; // end namespace morpheo             
298#endif
Note: See TracBrowser for help on using the repository browser.