Ignore:
Timestamp:
Apr 15, 2008, 8:40:01 PM (16 years ago)
Author:
rosiere
Message:
  • Finish Environment (and test)
  • Continue predictor_unit
  • Add external tools
  • svn keyword "Id" set
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/src/test.cpp

    • Property svn:keywords set to Id
    r78 r81  
    1111#include "Behavioural/include/Allocation.h"
    1212
    13 #define NB_ITERATION  1024
    14 #define CYCLE_MAX     (128*NB_ITERATION)
     13#define NB_ITERATION  16
     14#define CYCLE_MAX     (1024*NB_ITERATION)
    1515
    1616#define LABEL(str...)                                                   \
    … …  
    2121  } while(0)
    2222
    23 #define SC_START(cycle_offset)                                                       \
    24   do                                                                                 \
    25     {                                                                                \
    26       /*cout << "SC_START (begin)" << endl;*/                                        \
    27                                                                                      \
    28       uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time());          \
    29       if (cycle_offset != 0)                                                         \
    30         {                                                                            \
    31           cout << "##########[ cycle "<< cycle_current+cycle_offset << " ]" << endl; \
    32         }                                                                            \
    33                                                                                      \
    34       if (cycle_current > CYCLE_MAX)                                                 \
    35         {                                                                            \
    36           TEST_KO("Maximal cycles Reached");                                         \
    37         }                                                                            \
    38                                                                                      \
    39       sc_start(cycle_offset);                                                        \
    40                                                                                      \
    41       /*cout << "SC_START (end  )" << endl;*/                                        \
     23#define SC_START(cycle_offset)                                          \
     24  do                                                                    \
     25    {                                                                   \
     26      uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time()); \
     27      if (cycle_offset != 0)                                            \
     28        {                                                               \
     29          cout << "##########[ cycle "<< cycle_current+cycle_offset << " ]"; \
     30          cout << " (" << __LINE__ << ")" << endl;                      \
     31        }                                                               \
     32                                                                        \
     33      if (cycle_current > CYCLE_MAX)                                    \
     34        {                                                               \
     35          TEST_KO("Maximal cycles Reached");                            \
     36        }                                                               \
     37                                                                        \
     38      sc_start(cycle_offset);                                           \
     39                                                                        \
    4240    } while(0)
    4341
    … …  
    9088  ALLOC1_SC_SIGNAL( in_UPDATE_ADDRESS        ," in_UPDATE_ADDRESS        ",Taddress_t,_param->_nb_inst_update );
    9189  ALLOC1_SC_SIGNAL( in_UPDATE_MISS_PREDICTION," in_UPDATE_MISS_PREDICTION",Tcontrol_t,_param->_nb_inst_update );
     90  ALLOC1_SC_SIGNAL( in_UPDATE_PREDICTION_IFETCH," in_UPDATE_PREDICTION_IFETCH",Tcontrol_t,_param->_nb_inst_update );
    9291 
    9392  /********************************************************
    … …  
    127126  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_ADDRESS        ,_param->_nb_inst_update );
    128127  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_MISS_PREDICTION,_param->_nb_inst_update );
     128  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_PREDICTION_IFETCH,_param->_nb_inst_update );
    129129
    130130  msg(_("<%s> : Start Simulation ............\n"),name.c_str());
    … …  
    157157      LABEL("Iteration %d",iteration);
    158158
    159       SC_START(1);
     159      if (1)
     160        {
     161        uint32_t port = rand()%_param->_nb_inst_predict;
     162
     163        LABEL("PREDICT - PUSH");
     164       
     165        in_PREDICT_VAL  [port]->write(1);
     166        in_PREDICT_PUSH [port]->write(1);
     167        for (uint32_t i=0; i<_param->_nb_context; i++)
     168          for (uint32_t j=0; j<_param->_size_queue[i]; j++)
     169            {
     170              in_PREDICT_CONTEXT_ID   [port]->write(i);
     171              in_PREDICT_ADDRESS_PUSH [port]->write(0xdeadbeef+j);
     172             
     173              SC_START(0);
     174             
     175              TEST(Tcontrol_t, out_PREDICT_ACK  [port]->read(), 1);
     176              TEST(Tptr_t    , out_PREDICT_INDEX[port]->read(),(j+1)%_param->_size_queue[i]);
     177             
     178              SC_START(1);
     179             
     180            }
     181        in_PREDICT_VAL [port]->write(0);
     182       
     183        SC_START(1);
     184       
     185        in_PREDICT_VAL  [port]->write(1);
     186        in_PREDICT_PUSH [port]->write(1);
     187        for (uint32_t i=0; i<_param->_nb_context; i++)
     188          for (uint32_t j=0; j<_param->_size_queue[i]; j++)
     189            {
     190              in_PREDICT_CONTEXT_ID   [port]->write(i);
     191              in_PREDICT_ADDRESS_PUSH [port]->write(0x21071981+j);
     192             
     193              SC_START(0);
     194             
     195              TEST(Tcontrol_t, out_PREDICT_ACK        [port]->read(), 1);
     196              TEST(Tptr_t    , out_PREDICT_INDEX      [port]->read(),(j+1)%_param->_size_queue[i]);
     197              TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port]->read(),0xdeadbeef+j);
     198             
     199              SC_START(1);
     200            }
     201        in_PREDICT_VAL [port]->write(0);
     202       
     203        LABEL("PREDICT - POP");
     204       
     205        in_PREDICT_VAL  [port]->write(1);
     206        in_PREDICT_PUSH [port]->write(0);
     207        for (uint32_t i=0; i<_param->_nb_context; i++)
     208          for (uint32_t j=0; j< _param->_size_queue[i]; j++)
     209            {
     210              in_PREDICT_CONTEXT_ID   [port]->write(i);
     211              in_PREDICT_ADDRESS_PUSH [port]->write(0xbabedead);
     212             
     213              SC_START(0);
     214             
     215              TEST(Tcontrol_t, out_PREDICT_ACK        [port]->read(), 1);
     216              TEST(Tcontrol_t, out_PREDICT_HIT        [port]->read(), 1);
     217              uint32_t k=(_param->_size_queue[i]-j)%_param->_size_queue[i];
     218              TEST(Tptr_t    , out_PREDICT_INDEX      [port]->read(), k);
     219              TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port]->read(),(0x21071981+((k==0)?(_param->_size_queue[i]-1):(k-1))));
     220             
     221              SC_START(1);
     222            }
     223        in_PREDICT_VAL [port]->write(0);
     224        }
     225
     226      // Now, the stack is empty
     227
     228      if (1)
     229        {
     230        uint32_t port1 = rand()%_param->_nb_inst_decod;
     231        uint32_t port2 = rand()%_param->_nb_inst_predict;
     232
     233        LABEL("DECOD - without predict");
     234       
     235        LABEL("DECOD - PUSH"); 
     236       
     237        in_DECOD_VAL             [port1]->write(1);
     238        in_DECOD_PUSH            [port1]->write(1);
     239        in_DECOD_MISS_PREDICTION [port1]->write(0);
     240       
     241        for (uint32_t i=0; i<_param->_nb_context; i++)
     242          for (uint32_t j=0; j<_param->_size_queue[i]; j++)
     243            {
     244              in_DECOD_CONTEXT_ID   [port1]->write(i);
     245              in_DECOD_ADDRESS_PUSH [port1]->write(0xbeefcaca+j);
     246             
     247              SC_START(0);
     248             
     249              TEST(Tcontrol_t, out_DECOD_ACK  [port1]->read(), 1);
     250              TEST(Tptr_t    , out_DECOD_INDEX[port1]->read(),(j+1)%_param->_size_queue[i]);
     251             
     252              SC_START(1);
     253             
     254            }
     255        in_DECOD_VAL [port1]->write(0);
     256       
     257        SC_START(1);
     258       
     259        in_DECOD_VAL  [port1]->write(1);
     260        in_DECOD_PUSH [port1]->write(1);
     261        for (uint32_t i=0; i<_param->_nb_context; i++)
     262          for (uint32_t j=0; j<_param->_size_queue[i]; j++)
     263            {
     264              in_DECOD_CONTEXT_ID   [port1]->write(i);
     265              in_DECOD_ADDRESS_PUSH [port1]->write(0x21071981+j);
     266             
     267              SC_START(0);
     268             
     269              TEST(Tcontrol_t, out_DECOD_ACK        [port1]->read(), 1);
     270              TEST(Tptr_t    , out_DECOD_INDEX      [port1]->read(),(j+1)%_param->_size_queue[i]);
     271              TEST(Taddress_t, out_DECOD_ADDRESS_POP[port1]->read(),0xbeefcaca+j);
     272             
     273              SC_START(1);
     274            }
     275        in_DECOD_VAL [port1]->write(0);
     276       
     277        LABEL("DECOD - POP");
     278       
     279        in_DECOD_VAL  [port1]->write(1);
     280        in_DECOD_PUSH [port1]->write(0);
     281        for (uint32_t i=0; i<_param->_nb_context; i++)
     282          for (uint32_t j=0; j< _param->_size_queue[i]; j++)
     283            {
     284              in_DECOD_CONTEXT_ID   [port1]->write(i);
     285              in_DECOD_ADDRESS_PUSH [port1]->write(0xbabedead);
     286             
     287              SC_START(0);
     288             
     289              TEST(Tcontrol_t, out_DECOD_ACK        [port1]->read(), 1);
     290              TEST(Tcontrol_t, out_DECOD_HIT        [port1]->read(), 1);
     291              uint32_t k=(_param->_size_queue[i]-j)%_param->_size_queue[i];
     292              TEST(Tptr_t    , out_DECOD_INDEX      [port1]->read(), k);
     293              TEST(Taddress_t, out_DECOD_ADDRESS_POP[port1]->read(),(0x21071981+((k==0)?(_param->_size_queue[i]-1):(k-1))));
     294             
     295              SC_START(1);
     296            }
     297        in_DECOD_VAL [port1]->write(0);
     298
     299        LABEL("DECOD - with predict");
     300       
     301        LABEL("DECOD - PUSH (size_queue/2)"); 
     302       
     303        in_DECOD_VAL             [port1]->write(1);
     304        in_DECOD_PUSH            [port1]->write(1);
     305        in_DECOD_MISS_PREDICTION [port1]->write(1);
     306       
     307        for (uint32_t i=0; i<_param->_nb_context; i++)
     308          for (uint32_t j=0; j<_param->_size_queue[i]/2;j++)
     309            {
     310              in_DECOD_CONTEXT_ID   [port1]->write(i);
     311              in_DECOD_ADDRESS_PUSH [port1]->write(0x01234567+j);
     312             
     313              SC_START(0);
     314             
     315              TEST(Tcontrol_t, out_DECOD_ACK  [port1]->read(), 1);
     316              TEST(Tptr_t    , out_DECOD_INDEX[port1]->read(),(j+1)%_param->_size_queue[i]);
     317             
     318              SC_START(1);
     319             
     320            }
     321        in_DECOD_VAL [port1]->write(0);
     322
     323        LABEL("PREDICT - PUSH (size_queue/2)"); 
     324       
     325        in_PREDICT_VAL             [port2]->write(1);
     326        in_PREDICT_PUSH            [port2]->write(1);
     327       
     328        for (uint32_t i=0; i<_param->_nb_context; i++)
     329          for (uint32_t j=0; j<_param->_size_queue[i]/2;j++)
     330            {
     331              in_PREDICT_CONTEXT_ID   [port2]->write(i);
     332              in_PREDICT_ADDRESS_PUSH [port2]->write((0x89abcdef+j)+(_param->_size_queue[i]/2));
     333             
     334              SC_START(0);
     335             
     336              TEST(Tcontrol_t, out_PREDICT_ACK  [port2]->read(), 1);
     337              TEST(Tptr_t    , out_PREDICT_INDEX[port2]->read(),(j+1+(_param->_size_queue[i]/2))%_param->_size_queue[i]);
     338             
     339              SC_START(1);
     340            }
     341
     342        in_PREDICT_VAL [port2]->write(0);
     343
     344        LABEL("PREDICT - POP (size_queue/2)"); 
     345
     346        in_PREDICT_VAL  [port2]->write(1);
     347        in_PREDICT_PUSH [port2]->write(0);
     348        for (uint32_t i=0; i<_param->_nb_context; i++)
     349          {
     350            for (uint32_t j=0; j< _param->_size_queue[i]/2; j++)
     351              {
     352                in_PREDICT_CONTEXT_ID   [port2]->write(i);
     353                in_PREDICT_ADDRESS_PUSH [port2]->write(0xbabedead);
     354               
     355                SC_START(0);
     356               
     357                TEST(Tcontrol_t, out_PREDICT_ACK        [port2]->read(), 1);
     358                TEST(Tcontrol_t, out_PREDICT_HIT        [port2]->read(), 1);
     359                uint32_t k=  (_param->_size_queue[i]-j)%_param->_size_queue[i];
     360                TEST(Tptr_t    , out_PREDICT_INDEX      [port2]->read(), k);
     361
     362                Taddress_t res = (0x89abcdef+((k==0)?(_param->_size_queue[i]-1):(k-1)));
     363                LABEL("k      : %d",k);
     364                LABEL("res    : %x",res);
     365                LABEL("@_pop  : %x",out_PREDICT_ADDRESS_POP[port2]->read());
     366
     367                TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port2]->read(),res);
     368               
     369                SC_START(1);
     370              }
     371
     372            for (uint32_t j=0; j< _param->_size_queue[i]/2; j++)
     373              {
     374                in_PREDICT_CONTEXT_ID   [port2]->write(i);
     375                in_PREDICT_ADDRESS_PUSH [port2]->write(0xbabedead);
     376               
     377                SC_START(0);
     378               
     379                TEST(Tcontrol_t, out_PREDICT_ACK        [port2]->read(), 1);
     380                TEST(Tcontrol_t, out_PREDICT_HIT        [port2]->read(), 1);
     381                uint32_t k=(_param->_size_queue[i]/2-j)%_param->_size_queue[i];
     382                TEST(Tptr_t    , out_PREDICT_INDEX      [port2]->read(), k);
     383
     384                Taddress_t res = (0x01234567+((k==0)?(_param->_size_queue[i]/2-1):(k-1)));
     385
     386                LABEL("k      : %d",k);
     387                LABEL("res    : %x",res);
     388                LABEL("@_pop  : %x",out_PREDICT_ADDRESS_POP[port2]->read());
     389
     390                TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port2]->read(),res);
     391               
     392                SC_START(1);
     393              }
     394          }
     395
     396        in_PREDICT_VAL [port2]->write(0);
     397
     398        in_DECOD_VAL  [port1]->write(1);
     399        in_DECOD_PUSH [port1]->write(0);
     400        in_DECOD_MISS_PREDICTION [port1]->write(0);
     401
     402        for (uint32_t i=0; i<_param->_nb_context; i++)
     403          {
     404            for (uint32_t j=0; j< _param->_size_queue[i]/2; j++)
     405              {
     406                in_DECOD_CONTEXT_ID   [port1]->write(i);
     407                in_DECOD_ADDRESS_PUSH [port1]->write(0xbabedead);
     408               
     409                SC_START(0);
     410               
     411                TEST(Tcontrol_t, out_DECOD_ACK        [port1]->read(), 1);
     412                TEST(Tcontrol_t, out_DECOD_HIT        [port1]->read(), 1);
     413                uint32_t k=(_param->_size_queue[i]/2-j)%_param->_size_queue[i];
     414                TEST(Tptr_t    , out_DECOD_INDEX      [port1]->read(), k);
     415
     416                Taddress_t res = (0x01234567+((k==0)?(_param->_size_queue[i]/2-1):(k-1)));
     417
     418                LABEL("k      : %d",k);
     419                LABEL("res    : %x",res);
     420                LABEL("@_pop  : %x",out_DECOD_ADDRESS_POP[port1]->read());
     421
     422                TEST(Taddress_t, out_DECOD_ADDRESS_POP[port1]->read(),res);
     423               
     424                SC_START(1);
     425              }
     426          }
     427
     428        in_DECOD_VAL [port1]->write(0);
     429
     430      }
    160431    }
    161432
    … …  
    195466  delete []  in_UPDATE_INDEX         ;
    196467  delete []  in_UPDATE_ADDRESS       ;
     468  delete []  in_UPDATE_MISS_PREDICTION;
     469  delete []  in_UPDATE_PREDICTION_IFETCH;
    197470
    198471#endif
Note: See TracChangeset for help on using the changeset viewer.