check-paged.cxx File Reference

#include "eformat/eformat.h"
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <sys/uio.h>

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Variables
const size_t	PAGE_SIZE = 2500
const size_t	BUFFER_SIZE = 10000000

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Reads a file and check its validity (for the time being)

Definition at line 31 of file check-paged.cxx.

                                  {
  using namespace eformat;
 
  if ( argc != 2 )
  {
    std::cerr << "usage: " << argv[0] << " <file>" << std::endl;
    std::exit( 1 );
  }
 
  // 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;
 
  uint32_t* paged_event[BUFFER_SIZE / PAGE_SIZE];
  for ( size_t i = 0; i < BUFFER_SIZE / PAGE_SIZE; ++i )
    paged_event[i] = new uint32_t[PAGE_SIZE / sizeof( uint32_t )];
 
  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 );
    }
 
    // 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";
    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<1000> mymemory( myvec, page_counter );
 
    try
    {
      FullEventFragment<eformat::PagedMemory<1000>::const_iterator> fe( mymemory.begin() );
      fe.check_tree();
      // if check is ok, print the lvl1 identifier
      std::cout << "Event " << fe.lvl1_id() << " is Ok." << std::endl;
 
      // update offset
      offset += data[1] << 2;
    } catch ( eformat::Issue& ex )
    {
      std::cerr << std::endl << "Uncaught eformat issue: " << ex.what() << std::endl;
      std::cout << "Trying to continue..." << std::endl;
      continue;
    } catch ( ers::Issue& ex )
    {
      std::cerr << std::endl << "Uncaught ERS issue: " << ex.what() << std::endl;
      for ( size_t i = 0; i < BUFFER_SIZE / PAGE_SIZE; ++i ) delete[] paged_event[i];
      std::exit( 1 );
    } catch ( std::exception& ex )
    {
      std::cerr << std::endl << "Uncaught std exception: " << ex.what() << std::endl;
      for ( size_t i = 0; i < BUFFER_SIZE / PAGE_SIZE; ++i ) delete[] paged_event[i];
      std::exit( 1 );
    } catch ( ... )
    {
      std::cerr << std::endl << "Uncaught unknown exception" << std::endl;
      for ( size_t i = 0; i < BUFFER_SIZE / PAGE_SIZE; ++i ) delete[] paged_event[i];
      std::exit( 1 );
    }
  }
 
  for ( size_t i = 0; i < BUFFER_SIZE / PAGE_SIZE; ++i ) delete[] paged_event[i];
  return 0;
}

Variable Documentation

BUFFER_SIZE

const size_t BUFFER_SIZE = 10000000

Definition at line 26 of file check-paged.cxx.

PAGE_SIZE

const size_t PAGE_SIZE = 2500

Page size used as reference

Definition at line 25 of file check-paged.cxx.