Ignore:
Timestamp:
Dec 4, 2007, 1:26:55 PM (17 years ago)
Author:
rosiere
Message:

register_unit_glue : separation des fonctions - evite les cycles dans le graph de dependances des ports i/o

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue
Files:
9 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h

    r60 r61  
    184184#ifdef SYSTEMC                                 
    185185//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    186   public  : void     transition                (void);
    187   public  : void     genMealy_gpr_write        (void);
    188   public  : void     genMealy_gpr_read         (void);
    189   public  : void     genMealy_spr_write        (void);
    190   public  : void     genMealy_spr_read         (void);
    191   public  : void     genMealy_insert           (void);
    192   public  : void     genMealy_retire           (void);
     186  public  : void     transition                      (void);
     187  public  : void     genMealy_gpr_read               (void);
     188  public  : void     genMealy_gpr_read_status        (void);
     189  public  : void     genMealy_gpr_read_registerfile  (void);
     190  public  : void     genMealy_gpr_write              (void);
     191  public  : void     genMealy_gpr_write_status       (void);
     192  public  : void     genMealy_gpr_write_registerfile (void);
     193  public  : void     genMealy_spr_read               (void);
     194  public  : void     genMealy_spr_read_status        (void);
     195  public  : void     genMealy_spr_read_registerfile  (void);
     196  public  : void     genMealy_spr_write              (void);
     197  public  : void     genMealy_spr_write_status       (void);
     198  public  : void     genMealy_spr_write_registerfile (void);
     199  public  : void     genMealy_insert                 (void);
     200  public  : void     genMealy_retire                 (void);
    193201
    194202//#endif

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue.cpp

    r60 r61  
    6666    PORT_WRITE(out_CONST_1 ,1);
    6767
    68 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    69 
    7068    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - transition");
    7169
    … …  
    7371    dont_initialize ();
    7472    sensitive_pos << *(in_CLOCK);
    75 //#endif
    7673
    7774#ifdef SYSTEMCASS_SPECIFIC
    … …  
    8380    SC_METHOD (genMealy_gpr_read);
    8481    dont_initialize ();
    85     sensitive_neg << *(in_CLOCK);
     82//     sensitive_neg << *(in_CLOCK);
    8683    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
    8784      {
    88         sensitive << *(in_GPR_READ_VAL           [j]);
    8985        if (_param->_have_port_ooo_engine_id == true)
    9086          sensitive << *(in_GPR_READ_OOO_ENGINE_ID [j]);
    … …  
    9692                    << *(in_GPR_READ_STATUS_DATA_VAL   [i][j]);
    9793      }
    98 //#endif
    9994
    10095#ifdef SYSTEMCASS_SPECIFIC
    … …  
    114109            (*(out_GPR_READ_DATA                 [j])) (*( in_GPR_READ_REGISTERFILE_DATA [i][j]));
    115110            (*(out_GPR_READ_DATA_VAL             [j])) (*( in_GPR_READ_STATUS_DATA_VAL   [i][j]));     
    116 
     111          }
     112      }
     113#endif   
     114
     115    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_gpr_read_status");
     116
     117    SC_METHOD (genMealy_gpr_read_status);
     118    dont_initialize ();
     119//     sensitive_neg << *(in_CLOCK);
     120    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     121      {
     122        sensitive << *(in_GPR_READ_VAL           [j]);
     123        if (_param->_have_port_ooo_engine_id == true)
     124          sensitive << *(in_GPR_READ_OOO_ENGINE_ID [j]);
     125
     126        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     127          sensitive << *(in_GPR_READ_REGISTERFILE_ACK  [i][j]);
     128      }
     129
     130#ifdef SYSTEMCASS_SPECIFIC
     131    // List dependency information
     132    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     133      {
     134        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     135          {
     136            (*(out_GPR_READ_STATUS_VAL        [i][j])) (*( in_GPR_READ_VAL                  [j]));
     137            (*(out_GPR_READ_STATUS_VAL        [i][j])) (*( in_GPR_READ_REGISTERFILE_ACK  [i][j]));
     138            if (_param->_have_port_ooo_engine_id == true)
     139            (*(out_GPR_READ_STATUS_VAL        [i][j])) (*( in_GPR_READ_OOO_ENGINE_ID        [j]));
     140          }
     141      }
     142#endif   
     143
     144    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_gpr_read_registerfile");
     145
     146    SC_METHOD (genMealy_gpr_read_registerfile);
     147    dont_initialize ();
     148//     sensitive_neg << *(in_CLOCK);
     149    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     150      {
     151        sensitive << *(in_GPR_READ_VAL           [j]);
     152        if (_param->_have_port_ooo_engine_id == true)
     153          sensitive << *(in_GPR_READ_OOO_ENGINE_ID [j]);
     154
     155        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     156          sensitive << *(in_GPR_READ_STATUS_ACK        [i][j]);
     157      }
     158
     159#ifdef SYSTEMCASS_SPECIFIC
     160    // List dependency information
     161    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     162      {
     163        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     164          {
    117165            (*(out_GPR_READ_REGISTERFILE_VAL  [i][j])) (*( in_GPR_READ_VAL                  [j]));
    118166            (*(out_GPR_READ_REGISTERFILE_VAL  [i][j])) (*( in_GPR_READ_STATUS_ACK        [i][j]));
    119167            if (_param->_have_port_ooo_engine_id == true)
    120168            (*(out_GPR_READ_REGISTERFILE_VAL  [i][j])) (*( in_GPR_READ_OOO_ENGINE_ID        [j]));
    121 
    122             (*(out_GPR_READ_STATUS_VAL        [i][j])) (*( in_GPR_READ_VAL                  [j]));
    123             (*(out_GPR_READ_STATUS_VAL        [i][j])) (*( in_GPR_READ_REGISTERFILE_ACK  [i][j]));
    124             if (_param->_have_port_ooo_engine_id == true)
    125             (*(out_GPR_READ_STATUS_VAL        [i][j])) (*( in_GPR_READ_OOO_ENGINE_ID        [j]));
    126169          }
    127170      }
    … …  
    132175    SC_METHOD (genMealy_gpr_write);
    133176    dont_initialize ();
    134     sensitive_neg << *(in_CLOCK);
     177//     sensitive_neg << *(in_CLOCK);
    135178    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
    136179      {
    137         sensitive << *(in_GPR_WRITE_VAL           [j]);
    138180        if (_param->_have_port_ooo_engine_id == true)
    139181          sensitive << *(in_GPR_WRITE_OOO_ENGINE_ID [j]);
    … …  
    143185                    << *(in_GPR_WRITE_STATUS_ACK        [i][j]);
    144186      }
    145 //#endif
    146187
    147188#ifdef SYSTEMCASS_SPECIFIC
    … …  
    156197            (*(out_GPR_WRITE_ACK                  [j])) (*( in_GPR_WRITE_REGISTERFILE_ACK  [i][j]));
    157198            (*(out_GPR_WRITE_ACK                  [j])) (*( in_GPR_WRITE_STATUS_ACK        [i][j]));
    158 
     199          }
     200      }
     201#endif   
     202
     203    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_gpr_write_status");
     204
     205    SC_METHOD (genMealy_gpr_write_status);
     206    dont_initialize ();
     207//     sensitive_neg << *(in_CLOCK);
     208    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     209      {
     210        sensitive << *(in_GPR_WRITE_VAL           [j]);
     211        if (_param->_have_port_ooo_engine_id == true)
     212          sensitive << *(in_GPR_WRITE_OOO_ENGINE_ID [j]);
     213
     214        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     215          sensitive << *(in_GPR_WRITE_REGISTERFILE_ACK  [i][j]);
     216      }
     217
     218#ifdef SYSTEMCASS_SPECIFIC
     219    // List dependency information
     220    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     221      {
     222        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     223          {
     224            (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_VAL                  [j]));
     225            (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_REGISTERFILE_ACK  [i][j]));
     226            if (_param->_have_port_ooo_engine_id == true)
     227            (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_OOO_ENGINE_ID        [j]));
     228          }
     229      }
     230#endif   
     231
     232    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_gpr_write_registerfile");
     233
     234    SC_METHOD (genMealy_gpr_write_registerfile);
     235    dont_initialize ();
     236//     sensitive_neg << *(in_CLOCK);
     237    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     238      {
     239        sensitive << *(in_GPR_WRITE_VAL           [j]);
     240        if (_param->_have_port_ooo_engine_id == true)
     241          sensitive << *(in_GPR_WRITE_OOO_ENGINE_ID [j]);
     242
     243        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     244          sensitive << *(in_GPR_WRITE_STATUS_ACK        [i][j]);
     245      }
     246
     247#ifdef SYSTEMCASS_SPECIFIC
     248    // List dependency information
     249    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     250      {
     251        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     252          {
    159253            (*(out_GPR_WRITE_REGISTERFILE_VAL  [i][j])) (*( in_GPR_WRITE_VAL                  [j]));
    160254            (*(out_GPR_WRITE_REGISTERFILE_VAL  [i][j])) (*( in_GPR_WRITE_STATUS_ACK        [i][j]));
    161255            if (_param->_have_port_ooo_engine_id == true)
    162256            (*(out_GPR_WRITE_REGISTERFILE_VAL  [i][j])) (*( in_GPR_WRITE_OOO_ENGINE_ID        [j]));
    163            
    164             (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_VAL                  [j]));
    165             (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_REGISTERFILE_ACK  [i][j]));
    166             if (_param->_have_port_ooo_engine_id == true)
    167             (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_OOO_ENGINE_ID        [j]));
    168           }
    169       }
    170 #endif   
    171 
    172 //     log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_gpr_write_status");
    173 
    174 //     SC_METHOD (genMealy_gpr_write_status);
    175 //     dont_initialize ();
    176 //     sensitive_neg << *(in_CLOCK);
    177 //     for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
    178 //       {
    179 //      sensitive << *(in_GPR_WRITE_VAL           [j]);
    180 //      if (_param->_have_port_ooo_engine_id == true)
    181 //        sensitive << *(in_GPR_WRITE_OOO_ENGINE_ID [j]);
    182 
    183 //      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    184 //        sensitive << *(in_GPR_WRITE_REGISTERFILE_ACK  [i][j]);
    185 //       }
    186 // //#endif
    187 
    188 // #ifdef SYSTEMCASS_SPECIFIC
    189 //     // List dependency information
    190 //     for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
    191 //       {
    192 //      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    193 //        {
    194 //          (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_VAL                  [j]));
    195 //          (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_REGISTERFILE_ACK  [i][j]));
    196 //          if (_param->_have_port_ooo_engine_id == true)
    197 //          (*(out_GPR_WRITE_STATUS_VAL        [i][j])) (*( in_GPR_WRITE_OOO_ENGINE_ID        [j]));
    198 //        }
    199 //       }
    200 // #endif   
     257          }
     258      }
     259#endif   
    201260
    202261    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_spr_read");
    … …  
    204263    SC_METHOD (genMealy_spr_read);
    205264    dont_initialize ();
    206     sensitive_neg << *(in_CLOCK);
     265//     sensitive_neg << *(in_CLOCK);
    207266    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
    208267      {
    209         sensitive << *(in_SPR_READ_VAL           [j]);
    210268        if (_param->_have_port_ooo_engine_id == true)
    211269          sensitive << *(in_SPR_READ_OOO_ENGINE_ID [j]);
    … …  
    217275                    << *(in_SPR_READ_STATUS_DATA_VAL   [i][j]);
    218276      }
    219 //#endif
    220277
    221278#ifdef SYSTEMCASS_SPECIFIC
    … …  
    235292            (*(out_SPR_READ_DATA                 [j])) (*( in_SPR_READ_REGISTERFILE_DATA [i][j]));
    236293            (*(out_SPR_READ_DATA_VAL             [j])) (*( in_SPR_READ_STATUS_DATA_VAL   [i][j]));     
    237 
     294          }
     295      }
     296#endif   
     297
     298    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_spr_read_status");
     299
     300    SC_METHOD (genMealy_spr_read_status);
     301    dont_initialize ();
     302//     sensitive_neg << *(in_CLOCK);
     303    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     304      {
     305        sensitive << *(in_SPR_READ_VAL           [j]);
     306        if (_param->_have_port_ooo_engine_id == true)
     307          sensitive << *(in_SPR_READ_OOO_ENGINE_ID [j]);
     308
     309        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     310          sensitive << *(in_SPR_READ_REGISTERFILE_ACK  [i][j]);
     311      }
     312
     313#ifdef SYSTEMCASS_SPECIFIC
     314    // List dependency information
     315    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     316      {
     317        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     318          {
     319            (*(out_SPR_READ_STATUS_VAL        [i][j])) (*( in_SPR_READ_VAL                  [j]));
     320            (*(out_SPR_READ_STATUS_VAL        [i][j])) (*( in_SPR_READ_REGISTERFILE_ACK  [i][j]));
     321            if (_param->_have_port_ooo_engine_id == true)
     322            (*(out_SPR_READ_STATUS_VAL        [i][j])) (*( in_SPR_READ_OOO_ENGINE_ID        [j]));
     323          }
     324      }
     325#endif   
     326
     327    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_spr_read_registerfile");
     328
     329    SC_METHOD (genMealy_spr_read_registerfile);
     330    dont_initialize ();
     331//     sensitive_neg << *(in_CLOCK);
     332    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     333      {
     334        sensitive << *(in_SPR_READ_VAL           [j]);
     335        if (_param->_have_port_ooo_engine_id == true)
     336          sensitive << *(in_SPR_READ_OOO_ENGINE_ID [j]);
     337
     338        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     339          sensitive << *(in_SPR_READ_STATUS_ACK        [i][j]);
     340      }
     341
     342#ifdef SYSTEMCASS_SPECIFIC
     343    // List dependency information
     344    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     345      {
     346        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     347          {
    238348            (*(out_SPR_READ_REGISTERFILE_VAL  [i][j])) (*( in_SPR_READ_VAL                  [j]));
    239349            (*(out_SPR_READ_REGISTERFILE_VAL  [i][j])) (*( in_SPR_READ_STATUS_ACK        [i][j]));
    240350            if (_param->_have_port_ooo_engine_id == true)
    241351            (*(out_SPR_READ_REGISTERFILE_VAL  [i][j])) (*( in_SPR_READ_OOO_ENGINE_ID        [j]));
    242            
    243             (*(out_SPR_READ_STATUS_VAL        [i][j])) (*( in_SPR_READ_VAL                  [j]));
    244             (*(out_SPR_READ_STATUS_VAL        [i][j])) (*( in_SPR_READ_REGISTERFILE_ACK  [i][j]));
    245             if (_param->_have_port_ooo_engine_id == true)
    246             (*(out_SPR_READ_STATUS_VAL        [i][j])) (*( in_SPR_READ_OOO_ENGINE_ID        [j]));
    247352          }
    248353      }
    … …  
    253358    SC_METHOD (genMealy_spr_write);
    254359    dont_initialize ();
    255     sensitive_neg << *(in_CLOCK);
     360//     sensitive_neg << *(in_CLOCK);
    256361    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
    257362      {
    258         sensitive << *(in_SPR_WRITE_VAL           [j]);
    259363        if (_param->_have_port_ooo_engine_id == true)
    260364          sensitive << *(in_SPR_WRITE_OOO_ENGINE_ID [j]);
    … …  
    264368                    << *(in_SPR_WRITE_STATUS_ACK        [i][j]);
    265369      }
    266 //#endif
    267370
    268371#ifdef SYSTEMCASS_SPECIFIC
    … …  
    277380            (*(out_SPR_WRITE_ACK                  [j])) (*( in_SPR_WRITE_REGISTERFILE_ACK  [i][j]));
    278381            (*(out_SPR_WRITE_ACK                  [j])) (*( in_SPR_WRITE_STATUS_ACK        [i][j]));
    279 
     382          }
     383      }
     384#endif   
     385
     386    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_spr_write_status");
     387
     388    SC_METHOD (genMealy_spr_write_status);
     389    dont_initialize ();
     390//     sensitive_neg << *(in_CLOCK);
     391    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     392      {
     393        sensitive << *(in_SPR_WRITE_VAL           [j]);
     394        if (_param->_have_port_ooo_engine_id == true)
     395          sensitive << *(in_SPR_WRITE_OOO_ENGINE_ID [j]);
     396
     397        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     398          sensitive << *(in_SPR_WRITE_REGISTERFILE_ACK  [i][j]);
     399      }
     400
     401#ifdef SYSTEMCASS_SPECIFIC
     402    // List dependency information
     403    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     404      {
     405        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     406          {
     407            (*(out_SPR_WRITE_STATUS_VAL        [i][j])) (*( in_SPR_WRITE_VAL                  [j]));
     408            (*(out_SPR_WRITE_STATUS_VAL        [i][j])) (*( in_SPR_WRITE_REGISTERFILE_ACK  [i][j]));
     409            if (_param->_have_port_ooo_engine_id == true)
     410            (*(out_SPR_WRITE_STATUS_VAL        [i][j])) (*( in_SPR_WRITE_OOO_ENGINE_ID        [j]));
     411          }
     412      }
     413#endif   
     414
     415    log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_spr_write_registerfile");
     416
     417    SC_METHOD (genMealy_spr_write_registerfile);
     418    dont_initialize ();
     419//     sensitive_neg << *(in_CLOCK);
     420    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     421      {
     422        sensitive << *(in_SPR_WRITE_VAL           [j]);
     423        if (_param->_have_port_ooo_engine_id == true)
     424          sensitive << *(in_SPR_WRITE_OOO_ENGINE_ID [j]);
     425
     426        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     427          sensitive << *(in_SPR_WRITE_STATUS_ACK        [i][j]);
     428      }
     429
     430#ifdef SYSTEMCASS_SPECIFIC
     431    // List dependency information
     432    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     433      {
     434        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     435          {
    280436            (*(out_SPR_WRITE_REGISTERFILE_VAL  [i][j])) (*( in_SPR_WRITE_VAL                  [j]));
    281437            (*(out_SPR_WRITE_REGISTERFILE_VAL  [i][j])) (*( in_SPR_WRITE_STATUS_ACK        [i][j]));
    282438            if (_param->_have_port_ooo_engine_id == true)
    283439            (*(out_SPR_WRITE_REGISTERFILE_VAL  [i][j])) (*( in_SPR_WRITE_OOO_ENGINE_ID        [j]));
    284            
    285             (*(out_SPR_WRITE_STATUS_VAL        [i][j])) (*( in_SPR_WRITE_VAL                  [j]));
    286             (*(out_SPR_WRITE_STATUS_VAL        [i][j])) (*( in_SPR_WRITE_REGISTERFILE_ACK  [i][j]));
    287             if (_param->_have_port_ooo_engine_id == true)
    288             (*(out_SPR_WRITE_STATUS_VAL        [i][j])) (*( in_SPR_WRITE_OOO_ENGINE_ID        [j]));
    289440          }
    290441      }
    … …  
    295446    SC_METHOD (genMealy_insert);
    296447    dont_initialize ();
    297     sensitive_neg << *(in_CLOCK);
     448//     sensitive_neg << *(in_CLOCK);
    298449    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    299450      {
    … …  
    331482    SC_METHOD (genMealy_retire);
    332483    dont_initialize ();
    333     sensitive_neg << *(in_CLOCK);
     484//     sensitive_neg << *(in_CLOCK);
    334485    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    335486      {
    … …  
    416567}; // end namespace behavioural
    417568}; // end namespace morpheo             
     569
     570
     571

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read.cpp

    r60 r61  
    2828      {
    2929        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
    3130        Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
    3231        Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
    … …  
    3635        PORT_WRITE(out_GPR_READ_DATA     [j], PORT_READ(in_GPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
    3736        PORT_WRITE(out_GPR_READ_DATA_VAL [j], PORT_READ(in_GPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
    38    
    39         Tcontrol_t registerfile_val = val and registerfile_ack;
    40         Tcontrol_t status_val       = val and status_ack;
    41 
    42         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    43           {
    44             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    45             PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j], (id and status_val));
    46             PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], (id and registerfile_val));
    47           }
    4837      }
    4938

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_write.cpp

    r60 r61  
    2828      {
    2929        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
    3130        Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
    3231        Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
    … …  
    3433        // multiplexor
    3534        PORT_WRITE(out_GPR_WRITE_ACK [j],registerfile_ack and status_ack);
    36 
    37         Tcontrol_t registerfile_val = val and registerfile_ack;
    38         Tcontrol_t status_val       = val and status_ack;
    39        
    40         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    41           {
    42             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    43             PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], (id and status_val));
    44             PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], (id and registerfile_val));
    45           }
    4635      }
    4736

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read.cpp

    r60 r61  
    2727    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
    2828      {
    29         Tcontext_t ooo_engine_id;
    30        
    31         if (_param->_have_port_ooo_engine_id == true)
    32           ooo_engine_id = PORT_READ(in_SPR_READ_OOO_ENGINE_ID        [j]);
    33         else
    34           ooo_engine_id = 0;
    35 
     29        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
    3630        Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
    3731        Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
    … …  
    4135        PORT_WRITE(out_SPR_READ_DATA     [j], PORT_READ(in_SPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
    4236        PORT_WRITE(out_SPR_READ_DATA_VAL [j], PORT_READ(in_SPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
    43    
    44         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    45           {
    46             Tcontrol_t registerfile_val;
    47             Tcontrol_t status_val;
    48             if (i == ooo_engine_id)
    49               {
    50                 registerfile_val = PORT_READ(in_SPR_READ_VAL [j]);
    51                 status_val       = PORT_READ(in_SPR_READ_VAL [j]);
    52               }
    53             else
    54               {
    55                 registerfile_val = 0;
    56                 status_val       = 0;
    57               }
    58            
    59             PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL  [i][j], registerfile_val and status_ack      );
    60             PORT_WRITE(out_SPR_READ_STATUS_VAL        [i][j], status_val       and registerfile_ack);
    61           }
    6237      }
    6338

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_write.cpp

    r60 r61  
    2727    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
    2828      {
    29         Tcontext_t ooo_engine_id;
    30         if (_param->_have_port_ooo_engine_id == true)
    31           ooo_engine_id = PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID        [j]);
    32         else
    33           ooo_engine_id = 0;
    34 
     29        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
    3530        Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
    3631        Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
    3732
    3833        // multiplexor
    39         PORT_WRITE(out_SPR_WRITE_ACK      [j],registerfile_ack and status_ack);
    40 
    41         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    42           {
    43             Tcontrol_t registerfile_val;
    44             Tcontrol_t status_val;
    45             if (i == ooo_engine_id)
    46               {
    47                 registerfile_val = PORT_READ(in_SPR_WRITE_VAL [j]);
    48                 status_val       = PORT_READ(in_SPR_WRITE_VAL [j]);
    49               }
    50             else
    51               {
    52                 registerfile_val = 0;
    53                 status_val       = 0;
    54               }
    55            
    56             PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL  [i][j], registerfile_val and status_ack      );
    57             PORT_WRITE(out_SPR_WRITE_STATUS_VAL        [i][j], status_val       and registerfile_ack);
    58           }
     34        PORT_WRITE(out_SPR_WRITE_ACK [j],registerfile_ack and status_ack);
    5935      }
    6036
Note: See TracChangeset for help on using the changeset viewer.