Ignore:
Timestamp:
Jun 7, 2007, 9:13:47 PM (17 years ago)
Author:
rosiere
Message:

Vhdl_Testbench : Modification du testbench. Maintenant complétement encapsuler dans la classe "Interfaces".
Suppression de la class Vhdl_Testbench dans un avenir proche :D
Suppression du répertoire Configuration.old

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural
Files:
21 added
3 deleted
62 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/include/RegisterFile_Monolithic.h

    r15 r41  
    2323#include "Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/include/Statistics.h"
    2424#endif
     25#ifdef POSITION
     26#include "Behavioural/include/Position.h"
     27#else
     28#include "Behavioural/include/Interfaces.h"
     29#endif
    2530#ifdef VHDL
    2631#include "Behavioural/include/Vhdl.h"
    27 #endif
    28 #ifdef VHDL_TESTBENCH
    29 #include "Behavioural/include/Vhdl_Testbench.h"
    3032#endif
    3133
    … …  
    5557#endif
    5658
    57 #ifdef VHDL_TESTBENCH
    58   private   : Vhdl_Testbench                 * _vhdl_testbench;
     59#ifdef POSITION
     60  private   : Position                       * _position;
    5961#endif
     62
     63  private   : Interfaces                     * _interfaces;
    6064
    6165#ifdef SYSTEMC
    … …  
    6367    // Interface
    6468  public    : SC_CLOCK                      *  in_CLOCK        ;
    65   public    : SC_CLOCK                      *  in_NRESET       ;
     69  public    : SC_IN       (Tcontrol_t)      *  in_NRESET       ;
    6670
    6771    // ----- Interface Read
    … …  
    117121#if VHDL                                       
    118122  private : void     vhdl                      (void);
    119   private : void     vhdl_port                 (Vhdl & vhdl);
    120   private : void     vhdl_type                 (Vhdl & vhdl);
    121   private : void     vhdl_signal               (Vhdl & vhdl);
    122   private : void     vhdl_body                 (Vhdl & vhdl);
     123  private : void     vhdl_port                 (Vhdl * & vhdl);
     124  private : void     vhdl_type                 (Vhdl * & vhdl);
     125  private : void     vhdl_signal               (Vhdl * & vhdl);
     126  private : void     vhdl_body                 (Vhdl * & vhdl);
    123127#endif                                         
    124128                                               
    125129#ifdef VHDL_TESTBENCH                         
    126   private : void     vhdl_testbench            (Vhdl_Testbench & vhdl_testbench);
    127   private : void     vhdl_testbench_port       (Vhdl_Testbench & vhdl_testbench);
    128   private : void     vhdl_testbench_transition (Vhdl_Testbench & vhdl_testbench);
     130  private : void     vhdl_testbench_transition (void);
    129131#endif
    130132

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic.cpp

    r15 r41  
    2727    _param (param)
    2828  {
     29    log_printf(FUNC,RegisterFile_Monolithic,"RegisterFile_Monolithic","Begin");
     30
     31#ifdef SYSTEMC
     32    log_printf(INFO,RegisterFile_Monolithic,"RegisterFile_Monolithic","Allocation");
     33
     34    allocation ();
     35#endif
     36
    2937#ifdef STATISTICS
    3038    _stat = new Statistics (static_cast<string>(_name),
    3139                            param_statistics          ,
    3240                            param);
    33 #endif
    34 
    35 #ifdef VHDL_TESTBENCH
    36     _vhdl_testbench = new Vhdl_Testbench (_name);
    37     vhdl_testbench_port           (*_vhdl_testbench);
    38     _vhdl_testbench->set_clock    ("in_CLOCK",true);
    3941#endif
    4042
    … …  
    4547
    4648#ifdef SYSTEMC
    47     allocation ();
    48 
    4949    SC_METHOD (transition);
    5050    dont_initialize ();
    … …  
    7272      PORT_WRITE(out_WRITE_ACK [i], 1);
    7373#endif
     74
     75    log_printf(FUNC,RegisterFile_Monolithic,"RegisterFile_Monolithic","End");
    7476  };
    7577 
    7678  RegisterFile_Monolithic::~RegisterFile_Monolithic (void)
    7779  {
    78 #ifdef SYSTEMC
    79     deallocation ();
    80 #endif
    81 
    82 #ifdef VHDL_TESTBENCH
    83     // generate the test bench
    84     _vhdl_testbench->generate_file();
    85     delete _vhdl_testbench;
    86 #endif
    87 
    8880#ifdef STATISTICS
    8981    _stat->generate_file(statistics(0));
    9082    delete _stat;
     83#endif
     84
     85#ifdef SYSTEMC
     86    deallocation ();
    9187#endif
    9288  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_allocation.cpp

    r15 r41  
    1717  void RegisterFile_Monolithic::allocation (void)
    1818  {
    19     in_CLOCK  = new SC_CLOCK           ("in_CLOCK");
    20     in_NRESET = new SC_IN (Tcontrol_t) ("in_NRESET");
     19#ifdef POSITION
     20    _position   = new Position ();
    2121
    22     // ----- Interface Read
     22    Entity * entity = _position->set_entity (_name                    ,
     23                                             "RegisterFile_Monolithic",
     24                                             REGISTER                 );
     25   
     26    _interfaces = entity->set_interfaces();
     27#else
     28    _interfaces = new Interfaces();
     29#endif
     30
     31    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     32    Interface * interface_ = _interfaces->set_interface("", IN  ,SOUTH, "Generalist interface");
     33
     34     in_CLOCK              = interface_->set_signal_clk              ("clock" ,1);
     35     in_NRESET             = interface_->set_signal_in  <Tcontrol_t> ("nreset",1);
     36
     37    // ~~~~~[ Interface : "read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     38
    2339     in_READ_VAL         = new SC_IN (Tcontrol_t) * [_param._nb_port_read];
    2440    out_READ_ACK         = new SC_OUT(Tcontrol_t) * [_param._nb_port_read];
    … …  
    2743
    2844    for (uint32_t i=0; i<_param._nb_port_read; i++)
    29       {
    30         string rename;
     45      { 
     46        Interface_fifo * interface_read = _interfaces->set_interface("read_"+toString(i), IN  ,WEST, "Interface Read");
    3147
    32         rename = "in_READ_VAL["     + toString(i) + "]";
    33         in_READ_VAL     [i]  = new SC_IN (Tcontrol_t) (rename.c_str());
    34 
    35         rename = "out_READ_ACK["     + toString(i) + "]";
    36         out_READ_ACK    [i]  = new SC_OUT(Tcontrol_t) (rename.c_str());
    37 
    38         rename = "in_READ_ADDRESS[" + toString(i) + "]";
    39         in_READ_ADDRESS [i]  = new SC_IN (Taddress_t) (rename.c_str());
    40 
    41         rename = "out_READ_DATA["    + toString(i) + "]";
    42         out_READ_DATA   [i]  = new SC_OUT(Tdata_t)    (rename.c_str());
     48         in_READ_VAL     [i]  = interface_read->set_signal_valack_in        ("val"    , VAL);
     49        out_READ_ACK     [i]  = interface_read->set_signal_valack_out       ("ack"    , ACK);
     50         in_READ_ADDRESS [i]  = interface_read->set_signal_in  <Taddress_t> ("address", static_cast<uint32_t>(log2(_param._nb_word)));
     51        out_READ_DATA    [i]  = interface_read->set_signal_out <Tdata_t   > ("data"   , _param._size_word);
    4352      }
    4453
    45     // ----- Interface Write
     54    // ~~~~~[ Interface : "write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     55
    4656     in_WRITE_VAL        = new SC_IN (Tcontrol_t) * [_param._nb_port_write];
    4757    out_WRITE_ACK        = new SC_OUT(Tcontrol_t) * [_param._nb_port_write];
    … …  
    5161    for (uint32_t i=0; i<_param._nb_port_write; i++)
    5262      {
    53         string rename;
     63        Interface_fifo * interface_write = _interfaces->set_interface("write_"+toString(i), IN  ,EAST, "Interface Write");
    5464
    55         rename = "in_WRITE_VAL["  + toString(i) + "]";
    56         in_WRITE_VAL     [i]  = new SC_IN (Tcontrol_t) (rename.c_str());
    57 
    58         rename = "out_WRITE_VAL["  + toString(i) + "]";
    59         out_WRITE_ACK    [i]  = new SC_OUT(Tcontrol_t) (rename.c_str());
    60 
    61         rename = "in_WRITE_ADDRESS[" + toString(i) + "]";
    62         in_WRITE_ADDRESS [i]  = new SC_IN (Taddress_t) (rename.c_str());
    63 
    64         rename = "in_WRITE_DATA["    + toString(i) + "]";
    65         in_WRITE_DATA    [i]  = new SC_IN (Tdata_t)    (rename.c_str());
     65         in_WRITE_VAL     [i]  = interface_write->set_signal_valack_in        ("val"    , VAL);
     66        out_WRITE_ACK     [i]  = interface_write->set_signal_valack_out       ("ack"    , ACK);
     67         in_WRITE_ADDRESS [i]  = interface_write->set_signal_in  <Taddress_t> ("address", static_cast<uint32_t>(log2(_param._nb_word)));
     68         in_WRITE_DATA    [i]  = interface_write->set_signal_in  <Tdata_t   > ("data"   , _param._size_word);
    6669      }
    6770
    … …  
    7376        string rename = "reg_DATA["  + toString(i) + "]";
    7477        reg_DATA [i]  = new SC_REGISTER (Tdata_t) (rename.c_str());
    75       }   
     78      }
     79
     80#ifdef POSITION
     81    _position->generate_file();
     82#endif
    7683  };
    7784

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_deallocation.cpp

    r15 r41  
    1717  void RegisterFile_Monolithic::deallocation (void)
    1818  {
    19     delete in_CLOCK;
    20     delete in_NRESET;
     19    delete    in_CLOCK;
     20    delete    in_NRESET;
    2121    // ----- Interface Read
    22     for (uint32_t i=0; i<_param._nb_port_read; i++)
    23       {
    24         delete  in_READ_VAL     [i];
    25         delete out_READ_ACK     [i];
    26         delete  in_READ_ADDRESS [i];
    27         delete out_READ_DATA    [i];
    28       }
    29 
    30     delete  in_READ_VAL    ;
    31     delete out_READ_ACK    ;
    32     delete  in_READ_ADDRESS;
    33     delete out_READ_DATA   ;
     22    delete []  in_READ_VAL    ;
     23    delete [] out_READ_ACK    ;
     24    delete []  in_READ_ADDRESS;
     25    delete [] out_READ_DATA   ;
    3426
    3527    // ----- Interface Write
    36     for (uint32_t i=0; i<_param._nb_port_write; i++)
    37       {
    38         delete  in_WRITE_VAL     [i];
    39         delete out_WRITE_ACK     [i];
    40         delete  in_WRITE_ADDRESS [i];
    41         delete  in_WRITE_DATA    [i];
    42       }
    43 
    44     delete  in_WRITE_VAL    ;
    45     delete out_WRITE_ACK    ;
    46     delete  in_WRITE_ADDRESS;
    47     delete  in_WRITE_DATA   ;
     28    delete []  in_WRITE_VAL    ;
     29    delete [] out_WRITE_ACK    ;
     30    delete []  in_WRITE_ADDRESS;
     31    delete []  in_WRITE_DATA   ;
    4832
    4933    // ----- Register
    50     for (uint32_t i=0; i<_param._nb_word; i++)
    51       {
    52         delete reg_DATA [i];
    53       }   
     34    delete [] reg_DATA;
    5435
    55     delete reg_DATA;
     36#ifdef POSITION
     37    delete _position;
     38#else
     39    delete _interfaces;
     40#endif
    5641  };
    5742

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_transition.cpp

    r15 r41  
    4545
    4646#ifdef VHDL_TESTBENCH
    47     vhdl_testbench_transition (*_vhdl_testbench);
     47    vhdl_testbench_transition ();
    4848#endif
    4949    log_printf(FUNC,Register_File,"transition","End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_vhdl.cpp

    r15 r41  
    1818  void RegisterFile_Monolithic::vhdl (void)
    1919  {
    20     Vhdl vhdl (_name);
     20    Vhdl * vhdl = new Vhdl (_name);
    2121
    22     vhdl.set_library_work (_name + "_Pack");
     22    vhdl->set_library_work (_name + "_Pack");
    2323
    2424    vhdl_port   (vhdl);
    … …  
    2727    vhdl_body   (vhdl);
    2828
    29     vhdl.generate_file();
     29    vhdl->generate_file();
     30
     31    delete vhdl;
    3032  };
    3133

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_vhdl_body.cpp

    r15 r41  
    1515namespace registerfile_monolithic    {
    1616
    17   void RegisterFile_Monolithic::vhdl_body (Vhdl & vhdl)
     17  void RegisterFile_Monolithic::vhdl_body (Vhdl * & vhdl)
    1818  {
    19     vhdl.set_body ("");
    20     vhdl.set_body ("-----------------------------------------------------------------------------");
    21     vhdl.set_body ("-- Read RegisterFile");
    22     vhdl.set_body ("-----------------------------------------------------------------------------");
    23     vhdl.set_body ("");
     19    vhdl->set_body ("");
     20    vhdl->set_body ("-----------------------------------------------------------------------------");
     21    vhdl->set_body ("-- Read RegisterFile");
     22    vhdl->set_body ("-----------------------------------------------------------------------------");
     23    vhdl->set_body ("");
    2424   
    2525    for (uint32_t i = 0; i < _param._nb_port_read; i++)
    2626      {
    27         vhdl.set_body ("out_READ_ACK_"+toString(i)+"  <= '1';");
    28         vhdl.set_body ("out_READ_DATA_"+toString(i)+" <= reg_DATA (conv_integer(in_READ_ADDRESS_"+toString(i)+")) when in_READ_VAL_"+toString(i)+" = '1' else "+std_logic_others(_param._size_word,0)+";");
     27        vhdl->set_body ("out_READ_"+toString(i)+"_ACK  <= '1';");
     28        vhdl->set_body ("out_READ_"+toString(i)+"_DATA <= reg_DATA (conv_integer(in_READ_"+toString(i)+"_ADDRESS)) when in_READ_"+toString(i)+"_VAL = '1' else "+std_logic_others(_param._size_word,0)+";");
    2929      }
    30     vhdl.set_body ("");
    31     vhdl.set_body ("-----------------------------------------------------------------------------");
    32     vhdl.set_body ("-- Write RegisterFile");
    33     vhdl.set_body ("-----------------------------------------------------------------------------");
    34     vhdl.set_body ("");
    3530
    36     vhdl.set_body ("RegisterFile_write: process (in_CLOCK)");
    37     vhdl.set_body ("begin  -- process RegisterFile_write");
    38     vhdl.set_body ("\tif in_CLOCK'event and in_CLOCK = '1' then");
     31    vhdl->set_body ("");
     32    vhdl->set_body ("-----------------------------------------------------------------------------");
     33    vhdl->set_body ("-- Write RegisterFile");
     34    vhdl->set_body ("-----------------------------------------------------------------------------");
     35    vhdl->set_body ("");
     36
     37    vhdl->set_body ("RegisterFile_write: process (in_CLOCK)");
     38    vhdl->set_body ("begin  -- process RegisterFile_write");
     39    vhdl->set_body ("\tif in_CLOCK'event and in_CLOCK = '1' then");
    3940   
    4041    for (uint32_t i = 0; i < _param._nb_port_write; i++)
    4142      {
    42       vhdl.set_body ("\t\tif (in_WRITE_VAL_"+toString(i)+" = '1') then");
    43       vhdl.set_body ("\t\t\treg_DATA(conv_integer(in_WRITE_ADDRESS_"+toString(i)+")) <= in_WRITE_DATA_"+toString(i)+";");
    44       vhdl.set_body ("\t\tend if;");
     43      vhdl->set_body ("\t\tif (in_WRITE_"+toString(i)+"_VAL = '1') then");
     44      vhdl->set_body ("\t\t\treg_DATA(conv_integer(in_WRITE_"+toString(i)+"_ADDRESS)) <= in_WRITE_"+toString(i)+"_DATA;");
     45      vhdl->set_body ("\t\tend if;");
    4546      }
    4647
    47     vhdl.set_body ("\tend if;");
    48     vhdl.set_body ("end process RegisterFile_write;");
     48    vhdl->set_body ("\tend if;");
     49    vhdl->set_body ("end process RegisterFile_write;");
    4950
    5051    for (uint32_t i = 0; i < _param._nb_port_write; i++)
    51       vhdl.set_body ("out_WRITE_ACK_"+toString(i)+"<= '1';");
     52      vhdl->set_body ("out_WRITE_"+toString(i)+"_ACK <= '1';");
    5253  };
    5354

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_vhdl_port.cpp

    r15 r41  
    1515namespace registerfile_monolithic    {
    1616
    17   void RegisterFile_Monolithic::vhdl_port (Vhdl & vhdl)
     17  void RegisterFile_Monolithic::vhdl_port (Vhdl * & vhdl)
    1818  {
    19     vhdl.set_port ("in_CLOCK" , IN, 1);
    20     vhdl.set_port ("in_NRESET", IN, 1);
    21 
    22     for (uint32_t i = 0; i < _param._nb_port_read; i ++)
    23       {
    24         vhdl.set_port (" in_READ_VAL_"+toString(i)+"    ",IN ,std_logic(1)                    );
    25         vhdl.set_port ("out_READ_ACK_"+toString(i)+"    ",OUT,std_logic(1)                    );
    26         vhdl.set_port (" in_READ_ADDRESS_"+toString(i)+"",IN ,std_logic(static_cast<uint32_t>(log2(_param._nb_word))));
    27         vhdl.set_port ("out_READ_DATA_"+toString(i)+"   ",OUT,std_logic(_param._size_word    ));
    28       }
    29 
    30     for (uint32_t i = 0; i < _param._nb_port_write; i ++)
    31       {
    32         vhdl.set_port (" in_WRITE_VAL_"+toString(i)+"    ",IN ,std_logic(1)                    );
    33         vhdl.set_port ("out_WRITE_ACK_"+toString(i)+"    ",OUT,std_logic(1)                    );
    34         vhdl.set_port (" in_WRITE_ADDRESS_"+toString(i)+"",IN ,std_logic(static_cast<uint32_t>(log2(_param._nb_word))));
    35         vhdl.set_port (" in_WRITE_DATA_"+toString(i)+"   ",IN ,std_logic(_param._size_word    ));
    36       }
     19    _interfaces->set_port(vhdl);
    3720  };
    3821

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_vhdl_signal.cpp

    r15 r41  
    1515namespace registerfile_monolithic    {
    1616
    17   void RegisterFile_Monolithic::vhdl_signal (Vhdl & vhdl)
     17  void RegisterFile_Monolithic::vhdl_signal (Vhdl * & vhdl)
    1818  {
    19     vhdl.set_signal ("reg_DATA", "Tregfile");
     19    vhdl->set_signal ("reg_DATA", "Tregfile");
    2020  };
    2121

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_vhdl_testbench_transition.cpp

    r15 r41  
    1515namespace registerfile_monolithic    {
    1616
    17   void RegisterFile_Monolithic::vhdl_testbench_transition (Vhdl_Testbench & vhdl_testbench)
     17  void RegisterFile_Monolithic::vhdl_testbench_transition (void)
    1818  {
    19 #ifndef SYSTEMCASS_SPECIFIC
    20     sc_cycle(0);
    21 #endif
    22     vhdl_testbench.add_input (PORT_READ( in_NRESET));
     19    // Evaluation before read the ouput signal
     20    sc_start(0);
    2321
    24     for (uint32_t i = 0; i < _param._nb_port_read ; i ++)
    25       {
    26         vhdl_testbench.add_input (PORT_READ( in_READ_VAL     [i]));
    27         vhdl_testbench.add_output(PORT_READ(out_READ_ACK     [i]));
    28         vhdl_testbench.add_input (PORT_READ( in_READ_ADDRESS [i]));
    29         vhdl_testbench.add_output(PORT_READ(out_READ_DATA    [i]));
    30       }
    31     for (uint32_t i = 0; i < _param._nb_port_write; i ++)
    32       {
    33         vhdl_testbench.add_input (PORT_READ( in_WRITE_VAL    [i]));
    34         vhdl_testbench.add_output(PORT_READ(out_WRITE_ACK    [i]));
    35         vhdl_testbench.add_input (PORT_READ( in_WRITE_ADDRESS[i]));
    36         vhdl_testbench.add_input (PORT_READ( in_WRITE_DATA   [i]));
    37       }
    38 
    39     vhdl_testbench.add_test(true);
    40 
    41     vhdl_testbench.new_cycle (); // always at the end
     22    _interfaces->testbench();
    4223  };
    4324

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_vhdl_type.cpp

    r15 r41  
    1515namespace registerfile_monolithic    {
    1616
    17   void RegisterFile_Monolithic::vhdl_type (Vhdl & vhdl)
     17  void RegisterFile_Monolithic::vhdl_type (Vhdl * & vhdl)
    1818  {
    19     vhdl.set_type ("Tregfile", "array (" + toString(_param._nb_word-1) + " downto 0) of " + std_logic(_param._size_word));
     19    vhdl->set_type ("Tregfile", "array (" + toString(_param._nb_word-1) + " downto 0) of " + std_logic(_param._size_word));
    2020  };
    2121

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/SelfTest/src/test.cpp

    r40 r41  
    9090 
    9191  sc_start(0);
    92 //_Select_Priority_Fixed->vhdl_testbench_label("Initialisation");
    9392//cout << "{"+toString(static_cast<uint32_t>(sc_simulation_time()))+"} Initialisation" << endl;
    9493
    95   _Select_Priority_Fixed->vhdl_testbench_label("Loop of Test");
    9694  cout << "{"+toString(static_cast<uint32_t>(sc_simulation_time()))+"} Loop of Test" << endl;
    9795
    9896  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
    9997    {
    100       _Select_Priority_Fixed->vhdl_testbench_label("Iteration "+toString(iteration));
    101 
    10298      entity    = 0;
    10399      bool find = false;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/include/Select_Priority_Fixed.h

    r40 r41  
    3030#include "Behavioural/include/Vhdl.h"
    3131#endif
    32 #ifdef VHDL_TESTBENCH
    33 #include "Behavioural/include/Vhdl_Testbench.h"
    34 #endif
    3532
    3633using namespace std;
    … …  
    5956#ifdef STATISTICS
    6057  private   : Statistics                     * _stat;
    61 #endif
    62 
    63 #ifdef VHDL_TESTBENCH
    64   private   : Vhdl_Testbench                 * _vhdl_testbench;
    6558#endif
    6659
    … …  
    132125  private : void     vhdl_testbench_transition (void);
    133126#endif
    134   public  : void     vhdl_testbench_label      (string label);
    135127  };
    136128

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed.cpp

    r40 r41  
    4545                            param_statistics          ,
    4646                            param);
    47 #endif
    48 
    49 #ifdef VHDL_TESTBENCH
    50     log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Creation of a testbench");
    51 
    52     _vhdl_testbench = new Vhdl_Testbench (_name);
    5347#endif
    5448
    … …  
    10094    log_printf(FUNC,Select_Priority_Fixed,"~Select_Priority_Fixed","Begin");
    10195
    102 #ifdef VHDL_TESTBENCH
    103     log_printf(INFO,Select_Priority_Fixed,"~Select_Priority_Fixed","Generate Testbench  file");
    104 
    105     // generate the test bench
    106     _vhdl_testbench->generate_file();
    107     delete _vhdl_testbench;
    108 #endif
    109 
    11096#ifdef STATISTICS
    11197    log_printf(INFO,Select_Priority_Fixed,"~Select_Priority_Fixed","Generate Statistics file");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_allocation.cpp

    r40 r41  
    1717  void Select_Priority_Fixed::allocation (void)
    1818  {
    19     string rename;
    20 
    2119    log_printf(FUNC,Select_Priority_Fixed,"allocation","Begin");
    2220
    … …  
    2725                                             "Select_Priority_Fixed",
    2826                                             COMBINATORY            );
    29 
     27   
    3028    _interfaces = entity->set_interfaces();
    3129#else
    … …  
    3735    Interface_fifo * interface_ = _interfaces->set_interface("", IN  ,WEST, "Generalist interface");
    3836
    39      in_CLOCK        = interface_->set_signal_clk              ("clock" ,1, PORT_VHDL_YES_TESTBENCH_NO);
     37     in_CLOCK        = interface_->set_signal_clk              ("clock" ,1, CLOCK_VHDL_NO);
    4038     in_NRESET       = interface_->set_signal_in  <Tcontrol_t> ("nreset",1);
    4139     in_VAL          = new SC_IN (Tcontrol_t)           * [_param._nb_entity];

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_deallocation.cpp

    r40 r41  
    3434    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    3535
    36     cout << *_interfaces << endl;
    37 
    3836#ifdef POSITION
    3937    delete _position;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_vhdl_port.cpp

    r40 r41  
    2121    _interfaces->set_port(vhdl);
    2222
    23 #ifdef VHDL_TESTBENCH
    24     _interfaces->set_port(_vhdl_testbench);                     
    25    _vhdl_testbench->set_clock    ("in_CLOCK",true);
    26 #endif   
    27 
    2823   log_printf(FUNC,Select_Priority_Fixed,"vhdl_port","End");
    2924  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_vhdl_testbench_transition.cpp

    r40 r41  
    2323    sc_start(0);
    2424
    25     _interfaces->testbench(_vhdl_testbench);
    26 
    27     // add_test :
    28     //  - True  : the cycle must be compare with the output of systemC
    29     //  - False : no test
    30     _vhdl_testbench->add_test(true);
    31 
    32     _vhdl_testbench->new_cycle (); // always at the end
     25    _interfaces->testbench();
    3326
    3427    log_printf(FUNC,Select_Priority_Fixed,"vhdl_testbench_transition","End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/include/New_Component.h

    r40 r41  
    3030#include "Behavioural/include/Vhdl.h"
    3131#endif
    32 #ifdef VHDL_TESTBENCH
    33 #include "Behavioural/include/Vhdl_Testbench.h"
    34 #endif
    3532
    3633using namespace std;
    … …  
    5653#ifdef STATISTICS
    5754  private   : Statistics                     * _stat;
    58 #endif
    59 
    60 #ifdef VHDL_TESTBENCH
    61   private   : Vhdl_Testbench                 * _vhdl_testbench;
    6255#endif
    6356
    … …  
    122115  private : void     vhdl_testbench_transition (void);
    123116#endif
    124   public  : void     vhdl_testbench_label      (string label);
    125117  };
    126118

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/src/New_Component.cpp

    r40 r41  
    4444#endif
    4545
    46 #ifdef VHDL_TESTBENCH
    47     log_printf(INFO,@COMPONENT,"@COMPONENT","Creation of a testbench");
    48 
    49     _vhdl_testbench = new Vhdl_Testbench (_name);
    50 #endif
    51 
    5246#ifdef VHDL
    5347    // generate the vhdl
    … …  
    7872    log_printf(FUNC,@COMPONENT,"~@COMPONENT","Begin");
    7973
    80 #ifdef VHDL_TESTBENCH
    81     log_printf(INFO,@COMPONENT,"~@COMPONENT","Generate Testbench  file");
    82 
    83     // generate the test bench
    84     _vhdl_testbench->generate_file();
    85     delete _vhdl_testbench;
    86 #endif
    87 
    8874#ifdef STATISTICS
    8975    log_printf(INFO,@COMPONENT,"~@COMPONENT","Generate Statistics file");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/src/New_Component_vhdl_port.cpp

    r40 r41  
    1919    _interfaces->set_port(vhdl);
    2020
    21 #ifdef VHDL_TESTBENCH
    22     _interfaces->set_port(_vhdl_testbench);                     
    23    _vhdl_testbench->set_clock    ("in_CLOCK",true);
    24 #endif   
    25 
    2621    log_printf(FUNC,@COMPONENT,"vhdl_port","End");
    2722  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/src/New_Component_vhdl_testbench_transition.cpp

    r40 r41  
    2020    sc_start(0);
    2121
    22     _interfaces->testbench(_vhdl_testbench);
    23    
    24     // add_test :
    25     //  - True  : the cycle must be compare with the output of systemC
    26     //  - False : no test
    27     _vhdl_testbench->add_test(true);
    28 
    29     _vhdl_testbench->new_cycle (); // always at the end
     22    _interfaces->testbench();
    3023
    3124    log_printf(FUNC,@COMPONENT,"vhdl_testbench_transition","End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Debug_component.h

    r38 r41  
    77#define     DEBUG_Group                                     false
    88#define     DEBUG_Shifter                                   false
    9 #define     DEBUG_Register_File                             false
    10 #define     DEBUG_RegisterFile_Multi_Banked                 false
    11 #define       DEBUG_RegisterFile_Multi_Banked_Glue          false
     9#define     DEBUG_Register_File                             false
     10#define       DEBUG_RegisterFile_Monolithic                 false
     11#define       DEBUG_RegisterFile_Multi_Banked               false
     12#define         DEBUG_RegisterFile_Multi_Banked_Glue        false
    1213#define     DEBUG_Select                                    false
    1314#define       DEBUG_Select_Priority_Fixed                   false

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Direction.h

    r31 r41  
    77namespace behavioural          {
    88
    9 typedef enum { IN, OUT, INOUT } direction_t;
     9typedef enum { IN, OUT } direction_t;
     10  //typedef enum { IN, OUT, INOUT } direction_t;
    1011
    1112}; // end namespace behavioural         
    … …  
    1718      case morpheo::behavioural::IN    : return "in"    ; break;
    1819      case morpheo::behavioural::OUT   : return "out"   ; break;
    19       case morpheo::behavioural::INOUT : return "inout" ; break;
     20//    case morpheo::behavioural::INOUT : return "inout" ; break;
    2021      default    : return ""      ; break;
    2122      }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Interface.h

    r40 r41  
    2121#ifdef VHDL
    2222#include "Behavioural/include/Vhdl.h"
    23 #endif
    24 #ifdef VHDL_TESTBENCH
    25 #include "Behavioural/include/Vhdl_Testbench.h"
    2623#endif
    2724#include "Include/ToString.h"
    … …  
    5350
    5451#ifdef VHDL_TESTBENCH
    55   private   : list<string>        * _list_cycle   ;
     52  private   : uint32_t              _nb_cycle     ;
    5653#endif
    5754   
    … …  
    8077  public    : sc_in_clk *           set_signal_clk       (string          name     ,
    8178                                                          uint32_t        size     ,
    82                                                           presence_port_t presence_port=PORT_VHDL_YES_TESTBENCH_YES)
     79                                                          presence_port_t presence_port=CLOCK_VHDL_YES)
    8380    {
    8481      log_printf(FUNC,Behavioural,"set_signal_clk","Begin");
    8582
    86       Signal * sig = set_signal (name, IN , size, presence_port);
     83      if ((presence_port != CLOCK_VHDL_YES) and
     84          (presence_port != CLOCK_VHDL_NO ))
     85        throw ErrorMorpheo ("Signal \""+name+"\" is a clock, bad presence_port.");
     86
     87      Signal    * sig    = set_signal (name, IN , size, presence_port);
    8788      sc_in_clk * signal = new sc_in_clk (sig->_name.c_str());
    8889
    … …  
    9899    {
    99100      log_printf(FUNC,Behavioural,"set_signal_in","Begin");
     101
     102      if ((presence_port == CLOCK_VHDL_YES) or
     103          (presence_port == CLOCK_VHDL_NO ))
     104        throw ErrorMorpheo ("Signal \""+name+"\" is not a clock, bad presence_port.");
    100105
    101106      Signal * sig = set_signal (name, IN , size, presence_port);
    … …  
    117122      log_printf(FUNC,Behavioural,"set_signal_out","Begin");
    118123
     124      if ((presence_port == CLOCK_VHDL_YES) or
     125          (presence_port == CLOCK_VHDL_NO ))
     126        throw ErrorMorpheo ("Signal \""+name+"\" is not a clock, bad presence_port.");
     127
    119128      Signal * sig = set_signal (name, OUT , size, presence_port);
    120129      sc_out <T> * port = new sc_out <T> (sig->_name.c_str());
    … …  
    131140#ifdef VHDL
    132141  public    : void                  set_port             (Vhdl * & vhdl);
     142#ifdef VHDL_TESTBENCH
     143  public    : void                  set_signal           (Vhdl * & vhdl);
     144  public    : void                  get_signal           (list<string> * & list_signal);
     145#endif
    133146#endif
    134147#ifdef VHDL_TESTBENCH
    135   public    : void                  set_port             (Vhdl_Testbench * & vhdl_testbench);
     148  public    : uint32_t              get_cycle            (void);
     149  public    : string                get_clock            (void);
     150
     151  public    : void                  testbench            (void);
     152  public    : void                  testbench_cycle      (void);
     153  public    : void                  testbench_body       (Vhdl           * & vhdl          ,
     154                                                          string             counter_name  );
     155  public    : string                testbench_test       (Vhdl           * & vhdl        ,
     156                                                          string             counter_name);
     157  public    : string                testbench_test_ok    (Vhdl           * & vhdl        );
     158  protected : string                testbench_test_name   (Vhdl           * & vhdl);
     159  protected : string                testbench_test_ok_name(Vhdl           * & vhdl);
     160
    136161#endif
    137162
    … …  
    139164  public    : void                  port_map             (void * entity,
    140165                                                          void * interface);
    141 #endif
    142 
    143 #ifdef VHDL_TESTBENCH
    144   public    : void                  testbench_cycle      (void);
    145   public    : void                  testbench            (Vhdl_Testbench * & vhdl_testbench);
    146166#endif
    147167

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Interface_fifo.h

    r40 r41  
    2323#ifdef VHDL_TESTBENCH
    2424  private   : bool                  _test_exhaustive;
     25  private   : list<uint32_t>      * _list_cycle   ;
     26
    2527#endif
    2628
    … …  
    7274
    7375#ifdef VHDL_TESTBENCH
     76  public    : uint32_t              get_cycle            (void);
     77
     78  public    : void                  testbench            (void);
    7479  public    : bool                  testbench_transaction(void);
    75   public    : void                  testbench            (Vhdl_Testbench * & vhdl_testbench);
     80  public    : void                  testbench_cycle      (void);
     81  public    : string                testbench_test       (Vhdl           * & vhdl        ,
     82                                                          string             counter_name);
    7683#endif
    7784  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Interfaces.h

    r40 r41  
    1818#include "Behavioural/include/Vhdl.h"
    1919#endif
    20 #ifdef VHDL_TESTBENCH
    21 #include "Behavioural/include/Vhdl_Testbench.h"
    22 #endif
    2320
    2421using namespace std;
    … …  
    3027  {
    3128    // -----[ fields ]----------------------------------------------------
     29  private   : const string               _name;
    3230  private   : list<Interface_fifo*>    * _list_interface;
    3331
    3432    // -----[ methods ]---------------------------------------------------
    35   public    :                       Interfaces            (void);
     33  public    :                       Interfaces            (string name);
    3634  public    :                       Interfaces            (const Interfaces & interfaces);
    3735  public    :                       ~Interfaces           ();
    … …  
    4846#ifdef VHDL
    4947  public    : void                  set_port              (Vhdl           * & vhdl          );
     48#  ifdef VHDL_TESTBENCH
     49  private   : void                  get_signal            (list<string>   * & list_signal   );
     50  private   : void                  set_signal            (Vhdl           * & vhdl          );
     51#  endif
    5052#endif
    5153#ifdef VHDL_TESTBENCH
    52   public    : void                  set_port              (Vhdl_Testbench * & vhdl_testbench);
     54  private   : uint32_t              get_cycle             (void);
     55  private   : string                get_clock             (void);
     56
     57  private   : void                  testbench_generate_file (void);
     58  public    : void                  testbench             (void);
     59  private   : string                testbench_body        (Vhdl           * & vhdl          ,
     60                                                           string             counter_name  );
    5361#endif
    5462
    5563  public    : Interface_fifo  *     find_interface        (string name);
    56 
    57 #ifdef VHDL_TESTBENCH
    58   public    : void                  testbench             (Vhdl_Testbench * & vhdl_testbench);
    59 #endif
    6064
    6165  public    : XML                   toXML                 (void);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Signal.h

    r40 r41  
    1616#include <iostream>
    1717
    18 #ifdef VHDL_TESTBENCH
    19 #include "Behavioural/include/Vhdl_Testbench.h"
     18#ifdef VHDL
     19#include "Behavioural/include/Vhdl.h"
    2020#endif
    2121
    … …  
    4242                PORT_VHDL_YES_TESTBENCH_NO ,
    4343                PORT_VHDL_NO_TESTBENCH_YES ,
    44                 PORT_VHDL_NO_TESTBENCH_NO  } presence_port_t;
     44                PORT_VHDL_NO_TESTBENCH_NO  ,
     45                CLOCK_VHDL_YES             ,
     46                CLOCK_VHDL_NO              } presence_port_t;
    4547
    4648  class Signal
    … …  
    109111    }
    110112
    111   public    : void              testbench       (Vhdl_Testbench * & vhdl_testbench);
    112 
    113113  public    : template <typename T>
    114114              void              alloc           (void * port)
    … …  
    136136        _type_info = UNKNOW;
    137137    }
     138
     139  public    : void              testbench        (void);
     140  public    : void              testbench_body   (Vhdl           * & vhdl          ,
     141                                                  string             counter_name  );
     142  public    : void              testbench_test_ok(Vhdl           * & vhdl          );
    138143#endif
    139 
     144#ifdef VHDL
     145  public    : void              set_port        (Vhdl * & vhdl);
     146#  ifdef VHDL_TESTBENCH
     147  public    : string            get_clock       (void);
     148  public    : void              set_signal      (Vhdl * & vhdl);
     149  public    : void              get_name_vhdl   (list<string> * & list_signal);
     150#  endif
     151#endif
    140152  public    : XML               toXML           (void);
    141153

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Vhdl_Testbench.h

    r40 r41  
    3838    };
    3939
    40     // -----[ fields ]----------------------------------------------------
    41   private   : const string     _name       ;
    42   private   : const bool       _exhaustive ;
     40//     // -----[ fields ]----------------------------------------------------
     41//   private   : const string     _name       ;
     42//   private   : const bool       _exhaustive ;
    4343
    44   private   : string           _clock_name ;
    45   private   : uint32_t         _num_cycle  ;
     44//   private   : string           _clock_name ;
     45//   private   : uint32_t         _num_cycle  ;
    4646
    47   private   : uint32_t         _size_input ;
    48   private   : uint32_t         _size_output;
     47//   private   : uint32_t         _size_input ;
     48//   private   : uint32_t         _size_output;
    4949
    50   private   : list<string>     _list_input ;
    51   private   : list<string>     _list_input_cycle;
    52   private   : list<uint32_t>   _list_input_size ;
     50//   private   : list<string>     _list_input ;
     51//   private   : list<string>     _list_input_cycle;
     52//   private   : list<uint32_t>   _list_input_size ;
    5353
    54   private   : list<string>     _list_output;
    55   private   : list<string>     _list_output_cycle;
    56   private   : list<uint32_t>   _list_output_size ;
     54//   private   : list<string>     _list_output;
     55//   private   : list<string>     _list_output_cycle;
     56//   private   : list<uint32_t>   _list_output_size ;
    5757
    58   private   : list<bool>       _list_test;
    59   private   : list<string>     _list_port;
    60   private   : list<label_t>    _list_label;
     58//   private   : list<bool>       _list_test;
     59//   private   : list<string>     _list_port;
     60//   private   : list<label_t>    _list_label;
    6161
    62   private   : list<uint32_t>::iterator   _num_input ;
    63   private   : list<uint32_t>::iterator   _num_output;
     62//   private   : list<uint32_t>::iterator   _num_input ;
     63//   private   : list<uint32_t>::iterator   _num_output;
    6464
    65   private   : Vhdl           * _vhdl;
     65//   private   : Vhdl           * _vhdl;
    6666   
    6767    // -----[ methods ]---------------------------------------------------
    6868  public    :                  Vhdl_Testbench              (string   name,
    69                                                             bool     exhaustive=true);
    70   public    : virtual          ~Vhdl_Testbench             ();
     69                                                            bool     exhaustive=true){};
     70  public    :                  ~Vhdl_Testbench             (){};
    7171                                                           
    72   public    : void             generate_file               (void);
     72  public    : void             generate_file               (void){};
    7373
    7474  public    : void             set_port                    (string      name      ,
    7575                                                            direction_t direction ,
    76                                                             uint32_t    size      );
     76                                                            uint32_t    size      ){};
    7777  public    : void             set_clock                   (string      name      ,
    78                                                             bool        model_have_clock);
    79   public    : void             new_cycle                   (void);
     78                                                            bool        model_have_clock){};
     79  public    : void             new_cycle                   (void){};
    8080
    81   private   : uint32_t         get_input                   (void);
    82   private   : void             set_input                   (void);
    83   public    : void             add_input                   (uint32_t    value     );
     81  private   : uint32_t         get_input                   (void){return 0;};
     82  private   : void             set_input                   (void){};
     83  public    : void             add_input                   (uint32_t    value     ){};
    8484
    85   private   : uint32_t         get_output                  (void);
    86   private   : void             set_output                  (void);
    87   public    : void             add_output                  (uint32_t    value     );
     85  private   : uint32_t         get_output                  (void){return 0;};
     86  private   : void             set_output                  (void){};
     87  public    : void             add_output                  (uint32_t    value     ){};
    8888
    89   private   : uint32_t         get_test                    (void);
    90   public    : void             add_test                    (bool        must_test );
     89  private   : uint32_t         get_test                    (void){return 0;};
     90  public    : void             add_test                    (bool        must_test ){};
    9191
    92   private   : void             get_label                   (void);
    93   public    : void             add_label                   (string      label     );
     92  private   : void             get_label                   (void){};
     93  public    : void             add_label                   (string      label     ){};
    9494
    95   private   : void             generate_process_clock      (uint32_t    counter   );
    96   private   : void             generate_instance           (void);
     95  private   : void             generate_process_clock      (uint32_t    counter   ){};
     96  private   : void             generate_instance           (void){};
    9797  };
    9898

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Entity.cpp

    r38 r41  
    2020  {
    2121    log_printf(FUNC,Behavioural,"Entity","Begin");
    22     _is_map = false;
     22    _interfaces = new Interfaces (name);
     23    _is_map     = false;
    2324    log_printf(FUNC,Behavioural,"Entity","End");
    2425  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Entity_set_interfaces.cpp

    r31 r41  
    1414  Interfaces * Entity::set_interfaces (void)
    1515  {
    16     Interfaces * interfaces = new Interfaces ();
    17 
    18     _interfaces = interfaces;
    19    
    20     return interfaces;
     16    return _interfaces;
    2117  };
    2218

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface.cpp

    r40 r41  
    3030
    3131#ifdef VHDL_TESTBENCH
    32     _list_cycle    = new list<string>;
     32    _nb_cycle      = 0;
    3333#endif
    3434
    … …  
    5050#endif
    5151#ifdef VHDL_TESTBENCH
    52     _list_cycle    = interface._list_cycle;
     52    _nb_cycle      = interface._nb_cycle;
    5353#endif
    5454
    … …  
    7373    delete _list_signal;
    7474
    75 #ifdef VHDL_TESTBENCH
    76     delete _list_cycle ;
    77 #endif
    78 
    7975    log_printf(FUNC,Behavioural,"~Interface","End");
    8076  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo.cpp

    r40 r41  
    2525#ifdef VHDL_TESTBENCH
    2626    _test_exhaustive = true;
     27    _list_cycle      = new list<uint32_t>;
    2728#endif
    2829
    … …  
    4243#ifdef VHDL_TESTBENCH
    4344    _test_exhaustive = interface_fifo._test_exhaustive;
     45    _list_cycle      = interface_fifo._list_cycle;
    4446#endif
    4547
    … …  
    5456    delete _list_signal_ack;
    5557
     58#ifdef VHDL_TESTBENCH
     59    delete _list_cycle;
     60#endif
     61
    5662    log_printf(FUNC,Behavioural,"~Interface_fifo","End");
    5763  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_save_ptr.cpp

    r40 r41  
    1616    log_printf(FUNC,Behavioural,"save_ptr","Begin");
    1717   
     18#ifdef VHDL_TESTBENCH
     19    _test_exhaustive = false;
     20#endif
     21
    1822    if (val_ack == VAL)
    1923      _list_signal_val->push_back (signal);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_set_signal.cpp

    r40 r41  
    1717  {
    1818    log_printf(FUNC,Behavioural,"set_signal_valack","Begin");
    19    
     19
    2020    Signal * sig = Interface::set_signal (name         ,
    2121                                          direction    ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench.cpp

    r40 r41  
    1313namespace behavioural          {
    1414
    15   void Interface_fifo::testbench (Vhdl_Testbench * & vhdl_testbench)
     15  void Interface_fifo::testbench (void)
    1616  {
    1717    log_printf(FUNC,Behavioural,"testbench","Begin");
    … …  
    2020      testbench_cycle ();
    2121   
    22     Interface::testbench(vhdl_testbench);
     22    Interface::testbench_cycle ();
     23    Interface::testbench();
    2324
    2425    log_printf(FUNC,Behavioural,"testbench","End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_get_signal.cpp

    r40 r41  
    5151  };
    5252
     53#ifdef VHDL
     54#  ifdef VHDL_TESTBENCH
     55  void Interface::get_signal (list<string> * & list_signal)
     56  {
     57    if (not _list_signal->empty())
     58      {
     59        list<Signal*>::iterator i = _list_signal->begin();
     60       
     61        while (i != _list_signal->end())
     62          {
     63            (*i)->get_name_vhdl (list_signal);
     64            ++i;
     65          }
     66      }
     67  };
     68#  endif
     69#endif
     70
    5371}; // end namespace behavioural         
    5472}; // end namespace morpheo             

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_print.cpp

    r40 r41  
    2020    output_stream << x.get_signal () << endl;
    2121
    22 #ifdef VHDL_TESTBENCH
    23     if (x._list_cycle->empty()== false)
    24       {
    25         list<string>::iterator i = x._list_cycle->begin();
     22// #ifdef VHDL_TESTBENCH
     23//     if (x._list_cycle->empty()== false)
     24//       {
     25//      list<string>::iterator i = x._list_cycle->begin();
    2626
    27         while (i != x._list_cycle->end())
    28           {
    29             output_stream << "\n\t" << *i ;
    30             ++i;
    31           }
    32       }
    33 #endif
     27//      while (i != x._list_cycle->end())
     28//        {
     29//          output_stream << "\n\t" << *i ;
     30//          ++i;
     31//        }
     32//       }
     33// #endif
    3434
    3535    log_printf(FUNC,Behavioural,"operator<<","End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_set_port.cpp

    r40 r41  
    2222        while (i != _list_signal->end())
    2323          {
    24             presence_port_t p = (*i)->_presence_port;
    25             if ((p == PORT_VHDL_YES_TESTBENCH_YES) or
    26                 (p == PORT_VHDL_YES_TESTBENCH_NO ) )
    27               vhdl->set_port ((*i)->_name,(*i)->_direction,(*i)->_size);
     24            (*i)->set_port (vhdl);
    2825            ++i;
    2926          }
    … …  
    3330#endif
    3431
    35 #ifdef VHDL_TESTBENCH
    36   void Interface::set_port (Vhdl_Testbench * & vhdl_testbench)
    37   {
    38     log_printf(FUNC,Behavioural,"set_port (Testbench)","Begin");
    39     if (not _list_signal->empty())
    40       {
    41         list<Signal*>::iterator i     = _list_signal->begin();
    42        
    43         while (i != _list_signal->end())
    44           {
    45             presence_port_t p = (*i)->_presence_port;
    46             if ((p == PORT_VHDL_YES_TESTBENCH_YES) or
    47                 (p == PORT_VHDL_NO_TESTBENCH_YES ) )
    48               vhdl_testbench->set_port ((*i)->_name,(*i)->_direction,(*i)->_size);
    49             ++i;
    50           }
    51       }
    52     log_printf(FUNC,Behavioural,"set_port (Testbench)","End");
    53   };
    54 #endif
    5532}; // end namespace behavioural         
    5633}; // end namespace morpheo             

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_set_signal.cpp

    r40 r41  
    3232  };
    3333
     34#ifdef VHDL
     35#  ifdef VHDL_TESTBENCH
     36  void Interface::set_signal (Vhdl * & vhdl)
     37  {
     38    if (not _list_signal->empty())
     39      {
     40        list<Signal*>::iterator i = _list_signal->begin();
     41       
     42        while (i != _list_signal->end())
     43          {
     44            (*i)->set_signal (vhdl);
     45            ++i;
     46          }
     47      }
     48  };
     49#  endif
     50#endif
     51
    3452}; // end namespace behavioural         
    3553}; // end namespace morpheo             

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_testbench.cpp

    r40 r41  
    1313namespace behavioural          {
    1414
    15   void Interface::testbench_cycle (void)
    16   {
    17     // note : if defined(VHDL_TESTBENCH) then defined(SYSTEMC)
    18     _list_cycle->push_back(toString(sc_simulation_time()));
    19   }
    20 
    21   void Interface::testbench (Vhdl_Testbench * & vhdl_testbench)
     15  void Interface::testbench (void)
    2216  {
    2317    log_printf(FUNC,Behavioural,"testbench","Begin");
    … …  
    2923        while (i != _list_signal->end())
    3024          {
    31             (*i)->testbench(vhdl_testbench);
     25            (*i)->testbench();
    3226            ++i;
    3327          }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces.cpp

    r40 r41  
    1111namespace behavioural          {
    1212
    13   Interfaces::Interfaces  (void)
     13  Interfaces::Interfaces  (string name):
     14    _name (name)
    1415  {
    1516    log_printf(FUNC,Behavioural,"Interfaces","Begin");
    … …  
    1819  };
    1920
    20   Interfaces::Interfaces  (const Interfaces & interfaces)
     21  Interfaces::Interfaces  (const Interfaces & interfaces) :
     22    _name (interfaces._name)
    2123  {
    2224    log_printf(FUNC,Behavioural,"Interfaces (copy)","Begin");
    … …  
    2830  {
    2931    log_printf(FUNC,Behavioural,"~Interfaces","Begin");
     32
     33#ifdef VHDL_TESTBENCH
     34    testbench_generate_file ();
     35#endif
    3036
    3137    if (_list_interface->empty()== false)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_set_port.cpp

    r40 r41  
    2828#endif
    2929
    30 
    31 #ifdef VHDL_TESTBENCH
    32   void Interfaces::set_port (Vhdl_Testbench * & vhdl_testbench)
    33   {
    34     if (not _list_interface->empty())
    35       {
    36         list<Interface_fifo*>::iterator i     = _list_interface->begin();
    37        
    38         while (i != _list_interface->end())
    39           {
    40             (*i)->set_port (vhdl_testbench);
    41             ++i;
    42           }
    43       }
    44   };
    45 #endif
    46 
    4730}; // end namespace behavioural         
    4831}; // end namespace morpheo             

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_testbench.cpp

    r40 r41  
    1313namespace behavioural          {
    1414
    15   void Interfaces::testbench (Vhdl_Testbench * & vhdl_testbench)
     15  void Interfaces::testbench (void)
    1616  {
    1717    log_printf(FUNC,Behavioural,"testbench","Begin");
    … …  
    2323        while (i != _list_interface->end())
    2424          {
    25             (*i)->testbench(vhdl_testbench);
     25            (*i)->testbench();
    2626            ++i;
    2727          }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_testbench.cpp

    r40 r41  
    1313
    1414  // à optimisé -> pointeur de fonction afin d'éviter le test et le switch
    15   void Signal::testbench (Vhdl_Testbench * & vhdl_testbench)
     15  void Signal::testbench (void)
    1616  {
    1717    log_printf(FUNC,Behavioural,"testbench","Begin");
    1818
    1919    if ((_presence_port == PORT_VHDL_YES_TESTBENCH_YES) or
    20         (_presence_port == PORT_VHDL_NO_TESTBENCH_YES))
     20        (_presence_port == PORT_VHDL_NO_TESTBENCH_YES ))
    2121      {
    2222        string str;
    … …  
    3030              switch (_direction)
    3131                {
    32                 case IN    : {vhdl_testbench->add_input (value);
    33                               str =             toBase2 (value); break;}
    34                 case OUT   : {vhdl_testbench->add_output(value);
    35                               str =             toBase2 (value); break;}
    36                 case INOUT : {break;}
     32                case IN    : {str =             toBase2 (value); break;}
     33                case OUT   : {str =             toBase2 (value); break;}
     34//              case INOUT : {break;}
    3735                }
    3836              break;
    … …  
    4442              switch (_direction)
    4543                {
    46                 case IN    : {vhdl_testbench->add_input (value);
    47                               str =             toBase2 (value,_size); break;}
    48                 case OUT   : {vhdl_testbench->add_output(value);
    49                               str =             toBase2 (value,_size); break;}
    50                 case INOUT : {break;}
     44                case IN    : {str =             toBase2 (value,_size); break;}
     45                case OUT   : {str =             toBase2 (value,_size); break;}
     46//              case INOUT : {break;}
    5147                }
    5248              break;
    … …  
    5854              switch (_direction)
    5955                {
    60                 case IN    : {vhdl_testbench->add_input (value);
    61                               str =             toBase2 (value,_size); break;}
    62                 case OUT   : {vhdl_testbench->add_output(value);
    63                               str =             toBase2 (value,_size); break;}
    64                 case INOUT : {break;}           
     56                case IN    : {str =             toBase2 (value,_size); break;}
     57                case OUT   : {str =             toBase2 (value,_size); break;}
     58//              case INOUT : {break;}           
    6559                }
    6660              break;
    … …  
    7266              switch (_direction)
    7367                {
    74                 case IN    : {vhdl_testbench->add_input (value);
    75                               str =             toBase2 (value,_size); break;}
    76                 case OUT   : {vhdl_testbench->add_output(value);
    77                               str =             toBase2 (value,_size); break;}
    78                 case INOUT : {break;}
     68                case IN    : {str =             toBase2 (value,_size); break;}
     69                case OUT   : {str =             toBase2 (value,_size); break;}
     70//              case INOUT : {break;}
    7971                }
    8072              break;
    … …  
    8678              switch (_direction)
    8779                {
    88                 case IN    : {vhdl_testbench->add_input (value);
    89                               str =             toBase2 (value,_size); break;}
    90                 case OUT   : {vhdl_testbench->add_output(value);
    91                               str =             toBase2 (value,_size); break;}
    92                 case INOUT : {break;}
     80                case IN    : {str =             toBase2 (value,_size); break;}
     81                case OUT   : {str =             toBase2 (value,_size); break;}
     82//              case INOUT : {break;}
    9383                }
    9484              break;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench.cpp

    r40 r41  
    1313namespace behavioural          {
    1414
    15   Vhdl_Testbench::Vhdl_Testbench  (string   name       ,
    16                                    bool     exhaustive ):
    17     _name        (name       ),
    18     _exhaustive  (exhaustive )
    19   {
    20     _vhdl = new Vhdl (_name + "_Testbench");
     15//   Vhdl_Testbench::Vhdl_Testbench  (string   name       ,
     16//                                 bool     exhaustive ):
     17//     _name        (name       ),
     18//     _exhaustive  (exhaustive )
     19//   {
     20//     _vhdl = new Vhdl (_name + "_Testbench");
    2121
    22     _size_input  = 0;
    23     _size_output = 0;
     22//     _size_input  = 0;
     23//     _size_output = 0;
    2424
    25     _num_cycle   = 0;
    26   };
     25//     _num_cycle   = 0;
     26//   };
    2727 
    28   Vhdl_Testbench::~Vhdl_Testbench ()
    29   {
    30     delete _vhdl;
    31   };
     28//   Vhdl_Testbench::~Vhdl_Testbench ()
     29//   {
     30//     delete _vhdl;
     31//   };
    3232 
    3333

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_add_input.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::add_input (uint32_t value)
    19   {
    20     _list_input_cycle.push_front(toBase2(value,*_num_input));
    21     _num_input++;
    22   };
     18//   void Vhdl_Testbench::add_input (uint32_t value)
     19//   {
     20//     _list_input_cycle.push_front(toBase2(value,*_num_input));
     21//     _num_input++;
     22//   };
    2323 
    2424}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_add_label.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::add_label (string label)
    19   {
    20     _list_label.push_back(label_t(_num_cycle,label));
    21   };
     18//   void Vhdl_Testbench::add_label (string label)
     19//   {
     20//     _list_label.push_back(label_t(_num_cycle,label));
     21//   };
    2222 
    2323}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_add_output.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::add_output (uint32_t value)
    19   {
    20     _list_output_cycle.push_front(toBase2(value,*_num_output));
    21     _num_output ++;
    22   };
     18//   void Vhdl_Testbench::add_output (uint32_t value)
     19//   {
     20//     _list_output_cycle.push_front(toBase2(value,*_num_output));
     21//     _num_output ++;
     22//   };
    2323 
    2424}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_add_test.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::add_test (bool must_test)
    19   {
    20     _list_test.push_back(must_test);
    21   };
     18//   void Vhdl_Testbench::add_test (bool must_test)
     19//   {
     20//     _list_test.push_back(must_test);
     21//   };
    2222 
    2323}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_generate_file.cpp

    r2 r41  
    1414namespace behavioural          {
    1515
    16   void Vhdl_Testbench::generate_file (void)
    17   {
    18     _vhdl->set_library_work (_name + "_Pack");
     16//   void Vhdl_Testbench::generate_file (void)
     17//   {
     18//     _vhdl->set_library_work (_name + "_Pack");
    1919
    20     if (_size_input == 0)
    21       throw (ErrorMorpheo ("No input for the test bench."));
    22     if (_size_output == 0)
    23       throw (ErrorMorpheo ("No output for the test bench."));
     20//     if (_size_input == 0)
     21//       throw (ErrorMorpheo ("No input for the test bench."));
     22//     if (_size_output == 0)
     23//       throw (ErrorMorpheo ("No output for the test bench."));
    2424
    25     // Only 2 signals and a variable
    26     _vhdl->set_signal   ("testbench_input"       ,std_logic(_size_input ));
    27     _vhdl->set_signal   ("testbench_output"      ,std_logic(_size_output));
    28     _vhdl->set_signal   ("testbench_test"        ,std_logic(_size_output));
    29     _vhdl->set_signal   ("testbench_must_test"   ,std_logic(1));
    30     _vhdl->set_signal   ("testbench_counter"     ,"natural","0");
     25//     // Only 2 signals and a variable
     26//     _vhdl->set_signal   ("testbench_input"       ,std_logic(_size_input ));
     27//     _vhdl->set_signal   ("testbench_output"      ,std_logic(_size_output));
     28//     _vhdl->set_signal   ("testbench_test"        ,std_logic(_size_output));
     29//     _vhdl->set_signal   ("testbench_must_test"   ,std_logic(1));
     30//     _vhdl->set_signal   ("testbench_counter"     ,"natural","0");
    3131
    32     uint32_t counter = get_input  ();
    33     get_output ();
    34     get_test   ();
    35     get_label  ();
     32//     uint32_t counter = get_input  ();
     33//     get_output ();
     34//     get_test   ();
     35//     get_label  ();
    3636
    37 //     if (counter == get_output ())
    38 //       throw (ErrorMorpheo ("The number of input is different of number of output."));
     37// //     if (counter == get_output ())
     38// //       throw (ErrorMorpheo ("The number of input is different of number of output."));
    3939
    40     generate_instance      ();
    41     generate_process_clock (counter);
     40//     generate_instance      ();
     41//     generate_process_clock (counter);
    4242   
    43     _vhdl->generate_file(false, true);
    44   };
     43//     _vhdl->generate_file(false, true);
     44//   };
    4545
    4646}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_generate_instance.cpp

    r2 r41  
    1313namespace behavioural          {
    1414
    15   void Vhdl_Testbench::generate_instance (void)
    16   {
    17     _vhdl->set_body("");
    18     _vhdl->set_body("instance_"+_name+" : "+_name);
    19     _vhdl->set_body("port map (");
     15//   void Vhdl_Testbench::generate_instance (void)
     16//   {
     17//     _vhdl->set_body("");
     18//     _vhdl->set_body("instance_"+_name+" : "+_name);
     19//     _vhdl->set_body("port map (");
    2020   
    21     list<string>::iterator i   = _list_port.begin();
    22     if (i != _list_port.end())
    23       {
    24         _vhdl->set_body("\t "+*i+"\t=>\t"+*i);
    25         ++i;
    26       }
    27     while (i != _list_port.end())
    28       {
    29         _vhdl->set_body("\t,"+*i+"\t=>\t"+*i);
    30         ++i;
    31       }
    32     _vhdl->set_body("         );");
    33   };
     21//     list<string>::iterator i   = _list_port.begin();
     22//     if (i != _list_port.end())
     23//       {
     24//         _vhdl->set_body("\t "+*i+"\t=>\t"+*i);
     25//         ++i;
     26//       }
     27//     while (i != _list_port.end())
     28//       {
     29//         _vhdl->set_body("\t,"+*i+"\t=>\t"+*i);
     30//         ++i;
     31//       }
     32//     _vhdl->set_body("         );");
     33//   };
    3434
    3535}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_generate_process_clock.cpp

    r2 r41  
    1313namespace behavioural          {
    1414
    15   void Vhdl_Testbench::generate_process_clock (uint32_t counter)
    16   {
    17     _vhdl->set_body("");
    18     _vhdl->set_body(_clock_name+" <= not "+_clock_name+" after 50 ns;");
    19     _vhdl->set_body("testbench_counter <= testbench_counter+1 after 100 ns;");
    20     _vhdl->set_body("");
     15//   void Vhdl_Testbench::generate_process_clock (uint32_t counter)
     16//   {
     17//     _vhdl->set_body("");
     18//     _vhdl->set_body(_clock_name+" <= not "+_clock_name+" after 50 ns;");
     19//     _vhdl->set_body("testbench_counter <= testbench_counter+1 after 100 ns;");
     20//     _vhdl->set_body("");
    2121
    22     _vhdl->set_body("process ("+_clock_name+")");
    23     _vhdl->set_body("begin");
    24     _vhdl->set_body("\tif "+_clock_name+"'event and "+_clock_name+" = '1' then");
    25     _vhdl->set_body("");
    26     _vhdl->set_body("\t\tassert (not ((testbench_must_test = '1') and not (testbench_test = testbench_output)))");
    27     _vhdl->set_body("\t\treport \"   Test KO - output's test is different of output's component\"");
    28     _vhdl->set_body("\t\tseverity FAILURE;");
    29     _vhdl->set_body("");
    30     _vhdl->set_body("\t\tassert (not ((testbench_must_test = '1') and     (testbench_test = testbench_output)))");
    31     _vhdl->set_body("\t\treport \"   Test OK\"");
    32     _vhdl->set_body("\t\tseverity NOTE;");
    33     _vhdl->set_body("");
    34     _vhdl->set_body("\t\tassert (not ( testbench_must_test = '0'))");
    35     _vhdl->set_body("\t\treport \"No Test\"");
    36     _vhdl->set_body("\t\tseverity NOTE;");
    37     _vhdl->set_body("");
    38     _vhdl->set_body("\tend if;");
    39     _vhdl->set_body("end process;");
     22//     _vhdl->set_body("process ("+_clock_name+")");
     23//     _vhdl->set_body("begin");
     24//     _vhdl->set_body("\tif "+_clock_name+"'event and "+_clock_name+" = '1' then");
     25//     _vhdl->set_body("");
     26//     _vhdl->set_body("\t\tassert (not ((testbench_must_test = '1') and not (testbench_test = testbench_output)))");
     27//     _vhdl->set_body("\t\treport \"   Test KO - output's test is different of output's component\"");
     28//     _vhdl->set_body("\t\tseverity FAILURE;");
     29//     _vhdl->set_body("");
     30//     _vhdl->set_body("\t\tassert (not ((testbench_must_test = '1') and     (testbench_test = testbench_output)))");
     31//     _vhdl->set_body("\t\treport \"   Test OK\"");
     32//     _vhdl->set_body("\t\tseverity NOTE;");
     33//     _vhdl->set_body("");
     34//     _vhdl->set_body("\t\tassert (not ( testbench_must_test = '0'))");
     35//     _vhdl->set_body("\t\treport \"No Test\"");
     36//     _vhdl->set_body("\t\tseverity NOTE;");
     37//     _vhdl->set_body("");
     38//     _vhdl->set_body("\tend if;");
     39//     _vhdl->set_body("end process;");
    4040   
    41     _vhdl->set_body("");
    42     _vhdl->set_body("assert (not (testbench_counter = " + toString(counter)+"))");
    43     _vhdl->set_body("report \"End of Simulation\"");
    44     _vhdl->set_body("severity FAILURE;");
    45   };
     41//     _vhdl->set_body("");
     42//     _vhdl->set_body("assert (not (testbench_counter = " + toString(counter)+"))");
     43//     _vhdl->set_body("report \"End of Simulation\"");
     44//     _vhdl->set_body("severity FAILURE;");
     45//   };
    4646
    4747}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_get_input.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   uint32_t Vhdl_Testbench::get_input (void)
    19   {
    20     list<string>::iterator i   = _list_input.begin();
     18//   uint32_t Vhdl_Testbench::get_input (void)
     19//   {
     20//     list<string>::iterator i   = _list_input.begin();
    2121   
    22     uint32_t counter = 0;
     22//     uint32_t counter = 0;
    2323
    24     if (i != _list_input.end())
    25       {
    26         _vhdl->set_body ("");
    27         _vhdl->set_body ("with testbench_counter select");
    28         _vhdl->set_body ("\ttestbench_input <=");
     24//     if (i != _list_input.end())
     25//       {
     26//      _vhdl->set_body ("");
     27//      _vhdl->set_body ("with testbench_counter select");
     28//      _vhdl->set_body ("\ttestbench_input <=");
    2929
    30         while (i != _list_input.end())
    31           {
    32             list<string>::iterator j = i;
    33             ++i;
     30//      while (i != _list_input.end())
     31//        {
     32//          list<string>::iterator j = i;
     33//          ++i;
    3434
    35             if (i != _list_input.end())
    36               _vhdl->set_body ("\t\""+*j+"\" when "+toString(counter++)+",");
    37             else
    38               _vhdl->set_body ("\t\""+*j+"\" when others;");
    39           }
    40       }
     35//          if (i != _list_input.end())
     36//            _vhdl->set_body ("\t\""+*j+"\" when "+toString(counter++)+",");
     37//          else
     38//            _vhdl->set_body ("\t\""+*j+"\" when others;");
     39//        }
     40//       }
    4141
    42     return counter;
    43   };
     42//     return counter;
     43//   };
    4444 
    4545}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_get_label.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::get_label (void)
    19   {
    20     for (list<label_t>::iterator i = _list_label.begin(); i != _list_label.end(); i++)
    21       {
    22         _vhdl->set_body("");
    23         _vhdl->set_body("assert (not (testbench_counter = " + toString(i->_cycle)+"))");
    24         _vhdl->set_body("report \"***** "+i->_label+" *****\"");
    25         _vhdl->set_body("severity NOTE;"); 
    26       }
    27   };
     18//   void Vhdl_Testbench::get_label (void)
     19//   {
     20//     for (list<label_t>::iterator i = _list_label.begin(); i != _list_label.end(); i++)
     21//       {
     22//      _vhdl->set_body("");
     23//      _vhdl->set_body("assert (not (testbench_counter = " + toString(i->_cycle)+"))");
     24//      _vhdl->set_body("report \"***** "+i->_label+" *****\"");
     25//      _vhdl->set_body("severity NOTE;"); 
     26//       }
     27//   };
    2828 
    2929}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_get_output.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   uint32_t Vhdl_Testbench::get_output (void)
    19   {
    20     list<string>::iterator i   = _list_output.begin();
     18//   uint32_t Vhdl_Testbench::get_output (void)
     19//   {
     20//     list<string>::iterator i   = _list_output.begin();
    2121   
    22     uint32_t counter = 0;
     22//     uint32_t counter = 0;
    2323
    24     if (i != _list_output.end())
    25       {
    26         _vhdl->set_body ("");
    27         _vhdl->set_body ("with testbench_counter select");
    28         _vhdl->set_body ("\ttestbench_test <=");
     24//     if (i != _list_output.end())
     25//       {
     26//      _vhdl->set_body ("");
     27//      _vhdl->set_body ("with testbench_counter select");
     28//      _vhdl->set_body ("\ttestbench_test <=");
    2929
    30         while (i != _list_output.end())
    31           {
    32             list<string>::iterator j = i;
    33             ++i;
     30//      while (i != _list_output.end())
     31//        {
     32//          list<string>::iterator j = i;
     33//          ++i;
    3434
    35             if (i != _list_output.end())
    36               _vhdl->set_body ("\t\""+*j+"\" when "+toString(counter++)+",");
    37             else
    38               _vhdl->set_body ("\t\""+*j+"\" when others;");
    39           }
    40       }
     35//          if (i != _list_output.end())
     36//            _vhdl->set_body ("\t\""+*j+"\" when "+toString(counter++)+",");
     37//          else
     38//            _vhdl->set_body ("\t\""+*j+"\" when others;");
     39//        }
     40//       }
    4141
    42     return counter;
    43   };
     42//     return counter;
     43//   };
    4444 
    4545}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_get_test.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   uint32_t Vhdl_Testbench::get_test (void)
    19   {
    20     list<bool>::iterator i   = _list_test.begin();
     18//   uint32_t Vhdl_Testbench::get_test (void)
     19//   {
     20//     list<bool>::iterator i   = _list_test.begin();
    2121   
    22     uint32_t counter = 0;
     22//     uint32_t counter = 0;
    2323
    24     if (i != _list_test.end())
    25       {
    26         _vhdl->set_body ("");
    27         _vhdl->set_body ("with testbench_counter select");
    28         _vhdl->set_body ("\ttestbench_must_test <=");
     24//     if (i != _list_test.end())
     25//       {
     26//      _vhdl->set_body ("");
     27//      _vhdl->set_body ("with testbench_counter select");
     28//      _vhdl->set_body ("\ttestbench_must_test <=");
    2929
    30         while (i != _list_test.end())
    31           {
    32             list<bool>::iterator j = i;
    33             ++i;
     30//      while (i != _list_test.end())
     31//        {
     32//          list<bool>::iterator j = i;
     33//          ++i;
    3434
    35             string str = (*j==true)?"1":"0";
     35//          string str = (*j==true)?"1":"0";
    3636
    37             if (i != _list_test.end())
    38               _vhdl->set_body ("\t'"+str+"' when "+toString(counter++)+",");
    39             else
    40               _vhdl->set_body ("\t'"+str+"' when others;");
    41           }
    42       }
     37//          if (i != _list_test.end())
     38//            _vhdl->set_body ("\t'"+str+"' when "+toString(counter++)+",");
     39//          else
     40//            _vhdl->set_body ("\t'"+str+"' when others;");
     41//        }
     42//       }
    4343
    44     return counter;
    45   };
     44//     return counter;
     45//   };
    4646 
    4747}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_new_cycle.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::new_cycle (void)
    19   {
    20     set_input();
    21     set_output();
     18//   void Vhdl_Testbench::new_cycle (void)
     19//   {
     20//     set_input();
     21//     set_output();
    2222
    23     _num_input   = _list_input_size .begin();
    24     _num_output  = _list_output_size.begin();
     23//     _num_input   = _list_input_size .begin();
     24//     _num_output  = _list_output_size.begin();
    2525
    26     _num_cycle ++;
    27   };
     26//     _num_cycle ++;
     27//   };
    2828 
    2929}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_set_clock.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::set_clock (string name,
    19                                   bool   model_have_clock)
    20   {
    21     _clock_name = name;
    22     _vhdl->set_signal (name,std_logic(1),"'0'");
     18//   void Vhdl_Testbench::set_clock (string name,
     19//                                bool   model_have_clock)
     20//   {
     21//     _clock_name = name;
     22//     _vhdl->set_signal (name,std_logic(1),"'0'");
    2323
    24     if (model_have_clock == true)
    25       _list_port.push_back(name);
     24//     if (model_have_clock == true)
     25//       _list_port.push_back(name);
    2626
    27     _num_input   = _list_input_size .begin();
    28     _num_output  = _list_output_size.begin();
    29   };
     27//     _num_input   = _list_input_size .begin();
     28//     _num_output  = _list_output_size.begin();
     29//   };
    3030 
    3131}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_set_input.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::set_input (void)
    19   {
    20     string text = "";
     18//   void Vhdl_Testbench::set_input (void)
     19//   {
     20//     string text = "";
    2121
    22     while (_list_input_cycle.empty() == false)
    23       {
    24         text += _list_input_cycle.front();
     22//     while (_list_input_cycle.empty() == false)
     23//       {
     24//      text += _list_input_cycle.front();
    2525
    26         _list_input_cycle.pop_front();
    27       }
     26//      _list_input_cycle.pop_front();
     27//       }
    2828
    29     _list_input.push_back(text);
    30   };
     29//     _list_input.push_back(text);
     30//   };
    3131 
    3232}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_set_output.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::set_output (void)
    19   {
    20     string text = "";
     18//   void Vhdl_Testbench::set_output (void)
     19//   {
     20//     string text = "";
    2121
    22     while (_list_output_cycle.empty() == false)
    23       {
    24         text += _list_output_cycle.front();
     22//     while (_list_output_cycle.empty() == false)
     23//       {
     24//      text += _list_output_cycle.front();
    2525
    26         _list_output_cycle.pop_front();
    27       }
     26//      _list_output_cycle.pop_front();
     27//       }
    2828
    29     _list_output.push_back(text);
    30   };
     29//     _list_output.push_back(text);
     30//   };
    3131 
    3232}; // end namespace behavioural         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_Testbench_set_port.cpp

    r2 r41  
    1616namespace behavioural          {
    1717 
    18   void Vhdl_Testbench::set_port (string      name     ,
    19                                  direction_t direction,
    20                                  uint32_t    size     )
    21   {
    22     string   name2;
    23     uint32_t size_old;
    24     if (direction == IN)
    25       {
    26         _list_input_size.push_back(size);
    27         size_old      = _size_input;
    28         _size_input  += size;
    29         name2         = "testbench_input";
    30       }
    31     else
    32       {
    33         _list_output_size.push_back(size);
    34         size_old      = _size_output;
    35         _size_output += size;
    36         name2         = "testbench_output";
    37       }
     18//   void Vhdl_Testbench::set_port (string      name     ,
     19//                               direction_t direction,
     20//                               uint32_t    size     )
     21//   {
     22//     string   name2;
     23//     uint32_t size_old;
     24//     if (direction == IN)
     25//       {
     26//      _list_input_size.push_back(size);
     27//      size_old      = _size_input;
     28//      _size_input  += size;
     29//      name2         = "testbench_input";
     30//       }
     31//     else
     32//       {
     33//      _list_output_size.push_back(size);
     34//      size_old      = _size_output;
     35//      _size_output += size;
     36//      name2         = "testbench_output";
     37//       }
    3838
    39     string range;
    40     if (size == 1)
    41       range = "("+toString(size_old)+")";
    42     else
    43       range = "("+toString(size_old+size-1)+" downto "+toString(size_old)+")";
     39//     string range;
     40//     if (size == 1)
     41//       range = "("+toString(size_old)+")";
     42//     else
     43//       range = "("+toString(size_old+size-1)+" downto "+toString(size_old)+")";
    4444   
    45     _vhdl->set_alias (name, std_logic(size), name2, range);
     45//     _vhdl->set_alias (name, std_logic(size), name2, range);
    4646
    47     _list_port.push_back(name);
    48   };
     47//     _list_port.push_back(name);
     48//   };
    4949 
    5050}; // end namespace behavioural         
Note: See TracChangeset for help on using the changeset viewer.