check-paged.cxx

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/**
 * @file test/check.cxx
 * @author <a href="mailto:[email protected]>Andr� Rabello dos
 * ANJOS</a>
 * $Author: zhangy $
 * $Revision: 1.1.1.1 $
 * $Date: 2009/06/19 07:35:41 $
 *
 * This source code describes a small test program based on the eformat
 * library. It will read a file containing complete events and check the
 * format correctness.
 */
 
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <sys/uio.h>
#include "eformat/eformat.h"
 
/**
 * Page size used as reference
 */
const size_t PAGE_SIZE = 2500;
const size_t BUFFER_SIZE = 10000000;
 
/**
 * Reads a file and check its validity (for the time being)
 */
int main (int argc, char** argv)
{
  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;
}