Moved boost headers in configcache to source file.

[phys/latlib.git] / hypercache.cpp

diff --git a/hypercache.cpp b/hypercache.cpp
index b025ba69822763723c7478271a1b037538cc861e..26c86266c6d4e827fd067bd233e07719ed7a508d 100644 (file)
--- a/hypercache.cpp
+++ b/hypercache.cpp
@@ -1,111 +1,170 @@
 #include "hypercache.h"
 
 #include "hypercache.h"
 

-configcache *hypercache::O = NULL;
+#include <cstdlib>
+#include <cstring>
+

 configcache *hypercache::C = NULL;
 vector<hypercache::para> hypercache::delayedParaAdd;
 vector<hypercache::para> hypercache::delayedParaSet;
 string hypercache::activeCFile = "";
 vector<unsigned long> hypercache::parentConfigs;
 configcache *hypercache::C = NULL;
 vector<hypercache::para> hypercache::delayedParaAdd;
 vector<hypercache::para> hypercache::delayedParaSet;
 string hypercache::activeCFile = "";
 vector<unsigned long> hypercache::parentConfigs;

-writeout *hypercache::out = NULL;
+ostream* hypercache::log;
+vector<hypercache::observable> hypercache::Os;
+int hypercache::NEQUI;
+int hypercache::NSKIP;
+int hypercache::nequileft;
+pair<int, char*> hypercache::mostEquilibratedConfig;

 
 void hypercache::initCache(configcache **cache,
                           const string& cacheid, const int& nequi, const int& nskip, const string& datadir, 
 
 void hypercache::initCache(configcache **cache,
                           const string& cacheid, const int& nequi, const int& nskip, const string& datadir, 

-                          char **configmem, const int& configMemSize, const int& cachemode, writeout *out_a) {
+                          char **configmem, const int& configMemSize, const int& cachemode, ostream* _log) {
+  if ( _log != NULL )
+    log = _log;

   
   

-  bool allInitBefore = true;
+  *cache = new configcache(cacheid, nequi, nskip, datadir, configmem, configMemSize, cachemode, log);

   
   

-  if (O == NULL || C == NULL)
-    allInitBefore = false;
-
-  if ( out_a != NULL )
-    out = out_a;
+  for (vector<para>::iterator parit=delayedParaAdd.begin(); parit != delayedParaAdd.end(); ++parit)
+    (*cache)->addPara(parit->parid, parit->val);

 
 

-  *cache = new configcache(cacheid, nequi, nskip, datadir, configmem, configMemSize, cachemode, out_a);
+  for (vector<para>::iterator parit=delayedParaSet.begin(); parit != delayedParaSet.end(); ++parit)
+    (*cache)->setPara(parit->parid, parit->val);

 
 

-  if (O != NULL && C != NULL && !allInitBefore) {
-    for (vector<para>::iterator parit=delayedParaAdd.begin(); parit != delayedParaAdd.end(); ++parit) {
-      O->addPara(parit->parid, parit->val);
-      C->addPara(parit->parid, parit->val);
-    }
-    for (vector<para>::iterator parit=delayedParaSet.begin(); parit != delayedParaSet.end(); ++parit) {
-      O->setPara(parit->parid, parit->val);
-      C->setPara(parit->parid, parit->val);
-    }
-  }
+  NEQUI = nequi;
+  NSKIP = nskip;

 }
 
 void hypercache::addPara(const string& parid, const double& val) {
 }
 
 void hypercache::addPara(const string& parid, const double& val) {

-  if (O == NULL || C == NULL) {
-    para newpara; 
-    newpara.parid = parid;
-    newpara.val = val;
-    delayedParaAdd.push_back(newpara);
-  }
-  else {
-    O->addPara(parid, val);
+  para newpara; 
+  newpara.parid = parid;
+  newpara.val = val;
+  delayedParaAdd.push_back(newpara);
+
+  if (C != NULL)

     C->addPara(parid, val);
     C->addPara(parid, val);

-  }
+
+  for (vector<observable>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
+    osit->c->addPara(parid, val);

 }
 
 void hypercache::setPara(const string& parid, const double& val) {
 }
 
 void hypercache::setPara(const string& parid, const double& val) {

-  if (O == NULL || C == NULL) {
-    para newpara; 
-    newpara.parid = parid;
-    newpara.val = val;
-    delayedParaSet.push_back(newpara);
-  }
-  else {
-    O->setPara(parid, val);
+  para newpara; 
+  newpara.parid = parid;
+  newpara.val = val;
+  delayedParaSet.push_back(newpara);
+
+  if (C != NULL)

     C->setPara(parid, val);
     C->setPara(parid, val);

-    activeCFile = "";
-    parentConfigs.clear();
-  }
+  
+  for (vector<observable>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
+    osit->c->setPara(parid, val);
+
+  nequileft = NEQUI;
+  mostEquilibratedConfig.first = NEQUI;

 }
 
 void hypercache::finalize() {
 }
 
 void hypercache::finalize() {

+  for (vector<observable>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
+    delete osit->c;
+  

   delete C;
   delete C;

-  delete O;

 }
 
 string hypercache::fileOfPath(const string& dressedfile) {
   return dressedfile.substr(dressedfile.find_last_of("\\/")+1);
 }
 
 }
 
 string hypercache::fileOfPath(const string& dressedfile) {
   return dressedfile.substr(dressedfile.find_last_of("\\/")+1);
 }
 

-bool hypercache::readC() { 
-  bool readret;
+bool hypercache::readC() {
+  bool readAtLeastOneConfig;
+
+  C->readConfig(&readAtLeastOneConfig, &nequileft, &parentConfigs);

 
 

-  if ( readret = C->readConfig(&parentConfigs) )
+  if ( nequileft < 0 && readAtLeastOneConfig )

     activeCFile = fileOfPath(C->getInFileName());
   else
     activeCFile = "";
 
     activeCFile = fileOfPath(C->getInFileName());
   else
     activeCFile = "";
 

-  return readret; 
+  /* try to find more equilibrated config-file configuration for equilibration in excluded files */
+  if ( ( nequileft >= 0 || ( ! readAtLeastOneConfig ) ) && C->inFilesLeft() > 0 ) {
+    int nEquiLeftBeforeExcludedFileCheck = nequileft;
+    *log << "HYPERCACHE: Trying to find more equilibrated config in excluded files." << endl << flush;
+
+    char *tmpconfig = (char*) malloc(C->getConfigSize());
+
+    while (true) {
+      bool readnewconfig_ex;
+      int nequileftReadConfig_ex;
+
+      memcpy (tmpconfig, C->getConfigMem(), C->getConfigSize());
+      C->readConfig(&readnewconfig_ex, &nequileftReadConfig_ex, NULL);
+
+      if (! readnewconfig_ex) {
+       *log << "HYPERCACHE: No more excluded config-files for possible equilibration available." << endl << flush;
+       break;
+      }
+      
+      if (nequileftReadConfig_ex <= nequileft) {
+       nequileft = nequileftReadConfig_ex;
+       readAtLeastOneConfig = false;
+      }
+      else if (nequileftReadConfig_ex > nequileft) {
+       memcpy (C->getConfigMem(), tmpconfig, C->getConfigSize());
+      }
+    }
+    free(tmpconfig);
+
+    if (nEquiLeftBeforeExcludedFileCheck > nequileft)
+      *log << "HYPERCACHE: Found more equilibrated or same equilibrated excluded config-file configuration for equilibration." << endl << flush;
+    else
+      *log << "HYPERCACHE: Excluded config-file configuration for equilibration is less equilibrated than actual config." << endl << flush;
+  }
+
+  /* storing most equilibrated config */
+  if ( nequileft < mostEquilibratedConfig.first && readAtLeastOneConfig ) {
+    mostEquilibratedConfig.first = nequileft;
+    memcpy(mostEquilibratedConfig.second, C->getConfigMem(), C->getConfigSize());
+  }
+
+  /* injecting back most equilibrated config if nothing could be used anymore */
+  if ( (!readAtLeastOneConfig) && mostEquilibratedConfig.first < nequileft ) {
+    *log << "HYPERCACHE: Injecting back most equilibrated stored config with nequileft = " << mostEquilibratedConfig.first << endl << flush;
+    nequileft = mostEquilibratedConfig.first;
+    memcpy(C->getConfigMem(), mostEquilibratedConfig.second, C->getConfigSize());
+  }
+
+  return readAtLeastOneConfig;

 }
 
 void hypercache::writeC() {
 }
 
 void hypercache::writeC() {

-  C->writeConfig();
+  if (nequileft > 0)
+    nequileft = 0;
+
+   nequileft -= NSKIP;
+
+  C->writeConfig(NEQUI-nequileft-NSKIP);

   activeCFile = fileOfPath( C->getOutFileName().substr( 0, C->getOutFileName().length()-4 ) );
 }
 
   activeCFile = fileOfPath( C->getOutFileName().substr( 0, C->getOutFileName().length()-4 ) );
 }
 

-void hypercache::writeO() {
+void hypercache::writeO(int obsid) {
+  if ( ( Os[obsid].lastWrittenObsEquis + NSKIP != NEQUI-nequileft-NSKIP ) && Os[obsid].c->isOutFileOpen() )
+    Os[obsid].c->finishOutFile();
+

   if ( activeCFile != "" ) {
     unsigned long afilehash = configcache::hash(activeCFile);
   if ( activeCFile != "" ) {
     unsigned long afilehash = configcache::hash(activeCFile);

-    O->writeHeader("concurrent_cfile", (char*)(&afilehash), sizeof(unsigned long));
+    Os[obsid].c->writeHeader("concurrent_cfile", (char*)(&afilehash), sizeof(unsigned long), NEQUI-nequileft-NSKIP);

   }
   }

+  Os[obsid].c->writeConfig(NEQUI-nequileft-NSKIP); 

 
 

-  O->writeConfig(); 
+  Os[obsid].lastWrittenObsEquis = NEQUI-nequileft-NSKIP;

 }
 
 }
 

-bool hypercache::readO() {
-  bool readret;
+void hypercache::readO(int obsid, bool *readNewObsConfig, int *nequiObsLeft) {
+  Os[obsid].c->readConfig(readNewObsConfig, nequiObsLeft);

 
 

-  if ( readret = O->readConfig() ) {
-    unsigned long *parentconfig = (unsigned long*)O->getHeader("concurrent_cfile");
+  if ( *readNewObsConfig && *nequiObsLeft < 0 ) {
+    unsigned long *parentconfig = (unsigned long*)Os[obsid].c->getHeader("concurrent_cfile");

     if ( parentconfig != NULL )
       addParentConfig(parentconfig);
   }
     if ( parentconfig != NULL )
       addParentConfig(parentconfig);
   }

-
-  return readret;

 }
 
 void hypercache::addParentConfig(const unsigned long *parentconfig) {
 }
 
 void hypercache::addParentConfig(const unsigned long *parentconfig) {