source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_transition.cpp @ 124

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

1) Fix performance
2) add auto generation to SPECINT2000
3) add reset in genMoore and genMealy
  • Property svn:keywords set to Id
File size: 16.5 KB
RevLine 
[78]1#ifdef SYSTEMC
2/*
3 * $Id: Stat_List_unit_transition.cpp 123 2009-06-08 20:43:30Z rosiere $
4 *
5 * [ Description ]
6 *
7 */
8
9#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Stat_List_unit.h"
10
11namespace morpheo                    {
12namespace behavioural {
13namespace core {
14namespace multi_ooo_engine {
15namespace ooo_engine {
16namespace rename_unit {
17namespace register_translation_unit {
18namespace stat_list_unit {
19
20
21#undef  FUNCTION
22#define FUNCTION "Stat_List_unit::transition"
23  void Stat_List_unit::transition (void)
24  {
[88]25    log_begin(Stat_List_unit,FUNCTION);
26    log_function(Stat_List_unit,FUNCTION,_name.c_str());
[78]27
28    if (PORT_READ(in_NRESET) == 0)
29      {
30        uint32_t gpr = 0;
31        uint32_t spr = 0;
32       
33        for (uint32_t i=0; i<_param->_nb_bank; i++)
34          {
35            for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
36              gpr_stat_list [i][j].reset((gpr++)<_param->_nb_gpr_use_init);
37            for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
38              spr_stat_list [i][j].reset((spr++)<_param->_nb_spr_use_init);
39          }
[112]40        reg_GPR_PTR_FREE = 0;
41        reg_SPR_PTR_FREE = 0;
[78]42      }
43    else
44      {
[123]45#ifdef DEBUG_TEST
46        {
47          uint32_t free_list_nb_gpr_free     = PORT_READ(in_INFO_NB_GPR_FREE);
48          uint32_t free_list_nb_spr_free     = PORT_READ(in_INFO_NB_SPR_FREE);
49          uint32_t stat_list_nb_gpr_free     = 0;
50          uint32_t stat_list_nb_spr_free     = 0;
51          uint32_t stat_list_nb_gpr_can_free = 0;
52          uint32_t stat_list_nb_spr_can_free = 0;
53          uint32_t stat_list_nb_gpr_link     = 0;
54          uint32_t stat_list_nb_spr_link     = 0;
55          uint32_t stat_list_nb_gpr_use      = 0;
56          uint32_t stat_list_nb_spr_use      = 0;
57
58          for (uint32_t i=0; i<_param->_nb_bank; i++)
59            {
60              for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
61                {
62                  if (gpr_stat_list [i][j]._is_free)
63                    stat_list_nb_gpr_free ++;
64                  if (gpr_stat_list [i][j]._is_link)
65                    stat_list_nb_gpr_link ++;
66                  if (gpr_stat_list [i][j]._is_use)
67                    stat_list_nb_gpr_use ++;
68                  if (gpr_stat_list [i][j].can_free())
69                    stat_list_nb_gpr_can_free ++;
70                }
71              for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
72                {
73                  if (spr_stat_list [i][j]._is_free)
74                    stat_list_nb_spr_free ++;
75                  if (spr_stat_list [i][j]._is_link)
76                    stat_list_nb_spr_link ++;
77                  if (spr_stat_list [i][j]._is_use)
78                    stat_list_nb_spr_use ++;
79                  if (spr_stat_list [i][j].can_free())
80                    stat_list_nb_spr_can_free ++;
81                }
82            }
83
84          uint32_t  nb_gpr_free = stat_list_nb_gpr_free+stat_list_nb_gpr_can_free;
85          uint32_t  nb_spr_free = stat_list_nb_spr_free+stat_list_nb_spr_can_free;
86          uint32_t _nb_gpr_free = (_param->_nb_general_register - _param->_nb_gpr_use_init); 
87          uint32_t _nb_spr_free = (_param->_nb_special_register - _param->_nb_spr_use_init); 
88          uint32_t  nb_gpr_link = stat_list_nb_gpr_link - _param->_nb_gpr_use_init;
89          uint32_t  nb_spr_link = stat_list_nb_spr_link - _param->_nb_spr_use_init;
90          uint32_t  nb_gpr_use  = stat_list_nb_gpr_use - _param->_nb_gpr_use_init;
91          uint32_t  nb_spr_use  = stat_list_nb_spr_use - _param->_nb_spr_use_init;
92
93          log_printf(TRACE,Stat_List_unit,FUNCTION,"  * nb_gpr_free : stat_list %d - free_list %d - free %d, link %d (%d), use %d (%d)",stat_list_nb_gpr_free,free_list_nb_gpr_free,nb_gpr_free,nb_gpr_link,stat_list_nb_gpr_link,nb_gpr_use,stat_list_nb_gpr_use);
94          log_printf(TRACE,Stat_List_unit,FUNCTION,"  * nb_spr_free : stat_list %d - free_list %d - free %d, link %d (%d), use %d (%d)",stat_list_nb_spr_free,free_list_nb_spr_free,nb_spr_free,nb_spr_link,stat_list_nb_spr_link,nb_spr_use,stat_list_nb_spr_use);
95
96          if (free_list_nb_gpr_free != stat_list_nb_gpr_free)
97            throw ERRORMORPHEO(FUNCTION,toString(_("Number of free general register is not valid. %d in Stat_List and %d in Free_list.\n"),stat_list_nb_gpr_free,free_list_nb_gpr_free));
98          if (free_list_nb_spr_free != stat_list_nb_spr_free)
99            throw ERRORMORPHEO(FUNCTION,toString(_("Number of free general register is not valid. %d in Stat_List and %d in Free_list.\n"),stat_list_nb_spr_free,free_list_nb_spr_free));
100
101          if (PORT_READ(in_INFO_ROB_EMPTY) and (nb_gpr_free != _nb_gpr_free))
102            throw ERRORMORPHEO(FUNCTION,toString(_("Rob is empty but they have %d general registers free or can_free and must be %d registers."),nb_gpr_free,_nb_gpr_free));
103
104          if (PORT_READ(in_INFO_ROB_EMPTY) and (nb_spr_free != _nb_spr_free))
105            throw ERRORMORPHEO(FUNCTION,toString(_("Rob is empty but they have %d special registers free or can_free and must be %d registers."),nb_spr_free,_nb_spr_free));
106        }
107#endif
108
[78]109        // =====================================================
110        // =====[ INSERT ]======================================
111        // =====================================================
112        for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
113          if (PORT_READ(in_INSERT_VAL[i]) and internal_INSERT_ACK[i])
114            {
[106]115              log_printf(TRACE,Stat_List_unit,FUNCTION,"  * INSERT [%d]",i);
116             
[112]117//            if (PORT_READ(in_INSERT_READ_RA [i]))
118//              {
119//                Tgeneral_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RA_PHY [i]);
[106]120
[112]121//                   log_printf(TRACE,Stat_List_unit,FUNCTION,"    * READ_RA  - num_reg     : %d",num_reg);
[106]122
[112]123//                uint32_t bank = num_reg >> _param->_shift_gpr;
124//                uint32_t reg  = num_reg  & _param->_mask_gpr ;
125//                gpr_stat_list [bank][reg].insert_read();
126//              }
[78]127
[112]128//            if (PORT_READ(in_INSERT_READ_RB [i]))
129//              {
130//                Tgeneral_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RB_PHY [i]);
[106]131
[112]132//                   log_printf(TRACE,Stat_List_unit,FUNCTION,"    * READ_RB  - num_reg     : %d",num_reg);
[106]133
[112]134//                uint32_t bank = num_reg >> _param->_shift_gpr;
135//                uint32_t reg  = num_reg  & _param->_mask_gpr ;
136//                gpr_stat_list [bank][reg].insert_read();
137//              }
[78]138
[112]139//            if (PORT_READ(in_INSERT_READ_RC [i]))
140//              {
141//                Tgeneral_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RC_PHY [i]);
[106]142
[112]143//                   log_printf(TRACE,Stat_List_unit,FUNCTION,"    * READ_RC  - num_reg     : %d",num_reg);
[106]144
[112]145//                uint32_t bank = num_reg >> _param->_shift_spr;
146//                uint32_t reg  = num_reg  & _param->_mask_spr ;
147//                spr_stat_list [bank][reg].insert_read();
148//              }
[78]149
150              if (PORT_READ(in_INSERT_WRITE_RD [i]))
151                {
[117]152                  {
153                    Tgeneral_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RD_PHY_OLD [i]);
154                   
155                    log_printf(TRACE,Stat_List_unit,FUNCTION,"    * WRITE_RD - num_reg old : %d",num_reg);
156                   
157                    uint32_t bank = num_reg >> _param->_shift_gpr;
158                    uint32_t reg  = num_reg  & _param->_mask_gpr ;
159                    gpr_stat_list [bank][reg].insert_write_old();
160                  }
161                  {
162                    Tgeneral_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RD_PHY_NEW [i]);
163                   
164                    log_printf(TRACE,Stat_List_unit,FUNCTION,"    * WRITE_RD - num_reg new : %d",num_reg);
165                   
166                    uint32_t bank = num_reg >> _param->_shift_gpr;
167                    uint32_t reg  = num_reg  & _param->_mask_gpr ;
168                    gpr_stat_list [bank][reg].insert_write_new();
169                  }
[78]170                }
171
172              if (PORT_READ(in_INSERT_WRITE_RE [i]))
173                {
[117]174                  {
175                    Tspecial_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RE_PHY_OLD [i]);
176                   
177                    log_printf(TRACE,Stat_List_unit,FUNCTION,"    * WRITE_RE - num_reg old : %d",num_reg);
178                   
179                    uint32_t bank = num_reg >> _param->_shift_spr;
180                    uint32_t reg  = num_reg  & _param->_mask_spr ;
181                    spr_stat_list [bank][reg].insert_write_old();
182                  }
183                  {
184                    Tspecial_address_t num_reg = PORT_READ(in_INSERT_NUM_REG_RE_PHY_NEW [i]);
185                   
186                    log_printf(TRACE,Stat_List_unit,FUNCTION,"    * WRITE_RE - num_reg new : %d",num_reg);
187                   
188                    uint32_t bank = num_reg >> _param->_shift_spr;
189                    uint32_t reg  = num_reg  & _param->_mask_spr ;
190                    spr_stat_list [bank][reg].insert_write_new();
191                  }
192                }
[78]193            }
194
195        // =====================================================
196        // =====[ RETIRE ]======================================
197        // =====================================================
198        for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
199          if (PORT_READ(in_RETIRE_VAL[i]) and internal_RETIRE_ACK[i])
200            {
[106]201              log_printf(TRACE,Stat_List_unit,FUNCTION,"  * RETIRE [%d]",i);
202
[112]203              Tcontrol_t restore = PORT_READ(in_RETIRE_RESTORE [i]);
[106]204
[112]205              log_printf(TRACE,Stat_List_unit,FUNCTION,"    * restore : %d",restore);
[106]206
[112]207//            if (PORT_READ(in_RETIRE_READ_RA [i]))
208//              {
209//                Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RA_PHY [i]);
[78]210
[112]211//                   log_printf(TRACE,Stat_List_unit,FUNCTION,"    * READ_RA  - num_reg     : %d",num_reg);
[106]212
[112]213//                uint32_t bank = num_reg >> _param->_shift_gpr;
214//                uint32_t reg  = num_reg  & _param->_mask_gpr ;
215//                gpr_stat_list [bank][reg].retire_read();
216//              }
[106]217
[112]218//            if (PORT_READ(in_RETIRE_READ_RB [i]))
219//              {
220//                Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RB_PHY [i]);
[78]221
[112]222//                   log_printf(TRACE,Stat_List_unit,FUNCTION,"    * READ_RB  - num_reg     : %d",num_reg);
[106]223
[112]224//                uint32_t bank = num_reg >> _param->_shift_gpr;
225//                uint32_t reg  = num_reg  & _param->_mask_gpr ;
226//                gpr_stat_list [bank][reg].retire_read();
227//              }
[106]228
[112]229//            if (PORT_READ(in_RETIRE_READ_RC [i]))
230//              {
231//                Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RC_PHY [i]);
[78]232
[112]233//                   log_printf(TRACE,Stat_List_unit,FUNCTION,"    * READ_RC  - num_reg     : %d",num_reg);
234
235//                uint32_t bank = num_reg >> _param->_shift_spr;
236//                uint32_t reg  = num_reg  & _param->_mask_spr ;
237//                spr_stat_list [bank][reg].retire_read();
238//              }
239
[78]240              if (PORT_READ(in_RETIRE_WRITE_RD [i]))
241                {
[88]242                  Tcontrol_t restore_old = PORT_READ(in_RETIRE_RESTORE_RD_PHY_OLD [i]);
[106]243
244                  log_printf(TRACE,Stat_List_unit,FUNCTION,"    * WRITE_RD - restore_old : %d",restore_old);
245
[78]246                  {
247                    Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RD_PHY_OLD [i]);
[106]248
[112]249                    log_printf(TRACE,Stat_List_unit,FUNCTION,"                 num_reg_old : %d",num_reg);
[106]250                 
[78]251                    uint32_t bank = num_reg >> _param->_shift_gpr;
252                    uint32_t reg  = num_reg  & _param->_mask_gpr ;
[112]253                    gpr_stat_list [bank][reg].retire_write_old(restore, restore_old);
[78]254                  }
255                  {
256                    Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RD_PHY_NEW [i]);
[106]257
[112]258                    log_printf(TRACE,Stat_List_unit,FUNCTION,"                 num_reg_new : %d",num_reg);
[106]259
[78]260                    uint32_t bank = num_reg >> _param->_shift_gpr;
261                    uint32_t reg  = num_reg  & _param->_mask_gpr ;
[112]262                    gpr_stat_list [bank][reg].retire_write_new(restore, restore_old);
[78]263                  }
264                }
265
266              if (PORT_READ(in_RETIRE_WRITE_RE [i]))
267                {
[88]268                  Tcontrol_t restore_old = PORT_READ(in_RETIRE_RESTORE_RE_PHY_OLD [i]);
[106]269
270                  log_printf(TRACE,Stat_List_unit,FUNCTION,"    * WRITE_RE - restore_old : %d",restore_old);
271
[78]272                  {
[112]273                    Tspecial_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RE_PHY_OLD [i]);
[106]274
[112]275                    log_printf(TRACE,Stat_List_unit,FUNCTION,"                 num_reg_old : %d",num_reg);
[106]276
[78]277                    uint32_t bank = num_reg >> _param->_shift_spr;
278                    uint32_t reg  = num_reg  & _param->_mask_spr ;
[112]279                    spr_stat_list [bank][reg].retire_write_old(restore, restore_old);
[78]280                  }
281                  {
[112]282                    Tspecial_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RE_PHY_NEW [i]);
[106]283
[112]284                    log_printf(TRACE,Stat_List_unit,FUNCTION,"                 num_reg_new : %d",num_reg);
[106]285
[78]286                    uint32_t bank = num_reg >> _param->_shift_spr;
287                    uint32_t reg  = num_reg  & _param->_mask_spr ;
[112]288                    spr_stat_list [bank][reg].retire_write_new(restore, restore_old);
[78]289                  }
290                }
291            }
292
293        for (uint32_t i=0; i<_param->_nb_reg_free; i++)
294          {
295            // =====================================================
296            // =====[ PUSH_GPR ]====================================
297            // =====================================================
298            if (internal_PUSH_GPR_VAL [i] and PORT_READ(in_PUSH_GPR_ACK [i]))
[118]299              gpr_stat_list[internal_PUSH_GPR_NUM_BANK [i]][internal_PUSH_GPR_NUM_REG [i]].free();
[78]300           
301            // =====================================================
302            // =====[ PUSH_SPR ]====================================
303            // =====================================================
304            if (internal_PUSH_SPR_VAL [i] and PORT_READ(in_PUSH_SPR_ACK [i]))
[118]305              spr_stat_list[internal_PUSH_SPR_NUM_BANK [i]][internal_PUSH_SPR_NUM_REG [i]].free();
[78]306          }
307
308        // Update pointer
[112]309        reg_GPR_PTR_FREE = ((reg_GPR_PTR_FREE==0)?_param->_nb_general_register_by_bank:reg_GPR_PTR_FREE)-1;
310        reg_SPR_PTR_FREE = ((reg_SPR_PTR_FREE==0)?_param->_nb_special_register_by_bank:reg_SPR_PTR_FREE)-1;
[78]311      }
312
313
[88]314#if (DEBUG >= DEBUG_TRACE)
[112]315    {
316      log_printf(TRACE,Stat_List_unit,FUNCTION,"  * Dump Stat List");
317      log_printf(TRACE,Stat_List_unit,FUNCTION,"    * reg_GPR_PTR_FREE : %d",reg_GPR_PTR_FREE);
318      log_printf(TRACE,Stat_List_unit,FUNCTION,"    * reg_SPR_PTR_FREE : %d",reg_SPR_PTR_FREE);
319     
320      for (uint32_t i=0; i<_param->_nb_bank; i++)
321        for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
[123]322          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * GPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d, use %.1d",
[112]323                     i,
324                     j,
325                     (i<<_param->_shift_gpr)|j,
326                     gpr_stat_list[i][j]._is_free,
[123]327                     gpr_stat_list[i][j]._is_link,
328                     gpr_stat_list[i][j]._is_use// ,
[112]329//                      gpr_stat_list[i][j]._is_valid,
330//                      gpr_stat_list[i][j]._counter
331                     );
332      for (uint32_t i=0; i<_param->_nb_bank; i++)
333        for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
[123]334          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * SPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d, use %.1d",
[112]335                     i,
336                     j,
337                     (i<<_param->_shift_spr)|j,
338                     spr_stat_list[i][j]._is_free,
[123]339                     spr_stat_list[i][j]._is_link,
340                     spr_stat_list[i][j]._is_use// ,
[112]341//                      spr_stat_list[i][j]._is_valid,
342//                      spr_stat_list[i][j]._counter
343                     );
344    }
[88]345#endif
346
[112]347#ifdef DEBUG_TEST
348# if 0
349    {
350      uint32_t size_rob   = 64;
351      uint32_t nb_context = 1;
352     
353      {
354        uint32_t nb_is_link = 0;
355        uint32_t nb_reg = 32;
356        for (uint32_t i=0; i<_param->_nb_bank; i++)
357          for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
358            if (gpr_stat_list[i][j]._is_link)
359              nb_is_link ++;
360       
361        log_printf(TRACE,Stat_List_unit,FUNCTION,"    * nb_GPR_IS_LINK   : %d",nb_is_link);
362       
363        if (nb_is_link > size_rob+nb_context*nb_reg)
364          throw ERRORMORPHEO(FUNCTION,toString(_("They are %d linked gpr register, but max is size_rob+nb_context*%d = %d+%d*%d = %d"),nb_is_link,nb_reg,size_rob,nb_context,nb_reg,size_rob+nb_context*nb_reg));
365      }
366     
367      {
368        uint32_t nb_is_link = 0;
369        uint32_t nb_reg = 2;
370        for (uint32_t i=0; i<_param->_nb_bank; i++)
371          for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
372            if (spr_stat_list[i][j]._is_link)
373              nb_is_link ++;
374       
375        log_printf(TRACE,Stat_List_unit,FUNCTION,"    * nb_SPR_IS_LINK   : %d",nb_is_link);
376       
377        if (nb_is_link > size_rob+nb_context*nb_reg)
378          throw ERRORMORPHEO(FUNCTION,toString(_("They are %d linked spr register, but max is size_rob+nb_context*%d = %d+%d*%d = %d"),nb_is_link,nb_reg,size_rob,nb_context,nb_reg,size_rob+nb_context*nb_reg));
379      }
380    }
381# endif
382#endif
383               
384
[78]385#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
386    end_cycle ();
387#endif
388
[88]389    log_end(Stat_List_unit,FUNCTION);
[78]390  };
391
392}; // end namespace stat_list_unit
393}; // end namespace register_translation_unit
394}; // end namespace rename_unit
395}; // end namespace ooo_engine
396}; // end namespace multi_ooo_engine
397}; // end namespace core
398
399}; // end namespace behavioural
400}; // end namespace morpheo             
401#endif
Note: See TracBrowser for help on using the repository browser.