// memsize_t.cxx

#include "dataset_util/memsize.h"
#include "dataset_util/MemoryUsage.h"
#include <iostream>
#include <sstream>
#include <cstring>

using std::string;
using std::cout;
using std::endl;
using std::ostringstream;
using std::vector;
using std::set;
using std::multiset;
using std::map;

void msg(string txt) {
  cout << "--- ";
  cout << txt;
  cout << " ---" << endl;
}

// Compare expected and actual memory usage.
void check(size_t exp, size_t act) {
  cout << "Expected: " << exp << endl;
  cout << "  Actual: " << act << endl;
  assert( exp > 0 );
  assert( double(act)/double(exp) > 0.90 );
  assert( double(act)/double(exp) < 1.10 );
}

class MyClass {
  int ival;
  MyClass* p1;
  MyClass* p2;
  MyClass* p3;
  MyClass* p4;
  MyClass* p5;
public:
  MyClass(int i =0) : ival(i) { }
  bool operator<(const MyClass& rhs) const {
    return ival < rhs.ival;
  }
};


int memsize_t() {

  msg("string");
  const int nval = 100000;
  string mystring = "abcdefghijklmnopqrstuvwxyz";
  char copy[100];
  char copy2[100];
  size_t mem1 = MemoryUsage().total();
  string strs[nval];
  for ( int ival=0; ival<nval; ++ival ) {
    strcpy(copy, mystring.c_str());
    strs[ival] = copy;
  }
  size_t mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(nval*memsize_string(mystring), mem2-mem1);

  msg("vector");
  vector<MyClass> myvec(100);
  mem1 = MemoryUsage().total();
  const int nvec = 10000;
  vector<MyClass> vecs[nvec];
  size_t exp = 0;
  for ( int ivec=0; ivec<nvec; ++ivec ) {
    vecs[ivec] = myvec;
    exp += memsize_vector(vecs[ivec]);
  }
  mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(exp, mem2-mem1);

  msg("set");
  set<MyClass> myset;
  for ( int ival=0; ival<100; ++ival ) {
    myset.insert(ival);
  }
  mem1 = MemoryUsage().total();
  const int nset = 2000;
  set<MyClass> sets[nset];
  exp = 0;
  for ( int iset=0; iset<nset; ++iset ) {
    sets[iset] = myset;
    exp += memsize_set(sets[iset]);
  }
  mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(exp, mem2-mem1);
  
  msg("multiset");
  multiset<MyClass> mymset;
  for ( int ival=0; ival<100; ++ival ) {
    mymset.insert(ival);
  }
  mem1 = MemoryUsage().total();
  multiset<MyClass> msets[nset];
  exp = 0;
  for ( int iset=0; iset<nset; ++iset ) {
    msets[iset] = mymset;
    exp += memsize_multiset(msets[iset]);
  }
  mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(exp, mem2-mem1);
  
  msg("map");
  map<MyClass,MyClass> mymap;
  for ( int ival=0; ival<100; ++ival ) {
    mymap[ival] = 2*ival;
  }
  mem1 = MemoryUsage().total();
  const int nmap = 2000;
  map<MyClass, MyClass> maps[nmap];
  exp = 0;
  for ( int imap=0; imap<nmap; ++imap ) {
    maps[imap] = mymap;
    exp += memsize_map(maps[imap]);
  }
  mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(exp, mem2-mem1);
  
  msg("vector<string>");
  const int nsvecstr = 100;
  vector<string> mysvec(nsvecstr);
  mem1 = MemoryUsage().total();
  const int nsvec = 1000;
  vector<string> svecs[nsvec];
  exp = 0;
  for ( int ivec=0; ivec<nsvec; ++ivec ) {
    svecs[ivec] = mysvec;
    for ( int ival=0; ival<nsvecstr; ++ival ) {
      strcpy(copy, mystring.c_str());
      svecs[ivec][ival] = copy;
    }
    exp += memsize_vector_string(svecs[ivec]);
  }
  mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(exp, mem2-mem1);

  msg("map<string,string>");
  const int nsmapstr = 100;
  mem1 = MemoryUsage().total();
  const int nsmap = 1000;
  map<string,string> smaps[nsvec];
  exp = 0;
  for ( int imap=0; imap<nsmap; ++imap ) {
    for ( int ival=0; ival<nsmapstr; ++ival ) {
      ostringstream sval;
      ostringstream sval2;
      sval << imap << "-" << ival;
      sval2 << imap << "-" << 2*ival;
      strcpy(copy, sval.str().c_str());
      strcpy(copy2, sval2.str().c_str());
      smaps[imap][copy] = copy2;
    }
    exp += memsize_map_string(smaps[imap]);
  }
  mem2 = MemoryUsage().total();
  cout << mem2 << endl;
  check(exp, mem2-mem1);

  return 0;
}

#ifdef CTEST_MAIN
int main() {
  return memsize_t();
}
#endif