source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Pseudo_LRU/SelfTest/src/test.cpp @ 2

/*
 * $Id$
 *
 * [ Description ]
 * 
 * Test
 */

#include "Behavioural/Generic/Select/Pseudo_LRU/SelfTest/include/test.h"
#include "Include/Test.h"

void test (string name,
           morpheo::behavioural::generic::select::pseudo_lru::Parameters param)
{
  cout << "<" << name << "> : Simulation SystemC" << endl;

  if (param._nb_update < 1)
    {
      cerr << "<" << name << "> : To test, need a less one update's port" << endl;
      exit (EXIT_FAILURE);
    }
  
  try 
    {
      cout << param.print(1);
      param.test();
    }
  catch (morpheo::ErrorMorpheo & error)
    {
      cout << "<" << name << "> : " <<  error.what ();
      return;
    }
  catch (...)
    {
      cerr << "<" << name << "> : This test must generate a error" << endl;
      exit (EXIT_FAILURE);
    }
  Pseudo_LRU * _Pseudo_LRU = new Pseudo_LRU (name.c_str(),
#ifdef STATISTICS
                                             morpheo::behavioural::Parameters_Statistics(5,50),
#endif
                                             param);
  
#ifdef SYSTEMC
  /*********************************************************************
   * Déclarations des signaux
   *********************************************************************/
  sc_clock                                 CLOCK ("clock", 1.0, 0.5);

  sc_signal<Tcontrol_t>                    ACCESS_VAL     [param._nb_access];
  sc_signal<Tcontrol_t>                    ACCESS_ACK     [param._nb_access];
  sc_signal<Taddress_t>                    ACCESS_ADDRESS [param._nb_access];
  sc_signal<Tentity_t >                    ACCESS_ENTITY  [param._nb_access];
  
  sc_signal<Tcontrol_t>                    UPDATE_VAL     [param._nb_update];
  sc_signal<Tcontrol_t>                    UPDATE_ACK     [param._nb_update];
  sc_signal<Taddress_t>                    UPDATE_ADDRESS [param._nb_update];
  sc_signal<Tentity_t >                    UPDATE_ENTITY  [param._nb_update];
  
  /********************************************************
   * Instanciation
   ********************************************************/
  
  cout << "<" << name << "> Instanciation of _Pseudo_LRU" << endl;
  
  (*(_Pseudo_LRU->in_CLOCK))        (CLOCK);

    for (uint32_t i=0; i<param._nb_access; i++)
      {
        (*(_Pseudo_LRU-> in_ACCESS_VAL     [i])) (ACCESS_VAL     [i]);
        (*(_Pseudo_LRU->out_ACCESS_ACK     [i])) (ACCESS_ACK     [i]);
        if (param._size_table>1)
        (*(_Pseudo_LRU-> in_ACCESS_ADDRESS [i])) (ACCESS_ADDRESS [i]);
        (*(_Pseudo_LRU->out_ACCESS_ENTITY  [i])) (ACCESS_ENTITY  [i]);
      }

    for (uint32_t i=0; i<param._nb_update; i++)
      {
        (*(_Pseudo_LRU-> in_UPDATE_VAL     [i])) (UPDATE_VAL     [i]);
        (*(_Pseudo_LRU->out_UPDATE_ACK     [i])) (UPDATE_ACK     [i]);
        if (param._size_table>1)
        (*(_Pseudo_LRU-> in_UPDATE_ADDRESS [i])) (UPDATE_ADDRESS [i]);
        (*(_Pseudo_LRU-> in_UPDATE_ENTITY  [i])) (UPDATE_ENTITY  [i]);
      }
  /********************************************************
   * Simulation - Begin
   ********************************************************/

  cout << "<" << name << "> Start Simulation ............" << endl;
  // Initialisation

  sc_start(0);

  bool array [param._nb_access][param._nb_entity];

  for (uint32_t i=0; i<param._nb_access; i++)
    {
      ACCESS_VAL[i].write(0);
    }
  for (uint32_t i=0; i<param._nb_update; i++)
    {
      UPDATE_VAL[i].write(0);
    }

  sc_start(5);
  cout << "-----[ Test Update ]------------------------------" << endl;
  for (uint32_t i=0; i<param._nb_update; i++)
    {
      UPDATE_VAL[i].write(1);
    }
  
  for (uint32_t j=0; j<param._size_table; j+=param._nb_update)
    for (uint32_t k=0; k<param._nb_entity; k++)
      {
        cout << "time : " << static_cast<uint32_t>(sc_simulation_time()) << endl;
        for (uint32_t i=0; i<param._nb_update; i++)
          {
            
            Tcontrol_t val     = static_cast<Tcontrol_t>((j+i)<param._size_table);
            Taddress_t addr;
            if (param._size_table>1)
              addr = static_cast<Taddress_t>((j+i)%param._size_table);
            else
              addr = 0;
            Tentity_t  entity  = (k+1)%param._nb_entity;
            UPDATE_VAL     [i].write(val );
            if (param._size_table>1)
              UPDATE_ADDRESS [i].write(addr);
            UPDATE_ENTITY  [i].write(entity);
            
            sc_start(0);
            cout << "\t[" << i << "] " << val << " - " << UPDATE_ACK[i].read() << " addr : " << addr << " -> " << entity << endl;
          }
        sc_start(1);
      }
                    

  for (uint32_t i=0; i<param._nb_update; i++)
    {
      UPDATE_VAL[i].write(0);
    }

  sc_start(5);

  cout << "-----[ Test Access ]------------------------------" << endl;
  
  
  for (uint32_t j=0; j<param._size_table; j+=param._nb_access)
    {
      // init
      memset(static_cast<void*>(array),0,param._nb_access*param._nb_entity*sizeof(bool));
      
      for (uint32_t k=0; k<param._nb_entity; k++)
        {
          
          cout << "time : " << static_cast<uint32_t>(sc_simulation_time()) << endl;
          for (uint32_t i=0; i<param._nb_access; i++)
            {
              Tcontrol_t val     = static_cast<Tcontrol_t>((j+i)<param._size_table);
              Taddress_t addr    ;
              if (param._size_table>1)
                addr = static_cast<Taddress_t>((j+i)%param._size_table);
              else
                addr = 0;
              ACCESS_VAL     [i].write(val );
              if (param._size_table>1)
                ACCESS_ADDRESS [i].write(addr);
              
              sc_start(0);
              
              Tentity_t  entity  = ACCESS_ENTITY [i].read();
              
              cout << "\t[" << i << "] " << val << " - " << ACCESS_ACK[i].read() << " addr : " << addr << " -> " << entity << endl;
              
              TEST(bool,false,((val == true) && (array[i][entity] == true)));

//            if ((val == true) && (array[i][entity] == true))
//              {
//                cout << "Test KO : Have already give this way" << endl;
//                exit (1);
//              }
//            else
                array[i][entity] = true;
            }
          
          sc_start(1);
          
        }
    }

  for (uint32_t i=0; i<param._nb_access; i++)
    {
      ACCESS_VAL[i].write(0);
    }

  sc_start(0);

  /********************************************************
   * Simulation - End
   ********************************************************/

  cout << "<" << name << "> ............ Stop Simulation" << endl;

#endif

  delete _Pseudo_LRU;
}