header_access.cxx

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/**
 * @file header_access.cxx
 * @author <a href="mailto:[email protected]">Andre DOS ANJOS</a> 
 * $Author: zhangy $
 * $Revision: 1.1.1.1 $
 * $Date: 2009/06/19 07:35:41 $
 *
 * Describes a test that benchmarks header information access. The test tries
 * to read some words of ROBHeaders, starting from full events.
 */
 
#include "eformat/eformat.h"
#include "clocks/Clock.h"
#include "clocks/Time.h"
#include <iostream>
#include <fstream>
 
/**
 * Page size used as reference
 */
const size_t PAGE_SIZE = 8192; //8 kilobytes pages
const size_t BUFFER_SIZE = 4194304; //4 Megabytes
 
/**
 * Does the exercise itself.
 */
int main (int argc, char** argv)
{
  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;
  double validation_cpu_time = 0;
  uint32_t info_read = 0;
  uint32_t dummy = 0;
  uint32_t robs_read = 0;
  uint32_t ros_counter = 0;
  uint32_t event_counter = 0;
  RealTimeClock my_clock;
 
  //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 << 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());
      typedef eformat::PagedMemory<BUFFER_SIZE/PAGE_SIZE>::const_iterator
    pointer_t;
#else
      FullEventFragment<const uint32_t*> fe(event);
      typedef const uint32_t* pointer_t;
#endif
 
      fe.check_tree();
      ++event_counter;
 
      Time start = my_clock.time();
 
      //max SD's is well bellow 64
      pointer_t sdp[64];
      uint32_t nsd = fe.children(sdp, 64);
      for (size_t i=0; i<nsd; ++i) {
    SubDetectorFragment<pointer_t> sd(sdp[i]);
    //max ROS's in system is well bellow 256
    pointer_t rosp[256];
    uint32_t nros = sd.children(rosp, 256);
    for (size_t j=0; j<nros; ++j) {
      ROSFragment<pointer_t> ros(rosp[j]);
      ++ros_counter;
      //max number of ROB's is well bellow 2048
      pointer_t robp[2048];
      uint32_t nrob = ros.children(robp, 2048);
      for (size_t k=0; k<nrob; ++k) {
        ROBFragment<pointer_t> rob(robp[k]);
        dummy += rob.rod_lvl1_id(); //access
        ++info_read;
        ++robs_read;
      }
    }
      }
 
      Time end = my_clock.time();
      Time diff = end - start;
      cpu_time_used += diff.as_nanoseconds();
      start = my_clock.time();
      end = my_clock.time();
      diff = end - start;
      validation_cpu_time += diff.as_microseconds();
 
      //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;
    }
 
  } ///event loop
 
  std::cout << " Statistics for ROB Header access:" << std::endl;
  std::cout << " ---------------------------------" << std::endl;
  std::cout << "  - Total reading time: " << cpu_time_used/1e6 << " milisecs"
        << std::endl;
  std::cout << "  - Reading time per Event ("
        << event_counter << "): " << cpu_time_used/(event_counter*1e3)
        << " usecs" << std::endl;
  std::cout << "  - Reading time per ROS ("
        << ros_counter << "): " << cpu_time_used/(ros_counter*1e3)
        << " usecs" << std::endl;
  std::cout << "  - Reading time per ROB ("
        << robs_read << "): " << cpu_time_used/(robs_read)
        << " nanosecs" << std::endl;
  std::cout << "  - Reading time per info ("
        << info_read << "): " << cpu_time_used/(info_read)
        << " nanosecs" << std::endl;
  std::cout << "  - Validation per event (after header access): " 
        << validation_cpu_time/(event_counter)
        << " microseconds" << std::endl;
    
  std::exit(0);
}