hypercache.cpp

   1 #include "hypercache.h"
   2
   3 configcache *hypercache::C = NULL;
   4 vector<hypercache::para> hypercache::delayedParaAdd;
   5 vector<hypercache::para> hypercache::delayedParaSet;
   6 string hypercache::activeCFile = "";
   7 vector<unsigned long> hypercache::parentConfigs;
   8 ostream* hypercache::log;
   9 vector<configcache*> hypercache::Os;
  10 int hypercache::NEQUI;
  11 int hypercache::NSKIP;
  12 int hypercache::nequileft;
  13
  14 void hypercache::initCache(configcache **cache,
  15                            const string& cacheid, const int& nequi, const int& nskip, const string& datadir,
  16                            char **configmem, const int& configMemSize, const int& cachemode, ostream* _log) {
  17   if ( _log != NULL )
  18     log = _log;
  19
  20   *cache = new configcache(cacheid, nequi, nskip, datadir, configmem, configMemSize, cachemode, log);
  21
  22   for (vector<para>::iterator parit=delayedParaAdd.begin(); parit != delayedParaAdd.end(); ++parit)
  23     (*cache)->addPara(parit->parid, parit->val);
  24
  25   for (vector<para>::iterator parit=delayedParaSet.begin(); parit != delayedParaSet.end(); ++parit)
  26     (*cache)->setPara(parit->parid, parit->val);
  27
  28   NEQUI = nequi;
  29   NSKIP = nskip;
  30 }
  31
  32 void hypercache::addPara(const string& parid, const double& val) {
  33   para newpara;
  34   newpara.parid = parid;
  35   newpara.val = val;
  36   delayedParaAdd.push_back(newpara);
  37
  38   if (C != NULL)
  39     C->addPara(parid, val);
  40
  41   for (vector<configcache*>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
  42     (*osit)->addPara(parid, val);
  43 }
  44
  45 void hypercache::setPara(const string& parid, const double& val) {
  46   para newpara;
  47   newpara.parid = parid;
  48   newpara.val = val;
  49   delayedParaSet.push_back(newpara);
  50
  51   if (C != NULL)
  52     C->setPara(parid, val);
  53
  54   for (vector<configcache*>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
  55     (*osit)->setPara(parid, val);
  56
  57   nequileft = NEQUI;
  58 }
  59
  60 void hypercache::finalize() {
  61   for (vector<configcache*>::iterator osit = Os.begin(); osit != Os.end(); ++osit)
  62     delete *osit;
  63
  64   delete C;
  65 }
  66
  67 string hypercache::fileOfPath(const string& dressedfile) {
  68   return dressedfile.substr(dressedfile.find_last_of("\\/")+1);
  69 }
  70
  71 bool hypercache::readC() {
  72   bool readnewconfig_nonex;
  73   int nequileftReadConfig_nonex;
  74   bool readAtLeastOneConfig = false;
  75
  76   C->readConfig(readnewconfig_nonex, nequileftReadConfig_nonex, &parentConfigs);
  77
  78   if (readnewconfig_nonex) {
  79     cout << ":" << nequileftReadConfig_nonex << endl;
  80     nequileft = nequileftReadConfig_nonex;
  81     readAtLeastOneConfig = true;
  82   }
  83
  84   if ( nequileft < 0 && readnewconfig_nonex )
  85     activeCFile = fileOfPath(C->getInFileName());
  86   else
  87     activeCFile = "";
  88
  89   /* try to find more equilibrated config-file configuration for equilibration in excluded files */
  90   if ( nequileft > 0 && C->inFilesLeft() > 0 ) {
  91     *log << "HYPERCACHE: Trying to find more equilibrated config in excluded files." << endl << flush;
  92
  93     char *tmpconfig = (char*) malloc(C->getConfigSize());
  94
  95     while (true) {
  96       bool readnewconfig_ex;
  97       int nequileftReadConfig_ex;
  98
  99       memcpy (tmpconfig, C->getConfigMem(), C->getConfigSize());
 100       C->readConfig(readnewconfig_ex, nequileftReadConfig_ex, NULL);
 101
 102       if (! readnewconfig_ex) {
 103         *log << "HYPERCACHE: No more excluded config-files for possible equilibration available." << endl << flush;
 104         break;
 105       }
 106
 107       if (nequileftReadConfig_ex <= nequileft) {
 108         *log << "HYPERCACHE: Found more equilibrated or same equilibrated excluded config-file configuration for equilibration." << endl << flush;
 109         nequileft = nequileftReadConfig_ex;
 110         readAtLeastOneConfig = true;
 111       }
 112       else if (nequileftReadConfig_ex > nequileft) {
 113         *log << "HYPERCACHE: Excluded config-file configuration for equilibration is less equilibrated than actual config." << endl << flush;
 114         memcpy (C->getConfigMem(), tmpconfig, C->getConfigSize());
 115       }
 116     }
 117     free(tmpconfig);
 118   }
 119
 120   return readAtLeastOneConfig;
 121 }
 122
 123 void hypercache::writeC() {
 124   if (nequileft > 0)
 125     nequileft = 0;
 126
 127    nequileft -= NSKIP;
 128
 129   C->writeConfig(NEQUI-nequileft-NSKIP);
 130   activeCFile = fileOfPath( C->getOutFileName().substr( 0, C->getOutFileName().length()-4 ) );
 131 }
 132
 133 void hypercache::writeO(int obsid, int actnequi) {
 134   if ( activeCFile != "" ) {
 135     unsigned long afilehash = configcache::hash(activeCFile);
 136     Os[obsid]->writeHeader("concurrent_cfile", (char*)(&afilehash), sizeof(unsigned long), actnequi);
 137   }
 138   Os[obsid]->writeConfig(actnequi);
 139 }
 140
 141 void hypercache::readO(int obsid, bool& readnewconfig, int& nequileft) {
 142   Os[obsid]->readConfig(readnewconfig, nequileft);
 143
 144   if ( nequileft < 0 ) {
 145     unsigned long *parentconfig = (unsigned long*)Os[obsid]->getHeader("concurrent_cfile");
 146     if ( parentconfig != NULL )
 147       addParentConfig(parentconfig);
 148   }
 149 }
 150
 151 void hypercache::addParentConfig(const unsigned long *parentconfig) {
 152   for (vector<unsigned long>::iterator parit = parentConfigs.begin(); parit != parentConfigs.end(); ++parit)
 153     if ( *parit == *parentconfig )
 154       return;
 155
 156   parentConfigs.push_back(*parentconfig);
 157 }