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

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

1) Add soc test
2) fix bug (Pc management, Decod and execute, Update prediction ...)
File size: 14.6 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        if (_param->_have_port_depth)
44          {
45        PORT_WRITE(out_DEPTH_CURRENT [i], reg_UPT_TOP    [i]);
46        PORT_WRITE(out_DEPTH_MIN     [i], reg_UPT_BOTTOM [i]);
47        PORT_WRITE(out_DEPTH_MAX     [i], reg_UPT_TOP    [i]);
48          }
49        PORT_WRITE(out_DEPTH_FULL    [i], not reg_UPT_EMPTY [i] and (reg_UPT_TOP [i] == reg_UPT_BOTTOM [i]));
50
51//         bool empty = reg_UPT_EMPTY [i];
52//      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))));
53      }
54
55    // ===================================================================
56    // =====[ UPDATE ]====================================================
57    // ===================================================================
58
59    bool     retire_ras_from_ufpt [_param->_nb_context]; // event ufpt -> restore RAS, else update upt
60    bool     retire_ras_from_upt  [_param->_nb_context]; // event upt  -> restore RAS, else restore others structure
61    bool     ufpt_update          [_param->_nb_context];
62    bool     upt_update           [_param->_nb_context];
63    Tdepth_t tab_ufpt_depth       [_param->_nb_context];
64    Tdepth_t tab_upt_depth        [_param->_nb_context];
65
66    for (uint32_t i=0; i<_param->_nb_context; i++)
67      {
68        event_state_t event_state = reg_EVENT_STATE [i];
69
70        retire_ras_from_ufpt [i] = ((event_state == EVENT_STATE_FLUSH_UFPT            ) or
71                                    (event_state == EVENT_STATE_FLUSH_UFPT_AND_UPT));
72        retire_ras_from_upt  [i] = (event_state == EVENT_STATE_FLUSH_UPT);
73
74        ufpt_update          [i] = true;
75        upt_update           [i] = true;
76        tab_ufpt_depth       [i] = reg_UFPT_UPDATE [i];
77        tab_upt_depth        [i] = reg_UPT_UPDATE  [i];
78      }
79
80    for (uint32_t i=0; i<_param->_nb_inst_update; i++)
81      {
82        Tcontext_t          context     = (reg_UPDATE_PRIORITY+i)%_param->_nb_context;
83
84        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE [%d] (genMoore)",i);
85        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context         : %d",context);
86        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * event_state     : %s",toString(reg_EVENT_STATE [context]).c_str());
87
88        Tcontrol_t          val                  = false;
89        Tcontrol_t          val_without_ack      = false;
90        Tcontrol_t          miss_prediction      ;
91        Tcontrol_t          direction_good       ;
92        Tcontrol_t          btb_val              ;
93        Taddress_t          btb_address_src      ;
94        Taddress_t          btb_address_dest     ;
95        Tbranch_condition_t btb_condition        ;
96        Tcontrol_t          dir_val              ;
97        Thistory_t          dir_history          ;
98        Tcontrol_t          ras_val              ;
99        Tcontrol_t          ras_flush            ;
100        Tcontrol_t          ras_push             ;
101        Taddress_t          ras_address          ;
102        Tptr_t              ras_index            ;
103        Tcontrol_t          ras_prediction_ifetch;
104
105        // Test if update fetch prediction table need update port
106        if (retire_ras_from_ufpt [context])
107          {
108            if (ufpt_update [context])
109              {
110                // Update Fetch Prediction Table
111                // An update of ufpt is to previous miss. Just restore Return Address Stack
112               
113                Tdepth_t            depth     = tab_ufpt_depth[context];
114                ufpt_state_t        state     = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state; 
115                Tbranch_condition_t condition = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition; 
116               
117                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
118                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
119                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
120                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
121               
122                val                   = (state == UPDATE_FETCH_PREDICTION_STATE_EVENT);
123//              val_without_ack       = not update_ras(condition);
124
125                miss_prediction       = 1;
126//              direction_good        = ;
127                btb_val               = 0; // don't update btb (is update by the event branch)
128//              btb_address_src       = ;
129//              btb_address_dest      = ;
130//              btb_condition         = ;
131                dir_val               = 0; // don't update btb (is update by the event branch (if conditionnal branch))
132//              dir_history           = ;
133                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
134                ras_flush             = 0;
135                ras_push              = push_ras(condition);
136                ras_address           = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._address_ras;
137                ras_index             = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._index_ras;
138                ras_prediction_ifetch = 1;
139               
140                internal_UPDATE_FROM_UFPT [i] = true;
141                internal_UPDATE_DEPTH     [i] = depth;
142                internal_UPDATE_RAS       [i] = false;
143
144                // Warning : don't update same entry
145                if (depth == reg_UFPT_BOTTOM[context])
146                  ufpt_update [context] = false;
147               
148                tab_ufpt_depth[context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
149              }
150          }
151        else
152          {
153            if (upt_update [context])
154              {
155                // Update Prediction Table
156               
157                Tdepth_t            depth     = tab_upt_depth[context];
158                upt_state_t         state     = reg_UPDATE_PREDICTION_TABLE [context][depth]._state; 
159                Tbranch_condition_t condition = reg_UPDATE_PREDICTION_TABLE [context][depth]._condition; 
160                Tcontrol_t          ifetch    = reg_UPDATE_PREDICTION_TABLE [context][depth]._ifetch_prediction;
161               
162                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
163                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
164                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
165                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
166             
167                Tcontrol_t          state_is_ok_ko           = ((state == UPDATE_PREDICTION_STATE_OK   ) or
168                                                                (state == UPDATE_PREDICTION_STATE_KO   ));
169                Tcontrol_t          state_is_event           = ((state == UPDATE_PREDICTION_STATE_KO   ) or
170                                                                (state == UPDATE_PREDICTION_STATE_EVENT));
171                Tcontrol_t          state_is_event_update    = state_is_event and     need_update(condition);
172                Tcontrol_t          state_is_event_no_update = state_is_event and not need_update(condition);
173
174                if (retire_ras_from_upt [context])
175                  {
176                val                   = state_is_event_update;
177                val_without_ack       = state_is_event_no_update;
178                  }
179                else
180                  {
181                val                   = (state == UPDATE_PREDICTION_STATE_OK);
182                val_without_ack       = false;
183                  }                 
184
185                miss_prediction       = (state != UPDATE_PREDICTION_STATE_OK);
186                direction_good        = reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   ;
187                btb_val               = state_is_ok_ko and update_btb(condition);
188                btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
189                btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
190                btb_condition         = condition;
191                dir_val               = state_is_ok_ko and update_dir(condition) and ifetch; // if not ifetch, then static prediction
192                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history     ;
193                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
194                ras_flush             = (state == UPDATE_PREDICTION_STATE_KO); // miss prediction, RAS is corrupted
195                ras_push              = push_ras(condition);
196                ras_address           = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_ras;
197                ras_index             = reg_UPDATE_PREDICTION_TABLE [context][depth]._index_ras;
198                ras_prediction_ifetch = ifetch;
199
200                internal_UPDATE_FROM_UFPT [i] = false;
201                internal_UPDATE_DEPTH     [i] = depth;
202                internal_UPDATE_RAS       [i] = retire_ras_from_upt [context];
203
204                // Warning : don't update same entry
205                if (retire_ras_from_upt [context])
206                  {
207                    // Restore RAS.
208                    if ((depth == reg_UPT_BOTTOM[context]) or not (val or val_without_ack))
209                      upt_update [context] = false;
210                   
211                    tab_upt_depth[context] = (depth==0)?(_param->_size_upt_queue[context]-1):(depth-1);
212                  }
213                else
214                  {
215                    if ((depth == reg_UPT_TOP [context]) or not (val or val_without_ack))
216                      upt_update [context] = false;
217                   
218                    tab_upt_depth[context] = (depth+1)%_param->_size_upt_queue[context];
219                  }
220              }
221          }
222       
223        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val             : %d",val    );
224        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val_without_ack : %d",val_without_ack);
225        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_prediction : %d",miss_prediction);
226        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * direction_good  : %d",direction_good );
227        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * btb_val         : %d",btb_val);
228        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * dir_val         : %d",dir_val);
229        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * ras_val         : %d",ras_val);
230
231        internal_UPDATE_VAL             [i] = val;
232        internal_UPDATE_VAL_WITHOUT_ACK [i] = val_without_ack;
233        internal_UPDATE_CONTEXT_ID      [i] = context;
234
235        PORT_WRITE(out_UPDATE_VAL                   [i],internal_UPDATE_VAL [i]);
236        if (val)
237          {
238        if (_param->_have_port_context_id)
239        PORT_WRITE(out_UPDATE_CONTEXT_ID            [i],context              );
240        PORT_WRITE(out_UPDATE_MISS_PREDICTION       [i],miss_prediction      );
241        PORT_WRITE(out_UPDATE_DIRECTION_GOOD        [i],direction_good       );
242        PORT_WRITE(out_UPDATE_BTB_VAL               [i],btb_val              );
243        PORT_WRITE(out_UPDATE_BTB_ADDRESS_SRC       [i],btb_address_src      );
244        PORT_WRITE(out_UPDATE_BTB_ADDRESS_DEST      [i],btb_address_dest     );
245        PORT_WRITE(out_UPDATE_BTB_CONDITION         [i],btb_condition        );
246        PORT_WRITE(out_UPDATE_DIR_VAL               [i],dir_val              );
247        if (_param->_have_port_history)
248        PORT_WRITE(out_UPDATE_DIR_HISTORY           [i],dir_history          );
249        PORT_WRITE(out_UPDATE_RAS_VAL               [i],ras_val              );
250        PORT_WRITE(out_UPDATE_RAS_FLUSH             [i],ras_flush            );
251        PORT_WRITE(out_UPDATE_RAS_PUSH              [i],ras_push             );
252        PORT_WRITE(out_UPDATE_RAS_ADDRESS           [i],ras_address          );
253        PORT_WRITE(out_UPDATE_RAS_INDEX             [i],ras_index            );
254        PORT_WRITE(out_UPDATE_RAS_PREDICTION_IFETCH [i],ras_prediction_ifetch);
255          }
256      }
257   
258    // ===================================================================
259    // =====[ BRANCH_EVENT ]==============================================
260    // ===================================================================
261    for (uint32_t i=0; i<_param->_nb_context; i++)
262      {
263        Tcontrol_t val = (reg_EVENT_STATE [i] == EVENT_STATE_UPDATE_CONTEXT);
264
265        PORT_WRITE(out_BRANCH_EVENT_VAL              [i],val);
266        if (_param->_have_port_depth)
267        PORT_WRITE(out_BRANCH_EVENT_DEPTH            [i],reg_EVENT_DEPTH            [i]);
268        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_SRC      [i],reg_EVENT_ADDRESS_SRC      [i]);
269        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST_VAL [i],reg_EVENT_ADDRESS_DEST_VAL [i]);
270        PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST     [i],reg_EVENT_ADDRESS_DEST     [i]);
271
272        internal_BRANCH_EVENT_VAL [i] = val;
273      }
274      }
275
276    log_end(Update_Prediction_Table,FUNCTION);
277  };
278
279}; // end namespace update_prediction_table
280}; // end namespace prediction_unit
281}; // end namespace front_end
282}; // end namespace multi_front_end
283}; // end namespace core
284
285}; // end namespace behavioural
286}; // end namespace morpheo             
287#endif
Note: See TracBrowser for help on using the repository browser.