Ejemplo n.º 1
0
void
TestU01Suite::assess()
//******************************************************************************
// Output final assessment
//! \author  J. Bakosi
//******************************************************************************
{
  // Output summary of failed tests for all RNGs tested
  if ( !m_failed.empty() ) {
    const auto rngs = g_inputdeck.get< tag::selected, tag::rng >();
    m_print.failed( "Failed statistics", m_npval*rngs.size(), m_failed );
  } else m_print.note< tk::QUIET >( "All tests passed" );

  // Cost and quality assessment only for more than one RNG
  if (m_time.size() > 1) {
    // Output measured times per RNG in order of computational cost
    m_print.cost( "Generator cost",
                  "Measured times in seconds in increasing order (low is good)",
                  m_time );
    // Output number of failed tests per RNG in order of decreasing quality
    m_print.rank( "Generator quality",
                  "Number of failed tests in increasing order (low is good)",
                  m_nfail );
  }

  // Quit
  mainProxy.finalize();
}
Ejemplo n.º 2
0
void
RegSuite::evaluate( std::vector< std::string > status )
//******************************************************************************
// Evaluate a unit test
//! \param[in] status Vector strings containing the test results.
//! \author J. Bakosi
//******************************************************************************
{
  // Increase number of tests run
  ++m_nrun;

  // Evaluate test
  evaluate( status, m_ncomplete, m_nwarn, m_nskip, m_nexcp, m_nfail );

  // Echo one-liner info on result of test
  m_print.test( m_ncomplete, m_nfail, status );

  // Wait for all tests to finish, then quit
  if (m_nrun == m_ntest)
  {
//     assess( m_print, "serial and Charm++", m_nfail, m_nwarn, m_nskip, m_nexcp,
//             m_ncomplete );
    // Quit
    mainProxy.finalize( true );
  }
}
Ejemplo n.º 3
0
RegSuite::RegSuite( const ctr::CmdLine& cmdline ) :
  m_print( cmdline.get< tag::verbose >() ? std::cout : std::clog ),
  m_ntest( 0 ),
  m_nrun( 0 ),
  m_ncomplete( 0 ),
  m_nfail( 0 ),
  m_nskip( 0 ),
  m_nwarn( 0 ),
  m_nexcp( 0 )
//******************************************************************************
// Constructor
//! \param[in] cmdline Data structure storing data from the command-line parser
//! \author J. Bakosi
//******************************************************************************
{
  // Get group name string passed in by -g
  const auto grp = cmdline.get< tag::group >();

  // If only select groups to be run, see if there is any that will run
  bool work = false;
  if (grp.empty())
    work = true;
  else
    work = true;        // for now there is always work

  // Quit if there is no work to be done
  if (!work) {

    m_print.note( "\nNo regression test groups to be executed because no test "
                  "group names match '" + grp + "'.\n" );
    mainProxy.finalize( false );

  } else {

    m_print.endpart();
    m_print.part( "Regression test suite" );
    m_print.reghead( "Regression tests computed", grp );

    // Fire up all tests using the Charm++ runtime system
    const std::vector< std::string > tests {
      "./charmrun +p1 Main/unittest -g Exc",
      "./charmrun +p2 Main/unittest -g MKL",
      "./charmrun +p3 Main/unittest -g MPI",
      "./charmrun +p4 Main/unittest"
    };
    for (const auto& t : tests)
      if (grp.empty()) {                        // consider all test groups
        spawntest( t );
      } else if (t.find(grp) != std::string::npos) {
        // spawn only the tests that match the string specified via -g string
        spawntest( t );
      }

  }
}
Ejemplo n.º 4
0
void
MeshConvDriver::execute() const
//******************************************************************************
//  Execute: Convert mesh file
//! \author J. Bakosi
//******************************************************************************
{
  std::pair< std::string, tk::real > rtime, wtime;
  tk::writeUnsMesh( m_output, tk::readUnsMesh(m_input,rtime), wtime );
  mainProxy.timestamp( { rtime, wtime } );
  mainProxy.finalize();
}
Ejemplo n.º 5
0
void
Conductor::finish()
// *****************************************************************************
// Normal finish of time stepping
//! \author J. Bakosi
// *****************************************************************************
{
  // Print out reason for stopping
  const auto nstep = g_inputdeck.get< tag::discr, tag::nstep >();
  m_print.endsubsection();
  if (m_it >= nstep)
     m_print.note( "Normal finish, maximum number of iterations reached: " +
                   std::to_string( nstep ) );
   else
     m_print.note( "Normal finish, maximum time reached: " +
                   std::to_string( g_inputdeck.get<tag::discr,tag::term>() ) );

  // Quit
  mainProxy.finalize();
}
Ejemplo n.º 6
0
void
MeshConvDriver::execute() const
// *****************************************************************************
//  Execute: Convert mesh file
//! \author J. Bakosi
// *****************************************************************************
{
  m_print.endsubsection();

  std::vector< std::pair< std::string, tk::real > > times( 1 );

  auto mesh = tk::readUnsMesh( m_print, m_input, times[0] );
  auto wtimes = tk::writeUnsMesh( m_print,
                                  m_output,
                                  mesh,
                                  m_reorder );

  times.insert( end(times), begin(wtimes), end(wtimes) );
  mainProxy.timestamp( times );

  mainProxy.finalize();
}