// =====================================
// C/C++ Program Performance Measurement
// -------------------------------------
#define PROGRAM_NAME     "Simple C/C++ Perfometer : Copying files"
#define PROGRAM_VERSION  "Version CF-1.4"
// -------------------------------------
// Copyright (C) 2002-2004 Alex Vinokur
// mailto:alexvn <at> connect.to
// http://up.to/alexv
// =====================================

// --------------------------------------
#if ((defined unix) || (defined __unix) || (defined unix__) || (defined __unix__))
#define UNIX_ENV
#endif

// ==============
#include <ctime>
#include <cassert>
#include <string>
#include <vector>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <iterator>
#include <algorithm>
#ifdef UNIX_ENV
#include <fcntl.h>
#include <sys/mman.h>
#endif
using namespace std;

// --------------------------------------
typedef unsigned long ulong;
typedef unsigned int  uint;

// --------------------------------------
#define  MAX_VALUE(x,y)  ((x) > (y) ? (x) : (y))

// --------------------------------------
string get_compiler_info()
{
ostringstream oss;
ostringstream tss;
string str;

// ------ GNU gcc ------
#ifdef __GNUC__
  oss.str("");
  tss.str("");
  str.erase();

  oss << "GNU gcc " << __GNUC__;
#ifdef __GNUC_MINOR__
  oss << "." << __GNUC_MINOR__;
#ifdef __GNUC_PATCHLEVEL__
#if (__GNUC_PATCHLEVEL__)
  oss << "." << __GNUC_PATCHLEVEL__;
#endif
#endif
#endif

#if (__CYGWIN32__ || __CYGWIN__)
  oss << " (CYGWIN)";
#endif

#if (__MINGW32__ || __MINGW__ )
  oss << " (MINGW)";
#endif

#if (__DJGPP__)
  oss << " (DGGPP " << __DJGPP__;
#ifdef __DJGPP_MINOR__
  oss << "." << __DJGPP_MINOR__;
#endif
  oss << ")";
#endif

#endif

// ------ Microsoft C++ ------
#ifdef _MSC_VER
  oss.str("");
  tss.str("");
  str.erase();

  oss << "Microsoft C++ ";
  tss << _MSC_VER;
  str = tss.str();
  assert (str.size() == 4);
  oss << str[0] << str[1] << "." << str[2] << str[3];

#ifdef _MANAGED

#if (_MANAGED)
  oss << " (Managed)";
#else
  assert (0);
  oss << " (Unmanaged)";
#endif
#else

  oss << " (Unmanaged)";
#endif

#endif

// ------ Intel C++ ------
#ifdef __INTEL_COMPILER
  oss.str("");
  tss.str("");
  str.erase();

  oss << "Intel C++ ";
  tss << __INTEL_COMPILER;
  str = tss.str();
  assert (str.size() == 3);
  oss << str[0] << "." << str[1];
#endif

// ------ Borland C++ ------
#ifdef __BCPLUSPLUS__
  oss.str("");
  tss.str("");
  str.erase();

  oss << "Borland C++ ";
  tss << hex << __BCPLUSPLUS__;
  str = tss.str();
  assert (str.size() == 3);
  oss << str[0] << "." << str[1] << "." << str[2];
#endif

// ------ Digital Mars C++ ------
#ifdef __DMC__
  oss.str("");
  tss.str("");
  str.erase();

#ifndef __DMC_VERSION_STRING__
#error __DMC_VERSION_STRING__ Not Defined
#endif
  oss << __DMC_VERSION_STRING__;
#endif

  return oss.str();

} // get_compiler_info

// --------------------------------------
void show_compiler_info()
{
const string str(get_compiler_info());

  if (str.empty()) return;

  cout << string (str.size(), '-') << endl;
  cout << str << endl;
  cout << string (str.size(), '-') << endl;
}

// --------------------------------------
static vector<string>           foo_names;
static vector<string>::iterator iter_names;
static vector<vector<clock_t> > used_time;

static ulong  test_no = 0;
static ulong  file_size;
static string in_file_content;
static string in_file_tail_delta;

static uint   foo_setw = 0;

// ------------------------------
#define INPUT_TXT_FILE_NAME   "z-txt.in"
#define OUTPUT_TXT_FILE_NAME  "z-txt.out"
#define INPUT_BIN_FILE_NAME   "z-bin.in"
#define OUTPUT_BIN_FILE_NAME  "z-bin.out"

#define ROWS_IN_INPUT_FILE 7

static FILE* fp_txt_in;
static FILE* fp_txt_out;
static FILE* fp_bin_in;
static FILE* fp_bin_out;

#ifdef UNIX_ENV
static int fd_txt_in;
static int fd_txt_out;
static int fd_bin_in;
static int fd_bin_out;
#endif

static ifstream fs_txt_in;
static ofstream fs_txt_out;
static ifstream fs_bin_in;
static ofstream fs_bin_out;

#define BUFFER_SIZE  4096

static char*    mbuffer;

// ==================================
string file_to_string (ifstream& fin_i)
// ==================================
{
  assert (fin_i);
  assert (fin_i.is_open());

  // ---------------------
ios::iostate prev_state = fin_i.rdstate();
ulong prev_pos   = fin_i.tellg();

  fin_i.clear();

ulong start_pos, end_pos, file_supersize;
  fin_i.seekg(0, ios::beg);
  start_pos = fin_i.tellg();
  fin_i.seekg(0, ios::end);
  end_pos = fin_i.tellg();

  file_supersize = end_pos - start_pos;
string ret_str (file_supersize, '0');

  // ---------------------
  fin_i.seekg(0, ios::beg);

char ch;

ulong i;
  for (i = 0; fin_i.get (ch); i++)
  {
    assert (i < ret_str.size());
    ret_str[i] = ch;
  }

  assert (i <= file_supersize);
  ret_str.erase (i);

  // ---------------------
  fin_i.seekg(prev_pos, ios::beg);
  fin_i.clear(prev_state);

  // ---------------------
  return ret_str;

} // file_to_string (1)

// ==================================
string file_to_string (const string& filename_i)
// ==================================
{
ifstream fin (filename_i.c_str());
  assert (fin);
  assert (fin.is_open());

const string ret_str (file_to_string (fin));

  fin.close();
  assert (!fin.is_open());

  return ret_str;

} // file_to_string (2)

// ------------------------------
void fill_input_file (uint total_full_rows = ROWS_IN_INPUT_FILE)
{
  assert (total_full_rows > 0);
  if (file_size < total_full_rows)
  {
    total_full_rows = file_size;
  }
  assert (total_full_rows <= file_size);

ofstream test_txt_infile (INPUT_TXT_FILE_NAME);
  assert (test_txt_infile);
  assert (test_txt_infile.is_open());

ofstream test_bin_infile (INPUT_BIN_FILE_NAME);
  assert (test_bin_infile);
  assert (test_bin_infile.is_open());

const uint row_size = file_size/total_full_rows;

char ch = 0;

ulong counter = 0;
  for (ulong row_no = 0; row_no < total_full_rows; row_no++)
  {
    for (ulong ch_no = 0; ch_no < row_size; ch_no++)
    {
      while (!isprint(ch)) ch++;
      assert (counter < file_size);

      test_txt_infile << ch;
      test_bin_infile << ch;
      ch++;
      counter++;
      if (counter == file_size) break;

      if (ch == SCHAR_MAX) ch = 0;
    }

    if (counter == file_size) break;
    assert (counter < file_size);

    test_txt_infile << '\n';
    test_bin_infile << '\n';
    counter++;
    if (counter == file_size) break;
  }

  /*
  for (ulong i = 0; i < file_size; i++)
  {
    while (!isprint(ch)) ch++;
    test_txt_infile << ch++;
    if (ch == SCHAR_MAX) ch = 0;
  }
  */

  test_txt_infile.close();
  assert (!test_txt_infile.is_open());

  test_bin_infile.close();
  assert (!test_bin_infile.is_open());

const string str_txt (file_to_string (INPUT_TXT_FILE_NAME));
const string str_bin (file_to_string (INPUT_BIN_FILE_NAME));
  assert (str_txt == str_bin);

const string tail_txt (((*str_txt.rbegin()) == '\n') ? "" : "\n");
const string tail_bin (((*str_bin.rbegin()) == '\n') ? "" : "\n");
  assert (tail_txt == tail_bin);

  in_file_content = str_txt;
  in_file_tail_delta = tail_txt;

}

// --------------------------------------
void C_01_txt__functions_getc_putc ()
{
int      int_ch;

  clearerr(fp_txt_in);
  rewind (fp_txt_in);

  clearerr(fp_txt_out);
  rewind (fp_txt_out);

  // ------ Body ------
  while ((int_ch = getc(fp_txt_in)) != EOF) putc(int_ch, fp_txt_out);
  // ------------------
}

// --------------------------------------
void C_01_bin__functions_getc_putc ()
{
int      int_ch;

  clearerr(fp_bin_in);
  rewind (fp_bin_in);

  clearerr(fp_bin_out);
  rewind (fp_bin_out);

  // ------ Body ------
  while ((int_ch = getc(fp_bin_in)) != EOF) putc(int_ch, fp_bin_out);
  // ------------------
}

// --------------------------------------
void C_02_txt__functions_fgetc_fputc ()
{
int      int_ch;

  clearerr(fp_txt_in);
  rewind (fp_txt_in);

  clearerr(fp_txt_out);
  rewind (fp_txt_out);

  // ------ Body ------
  while ((int_ch = fgetc(fp_txt_in)) != EOF) fputc(int_ch, fp_txt_out);
  // ------------------
}

// --------------------------------------
void C_02_bin__functions_fgetc_fputc ()
{
int      int_ch;

  clearerr(fp_bin_in);
  rewind (fp_bin_in);

  clearerr(fp_bin_out);
  rewind (fp_bin_out);

  // ------ Body ------
  while ((int_ch = fgetc(fp_bin_in)) != EOF) fputc(int_ch, fp_bin_out);
  // ------------------
}

// --------------------------------------
void C_03_txt__functions_fread_fwrite ()
{
char     cbuffer[BUFFER_SIZE];
size_t   nread;

  clearerr(fp_txt_in);
  rewind (fp_txt_in);

  clearerr(fp_txt_out);
  rewind (fp_txt_out);

  // ------ Body ------
  while ((nread = fread(cbuffer, sizeof(char), sizeof(cbuffer), fp_txt_in)) > 0)
  {
    fwrite(cbuffer, sizeof(char), nread, fp_txt_out);
  }
  // ------------------
}

// --------------------------------------
void C_03_bin__functions_fread_fwrite ()
{
char     cbuffer[BUFFER_SIZE];
size_t   nread;

  clearerr(fp_bin_in);
  rewind (fp_bin_in);

  clearerr(fp_bin_out);
  rewind (fp_bin_out);

  // ------ Body ------
  while ((nread = fread(cbuffer, sizeof(char), sizeof(cbuffer), fp_bin_in)) > 0)
  {
    fwrite(cbuffer, sizeof(char), nread, fp_bin_out);
  }
  // ------------------
}

#ifdef UNIX_ENV
// --------------------------------------
void unix_C_04_txt__mmap ()
{
off_t rc;
  rc = lseek(fd_txt_in, 0, SEEK_SET);
  rc = lseek(fd_txt_out, 0, SEEK_SET);

  // ------ Body ------
char* ptr = (char*)mmap(0, file_size, PROT_READ, MAP_SHARED, fd_txt_in, 0);
  assert (ptr != MAP_FAILED);
  write(fd_txt_out, ptr, file_size);
  munmap(ptr, file_size);
  // ------------------
}
#endif

// --------------------------------------
void cpp_01_txt__operators_in_out ()
{
char ch;

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_txt_in.unsetf(ios::skipws);
  while (fs_txt_in >> ch) fs_txt_out << ch;
  // ------------------
}

// --------------------------------------
void cpp_01_bin__operators_in_out ()
{
char ch;

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_bin_in.unsetf(ios::skipws);
  while (fs_bin_in >> ch) fs_bin_out << ch;
  // ------------------
}

// --------------------------------------
void cpp_02_txt__methods_get_put ()
{
char ch;

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  while (fs_txt_in.get(ch)) fs_txt_out.put(ch);
  // ------------------
}

// --------------------------------------
void cpp_02_bin__methods_get_put ()
{
char ch;

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  while (fs_bin_in.get(ch)) fs_bin_out.put(ch);
  // ------------------
}

// --------------------------------------
void cpp_03_txt__methods_sbumpc_sputc ()
{
char ch;

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  while ((ch = fs_txt_in.rdbuf()->sbumpc()) != EOF) fs_txt_out.rdbuf()->sputc(ch);
  // ------------------
}

// --------------------------------------
void cpp_03_bin__methods_sbumpc_sputc ()
{
char ch;

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  while ((ch = fs_bin_in.rdbuf()->sbumpc()) != EOF) fs_bin_out.rdbuf()->sputc(ch);
  // ------------------
}

// --------------------------------------
void cpp_04_txt__method_sbumpc__op_out ()
{
char ch;

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  ch = fs_txt_in.rdbuf()->sbumpc();
  fs_txt_out << ch;

  while (ch != EOF)
  {
    fs_txt_out << fs_txt_in.rdbuf();
    ch = fs_txt_in.rdbuf()->sbumpc();
  }

}

// --------------------------------------
void cpp_04_bin__method_sbumpc__op_out ()
{
char ch;

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  ch = fs_bin_in.rdbuf()->sbumpc();
  fs_bin_out << ch;

  while (ch != EOF)
  {
    fs_bin_out << fs_bin_in.rdbuf();
    ch = fs_bin_in.rdbuf()->sbumpc();
  }

}

// --------------------------------------
void cpp_05_txt__method_rdbuf__op_out ()
{
  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_txt_out << fs_txt_in.rdbuf();
  // ------------------

}

// --------------------------------------
void cpp_05_bin__method_rdbuf__op_out ()
{
  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_bin_out << fs_bin_in.rdbuf();
  // ------------------

}

// --------------------------------------
void cpp_06_txt__methods_cpp_read_write__const_buf ()
{
char cbuffer[BUFFER_SIZE];

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  while (!fs_txt_in.eof())
  {
    fs_txt_in.read (cbuffer, sizeof(cbuffer));
    fs_txt_out.write (cbuffer, fs_txt_in.gcount());
  }
  // ------------------
}

// --------------------------------------
void cpp_06_bin__methods_cpp_read_write__const_buf ()
{
char cbuffer[BUFFER_SIZE];

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  while (!fs_bin_in.eof())
  {
    fs_bin_in.read (cbuffer, sizeof(cbuffer));
    fs_bin_out.write (cbuffer, fs_bin_in.gcount());
  }
  // ------------------
}

// --------------------------------------
void cpp_07_txt__methods_cpp_read_write__max_buf ()
{
  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_txt_in.read   (mbuffer, file_size);
  fs_txt_out.write (mbuffer, file_size);
  // ------------------

}

// --------------------------------------
void cpp_07_bin__methods_cpp_read_write__max_buf ()
{
  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_bin_in.read   (mbuffer, file_size);
  fs_bin_out.write (mbuffer, file_size);
  // ------------------

}

// --------------------------------------
void cpp_08_txt__method_getline ()
{
string line;

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  while (getline (fs_txt_in, line)) fs_txt_out << line << '\n';
  // ------------------

}

// --------------------------------------
void cpp_08_bin__method_getline ()
{
string line;

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  while (getline (fs_bin_in, line)) fs_bin_out << line << '\n';
  // ------------------

}

// --------------------------------------
void cpp_09_txt__method_ifstream_getline ()
{
char buffer[BUFFER_SIZE];

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  while (fs_txt_in.getline (buffer, sizeof(buffer))) fs_txt_out << buffer << '\n';
  // ------------------

}

// --------------------------------------
void cpp_09_bin__method_ifstream_getline ()
{
char buffer[BUFFER_SIZE];

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  while (fs_bin_in.getline (buffer, sizeof(buffer))) fs_bin_out << buffer << '\n';
  // ------------------

}

// --------------------------------------
void cpp_10_txt__iterators ()
{
char buffer[BUFFER_SIZE];

  fs_txt_in.clear();
  fs_txt_in.seekg (0, ios::beg);

  fs_txt_out.clear();
  fs_txt_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_txt_in >> noskipws;
istream_iterator<char> in(fs_txt_in), eos;
ostream_iterator<char> out(fs_txt_out);
  copy (in, eos, out);
  // ------------------

}

// --------------------------------------
void cpp_10_bin__iterators ()
{
char buffer[BUFFER_SIZE];

  fs_bin_in.clear();
  fs_bin_in.seekg (0, ios::beg);

  fs_bin_out.clear();
  fs_bin_out.seekp (0, ios::beg);

  // ------ Body ------
  fs_bin_in >> noskipws;
istream_iterator<char> in(fs_bin_in), eos;
ostream_iterator<char> out(fs_bin_out);
  copy (in, eos, out);
  // ------------------

}

// -----------------------------------
// -----------------------------------
// -----------------------------------
#define MEASURE_IT(x, y) \
  foo_setw = MAX_VALUE (foo_setw, string (#y).size()); \
  start_time = clock(); \
  assert (start_time != clock_t (-1)); \
  { for (ulong k = 0; k < no_of_repetitions; k++) { x; } } \
  end_time = clock(); \
  assert (end_time != clock_t (-1)); \
  if (!(end_time > start_time)) { cout << "Number of repetitions is too small" << endl << "Good Luck" << endl <<
endl; exit(1); }\
  assert (end_time > start_time); \
  if (find (foo_names.begin(), foo_names.end(), #y) == foo_names.end()) \
  { \
    foo_names.push_back (#y); \
    used_time.push_back (vector<clock_t>()); \
  } \
  assert (foo_names.size() == used_time.size()); \
  iter_names = find (foo_names.begin(), foo_names.end(), #y); \
  assert (iter_names != foo_names.end()); \
  used_time[distance (foo_names.begin(), iter_names)].push_back ((end_time - start_time))

#define MEASURE_WITH_ARG(foo, argument) MEASURE_IT (foo(argument), foo)
#define MEASURE_WITH_NO_ARG(foo) MEASURE_IT (foo(), foo)

// ------------
void measure (ulong no_of_repetitions)
{
clock_t start_time;
clock_t end_time;
vector<clock_t> elapsed_time_vect;

  // -------------------------------
  fill_input_file ();
  mbuffer = new char [file_size];

  fp_txt_in  = fopen(INPUT_TXT_FILE_NAME, "r");
  assert(fp_txt_in);

  fp_txt_out = fopen(OUTPUT_TXT_FILE_NAME, "w");
  assert(fp_txt_out);

  fp_bin_in  = fopen(INPUT_BIN_FILE_NAME, "rb");
  assert(fp_txt_in);

  fp_bin_out = fopen(OUTPUT_BIN_FILE_NAME, "wb");
  assert(fp_txt_out);

#ifdef UNIX_ENV
  fd_txt_in = open(INPUT_TXT_FILE_NAME, O_RDONLY);
  assert (fd_txt_in != -1);

  fd_txt_out = open(OUTPUT_TXT_FILE_NAME, O_WRONLY);
  assert (fd_txt_out != -1);

  assert (fd_txt_in != fd_txt_out);

#endif

  fs_txt_in.open (INPUT_TXT_FILE_NAME);
  assert (fs_txt_in);
  assert (fs_txt_in.is_open());

  fs_txt_out.open (OUTPUT_TXT_FILE_NAME);
  assert (fs_txt_out);
  assert (fs_txt_out.is_open());

  fs_bin_in.open (INPUT_BIN_FILE_NAME, ios::binary);
  assert (fs_bin_in);
  assert (fs_bin_in.is_open());

  fs_bin_out.open (OUTPUT_BIN_FILE_NAME, ios::binary);
  assert (fs_bin_out);
  assert (fs_bin_out.is_open());

  if (in_file_content.size() != file_size)
  {
    cerr << "Requested file size = " << file_size << endl;
    cerr << "Input file size     = " << in_file_content.size() << endl;
    assert (in_file_content.size() == file_size);
  }

  // -------------------------------
  // cout << "\t---> Test-" << ++test_no << " started" << endl;
  cout << ".";
  cout.flush();

  // -------------------------------
  MEASURE_WITH_NO_ARG (C_01_txt__functions_getc_putc);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (C_01_bin__functions_getc_putc);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (C_02_txt__functions_fgetc_fputc);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (C_02_bin__functions_fgetc_fputc);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (C_03_txt__functions_fread_fwrite);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (C_03_bin__functions_fread_fwrite);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

#ifdef UNIX_ENV
  MEASURE_WITH_NO_ARG (unix_C_04_txt__mmap);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));
#endif

  MEASURE_WITH_NO_ARG (cpp_01_txt__operators_in_out);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_01_bin__operators_in_out);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_02_txt__methods_get_put);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_02_bin__methods_get_put);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_03_txt__methods_sbumpc_sputc);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_03_bin__methods_sbumpc_sputc);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_04_txt__method_sbumpc__op_out);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_04_bin__method_sbumpc__op_out);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_05_txt__method_rdbuf__op_out);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_05_bin__method_rdbuf__op_out);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_06_txt__methods_cpp_read_write__const_buf);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_06_bin__methods_cpp_read_write__const_buf);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_07_txt__methods_cpp_read_write__max_buf);
  assert (in_file_content == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_07_bin__methods_cpp_read_write__max_buf);
  assert (in_file_content == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_08_txt__method_getline);
  assert ((in_file_content + in_file_tail_delta) == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_08_bin__method_getline);
  assert ((in_file_content + in_file_tail_delta) == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_09_txt__method_ifstream_getline);
  assert ((in_file_content + in_file_tail_delta) == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_09_bin__method_ifstream_getline);
  assert ((in_file_content + in_file_tail_delta) == file_to_string(OUTPUT_BIN_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_10_txt__iterators);
  assert ((in_file_content + in_file_tail_delta) == file_to_string(OUTPUT_TXT_FILE_NAME));

  MEASURE_WITH_NO_ARG (cpp_10_bin__iterators);
  assert ((in_file_content + in_file_tail_delta) == file_to_string(OUTPUT_BIN_FILE_NAME));

  // -------------------------------
  // cerr << "\t     Test-" << test_no << " finished" << endl;

  // -------------------------------
  fs_txt_in.clear();
  fs_txt_in.close();
  assert (!fs_txt_in.is_open());

  fs_txt_out.clear();
  fs_txt_out.close();
  assert (!fs_txt_out.is_open());

  fs_bin_in.clear();
  fs_bin_in.close();
  assert (!fs_bin_in.is_open());

  fs_bin_out.clear();
  fs_bin_out.close();
  assert (!fs_bin_out.is_open());

#ifdef UNIX_ENV
  close (fd_txt_in);
  close (fd_txt_out);
#endif

  clearerr(fp_txt_in);
  fclose(fp_txt_in);

  clearerr(fp_txt_out);
  fclose(fp_txt_out);

  clearerr(fp_bin_in);
  fclose(fp_bin_in);

  clearerr(fp_bin_out);
  fclose(fp_bin_out);

}

// ------------
void show (ulong no_of_tests)
{
clock_t units;
clock_t sum;
#define THRESHOLD  0.2
const ulong   threshold = ulong(no_of_tests * THRESHOLD);

  assert ((threshold * 2) <= no_of_tests);

  cout << endl;
  assert (foo_names.size() == used_time.size());

  for (ulong i = 0; i < foo_names.size(); i++)
  {
    sum = 0;
    assert (no_of_tests == used_time[i].size());
    for (ulong k = threshold; k < (used_time[i].size() - threshold); k++)
    {
      sum += used_time[i][k];
    }
    units = sum/(used_time[i].size() - (threshold * 2));

    cout << setw(foo_setw)
         << std::left
         << foo_names[i]
         << " : "
         << setw(6)
         << std::right
         << units
         << " units"
         << " (";
    cout.setf(ios::fixed, ios::floatfield);
    cout << setprecision (3)
         << (float(units)/float(CLOCKS_PER_SEC))
         << " secs)"
         << endl;
  }

}

// ------------
void run (ulong no_of_runs, ulong no_of_tests, ulong no_of_repetitions)
{
  for (ulong i = 0; i < no_of_runs; i++)
  {
    test_no = 0;
    foo_names.clear();
    used_time.clear();

    // ----------------------
    cout << endl << endl << "   Run-" << (i + 1) << " of " << no_of_runs << " : Started ";
    cout.flush();
    for (ulong k = 0; k < no_of_tests; k++) measure (no_of_repetitions);
    show (no_of_tests);
    cout << "   Run-" << (i + 1) << " of " << no_of_runs << " : Finished"<< endl << endl;
  }
}

// ------------
int main(int argc, char** argv)
{

  cout << endl;
  cout << string (string (PROGRAM_NAME).size(), '=') << endl;
  cout << PROGRAM_NAME << endl;
  cout << PROGRAM_VERSION << endl;
  cout << string (string (PROGRAM_NAME).size(), '=') << endl;
  // --------------------------

  cout << endl;
  cout << endl;
  show_compiler_info();

  cout << endl;
  cout << "\tYOUR COMMAND LINE : ";
string exe_name (argv[0]);
  cout << exe_name.substr (exe_name.find_last_of ("/\\") + 1) << " ";
  for (long i = 1; i < argc; i++) cout << argv[i] << " ";
  cout << endl;
  cout << endl;

  if (!(argc >= 4))
  {
    cout << "\tUSAGE : "
         << argv[0]
         << " "
         << "<File size> <No. of tests> <No. of repetitions> [<No. of runs>]"
         << endl;
    return 1;
  }
  assert (argc >= 4);

  file_size = atoi (argv[1]);
  assert (file_size > 0);

const ulong no_of_tests = atoi (argv[2]);
  assert (no_of_tests > 0);

const ulong no_of_repetitions = atoi (argv[3]);
  assert (no_of_repetitions > 0);

const ulong no_of_runs       = ((argc > 4) ? atoi (argv[4]) : 1);
  assert (no_of_runs > 0);

  cout << "\t### File size             : " << file_size << endl;
  cout << "\t### Number of runs        : " << no_of_runs << endl;
  cout << "\t### Number of tests       : " << no_of_tests << endl;
  cout << "\t### Number of repetitions : " << no_of_repetitions << endl;
  cout << "\t### CLOCKS_PER_SEC        : " << CLOCKS_PER_SEC << endl;
  cout << endl;

  // -----------------------------
  run (no_of_runs, no_of_tests, no_of_repetitions);

  return 0;
}

--
   Alex Vinokur
     mailto:alexvn <at> connect.to
     http://mathforum.org/library/view/10978.html

-------------------------------------------------------
This SF.Net email is sponsored by: IBM Linux Tutorials
Free Linux tutorial presented by Daniel Robbins, President and CEO of
GenToo technologies. Learn everything from fundamentals to system
administration.http://ads.osdn.com/?ad_id=1470&alloc_id=3638&op=click