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/src
Files:
21 added
33 edited

Legend:

Unmodified
Added
Removed

  • 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.