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