validate.cxx File Reference

#include "clocks/Clock.h"
#include "clocks/Time.h"
#include "eformat/eformat.h"
#include <fstream>
#include <iostream>

Go to the source code of this file.

Functions
template<class TPointer>
uint32_t	components (const eformat::FullEventFragment< TPointer > &f)
int	main (int argc, char **argv)

Variables
const size_t	PAGE_SIZE = 8192
const size_t	BUFFER_SIZE = 4194304

Detailed Description

Author

Andre DOS ANJOS

Author

zhangy

Revision

1.1.1.1

Date

2009/06/19 07:35:41

Describes a test that benchmarks validation of full events.

Definition in file validate.cxx.

Function Documentation

components()

template<class TPointer>

uint32_t components

(

const eformat::FullEventFragment< TPointer > &

f

)

Calculates the number of components in an event

Definition at line 29 of file validate.cxx.

                                                                   {
  using namespace eformat;
  uint32_t retval = 0;
 
  // max SD's is well bellow 64
  TPointer sdp[64];
  uint32_t nsd = f.children( sdp, 64 );
  retval += nsd;
  for ( size_t i = 0; i < nsd; ++i )
  {
    SubDetectorFragment<TPointer> sd( sdp[i] );
    // max ROS's in system is well bellow 256
    TPointer rosp[256];
    uint32_t nros = sd.children( rosp, 256 );
    retval += nros;
    for ( size_t j = 0; j < nros; ++j )
    {
      ROSFragment<TPointer> ros( rosp[j] );
      retval += ros.nchildren();
    }
  }
 
  return retval;
}

Referenced by main().

main()

int main	(	int	argc,
		char **	argv )

Does the exercise itself.

Definition at line 57 of file validate.cxx.

                                  {
  using namespace eformat;
 
  if ( argc != 2 )
  {
    std::cerr << "usage: " << argv[0] << " <test-file>" << std::endl;
    std::exit( 1 );
  }
 
  // time accounting
  double        cpu_time_used           = 0;
  uint32_t      events_read             = 0;
  uint32_t      components_instantiated = 0;
  RealTimeClock my_clock;
  uint32_t      event_size = 0;
 
  // open normally a file
  std::fstream in( argv[1], std::ios::in | std::ios::binary );
  if ( !in )
  {
    std::cerr << "File `" << argv[1] << "' does not exist?!" << std::endl;
    std::exit( 1 );
  }
  size_t offset = 0;
 
#ifdef PAGED_MEMORY
  std::cout << "Working with paged storage with page size = " << PAGE_SIZE << " bytes."
            << std::endl;
#else
  std::cout << "Working with contiguous storage." << std::endl;
#endif
 
  while ( in && in.good() && !in.eof() )
  {
    // soft check, so we don't mistake too often
    uint32_t data[2];
    in.read( (char*)data, 8 );
    if ( !in.good() || in.eof() ) break; // end-of-file
    if ( data[0] != eformat::FULL_EVENT )
    {
      // stop!
      std::cout << "Word at offset " << HEX( offset ) << " is not "
                << HEX( eformat::FULL_EVENT ) << std::endl;
      std::exit( 1 );
    }
 
#ifdef PAGED_MEMORY
    // data[1] is the fragment size, in words. Take it and read the fragment
    in.seekg( offset );
    // read the event into my pages
    size_t to_read      = data[1] << 2;
    size_t page_counter = 0;
    // std::cout << "Loading page";
    uint32_t paged_event[BUFFER_SIZE / PAGE_SIZE][PAGE_SIZE / sizeof( uint32_t )];
    while ( to_read > 0 )
    {
      size_t readnow = ( PAGE_SIZE > to_read ) ? to_read : PAGE_SIZE;
      in.read( (char*)paged_event[page_counter], readnow );
      to_read -= readnow;
      ++page_counter;
      // std::cout << " " << page_counter;
    }
    // std::cout << ": ";
    struct iovec myvec[BUFFER_SIZE / PAGE_SIZE];
    for ( size_t i = 0; i < page_counter; ++i )
    {
      myvec[i].iov_base = paged_event[i];
      myvec[i].iov_len  = PAGE_SIZE;
    }
    // correct last page
    myvec[page_counter - 1].iov_len = data[1] << 2 - ( page_counter - 1 ) * PAGE_SIZE;
    eformat::PagedMemory<BUFFER_SIZE / PAGE_SIZE> mem( myvec, page_counter );
#else
    in.seekg( offset );
    uint32_t event[BUFFER_SIZE / 4];
    in.read( (char*)event, data[1] << 2 );
#endif
 
    offset += data[1] << 2;
 
    try
    {
#ifdef PAGED_MEMORY
      FullEventFragment<eformat::PagedMemory<BUFFER_SIZE / PAGE_SIZE>::const_iterator> fe(
          mem.begin() );
#else
      FullEventFragment<const uint32_t*> fe( event );
#endif
 
      event_size += 4 * fe.fragment_size_word();
 
      Time start = my_clock.time();
      fe.check_tree();
      Time end  = my_clock.time();
      Time diff = end - start;
 
      // calculate the number of event components:
      uint32_t comps = components( fe );
      components_instantiated += comps;
 
      // std::cout << " > Timing          : " << diff.as_milliseconds()
      //    << " ms" << std::endl;
      // std::cout << " > Timing/component: " << diff.as_milliseconds()*1e3/comps
      //    << " us" << std::endl;
      cpu_time_used += diff.as_milliseconds();
      ++events_read;
 
      // if check is ok, print the lvl1 identifier
      // std::cout << fe.lvl1_id() << "..";
    }
 
    catch ( eformat::Issue& ex )
    {
      std::cerr << std::endl << "Uncaught eformat exception: " << ex.what() << std::endl;
    }
 
    catch ( ers::Issue& ex )
    {
      std::cerr << std::endl << "Uncaught ERS exception: " << ex.what() << std::endl;
    }
 
    catch ( std::exception& ex )
    {
      std::cerr << std::endl << "Uncaught std exception: " << ex.what() << std::endl;
    }
 
    catch ( ... )
    { std::cerr << std::endl << "Uncaught unknown exception" << std::endl; }
  }
 
  std::cout << std::endl;
  std::cout << " Statistics for Event Validation:" << std::endl;
  std::cout << " --------------------------------" << std::endl;
  std::cout << "  - Total reading time: " << cpu_time_used << " millisecs" << std::endl;
  std::cout << "  - Validation time per event (" << events_read
            << "): " << cpu_time_used / events_read << " millisecs" << std::endl;
  std::cout << "  - Average event size: " << event_size / ( 1024.0 * 1024 * events_read )
            << " megabytes" << std::endl;
  std::cout << "  - Validation time per component (" << components_instantiated
            << "): " << 1e3 * cpu_time_used / components_instantiated << " microsecs"
            << std::endl;
  std::exit( 0 );
}

Variable Documentation

BUFFER_SIZE

const size_t BUFFER_SIZE = 4194304

Definition at line 23 of file validate.cxx.

PAGE_SIZE

const size_t PAGE_SIZE = 8192

Page size used as reference

Definition at line 22 of file validate.cxx.