Possibility to set the CDB manager in snapshot mode, that is, after looking in the...
authorrgrosso <rgrosso@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 31 Jan 2012 21:01:26 +0000 (21:01 +0000)
committerrgrosso <rgrosso@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 31 Jan 2012 21:01:26 +0000 (21:01 +0000)
and before looking, as fallback, in the storage, look at the snapshot file.
Get
|
->Get from cache -> OK
|
->Get from snapshot ->OK
|
->Get from the storage -> OK
|
->Fatal
This will allow to use partially a snapshot, increasing the memory only for the needed entries.
In order to make this possible, DumpToSnapshotFile has to be called with singleKeys=kFALSE (when
creating the snapshot).

STEER/CDB/AliCDBManager.cxx
STEER/CDB/AliCDBManager.h
STEER/STEER/AliReconstruction.cxx
STEER/STEER/AliSimulation.cxx
STEER/STEER/AliSimulation.h

index 6550c49..e3a3bec 100644 (file)
@@ -101,7 +101,7 @@ void AliCDBManager::InitFromCache(TMap *entryCache, Int_t run) {
 }
 
 //_____________________________________________________________________________
-void  AliCDBManager::DumpToSnapshotFile(const char* snapshotFileName){
+void  AliCDBManager::DumpToSnapshotFile(const char* snapshotFileName, Bool_t singleKeys){
 // 
 // dump the entries map and the ids list to
 // the output file
@@ -118,8 +118,25 @@ void  AliCDBManager::DumpToSnapshotFile(const char* snapshotFileName){
 
     f->cd();                                                                                           
 
-    f->WriteObject(&fEntryCache,"CDBentriesMap");
-    f->WriteObject(fIds,"CDBidsList");
+    if(singleKeys){
+       f->WriteObject(&fEntryCache,"CDBentriesMap");
+       f->WriteObject(fIds,"CDBidsList");
+    }else{
+       // We write the entries one by one named by their calibration path
+       /*
+       fEntryCache.Write("CDBentriesMap");
+       fIds->Write("CDBidsList");
+       */
+       TIter iter(fEntryCache.GetTable());
+       TPair* pair = 0;
+       while((pair = dynamic_cast<TPair*> (iter.Next()))){
+           TObjString *os = dynamic_cast<TObjString*>(pair->Key());
+           TString path = os->GetString();
+           AliCDBEntry *entry = dynamic_cast<AliCDBEntry*>(pair->Value());
+           path.ReplaceAll("/","*");
+           entry->Write(path.Data());
+       }
+    }
     f->Close();
     delete f;
 
@@ -280,6 +297,10 @@ AliCDBManager::AliCDBManager():
   fRun(-1),
   fCache(kTRUE),
   fLock(kFALSE),
+  fSnapshotMode(kFALSE),
+  fSnapshotFile(0),
+//  fSnapshotCache(0),
+//  fSnapshotIdsList(0),
   fRaw(kFALSE),
   fStartRunLHCPeriod(-1),
   fEndRunLHCPeriod(-1),
@@ -312,6 +333,12 @@ AliCDBManager::~AliCDBManager() {
        delete fCondParam;
        delete fRefParam;
        delete fShortLived; fShortLived = 0x0;
+       //fSnapshotCache = 0;
+       //fSnapshotIdsList = 0;
+       if(fSnapshotMode){
+           fSnapshotFile->Close();
+           fSnapshotFile = 0;
+       }
 }
 
 //_____________________________________________________________________________
@@ -813,27 +840,40 @@ AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) {
        // first look into map of cached objects
        if(fCache && query.GetFirstRun() == fRun)
                entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
-
        if(entry) {
                AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data()));
                return entry;
        }
 
+       // if snapshot flag is set, try getting from the snapshot
+       if(fSnapshotMode && query.GetFirstRun() == fRun)
+           // entry = (AliCDBEntry*) fSnapshotCache->GetValue(query.GetPath()); // not possible,
+           // all the map would be charged in memory from the snapshot anyway.
+           entry = GetEntryFromSnapshot(query.GetPath());
+       if(entry) {
+               AliDebug(2, Form("Object %s retrieved from the snapshot !!",query.GetPath().Data()));
+               if(query.GetFirstRun() == fRun) // no need to check fCache, fSnapshotMode not possible otherwise
+                   CacheEntry(query.GetPath(), entry);
+
+               if(!fIds->Contains(&entry->GetId()))
+                   fIds->Add(entry->GetId().Clone());
+
+               return entry;
+       }
+
+       // Entry is not in cache (and, in case we are in snapshot mode, not in the snapshot either)
+       // => retrieve it from the storage and cache it!!
        if(!fDefaultStorage) {
                AliError("No storage set!");
                return NULL;
        }
-       // Entry is not in cache -> retrieve it from CDB and cache it!!
        AliCDBStorage *aStorage=0;
        AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
-//     Bool_t usedDefStorage=kTRUE;
 
        if(aPar) {
                aStorage=GetStorage(aPar);
                TString str = aPar->GetURI();
                AliDebug(2,Form("Looking into storage: %s",str.Data()));
-//             usedDefStorage=kFALSE;
-
        } else {
                aStorage=GetDefaultStorage();
                AliDebug(2,"Looking into default storage");
@@ -855,6 +895,81 @@ AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) {
 }
 
 //_____________________________________________________________________________
+AliCDBEntry* AliCDBManager::GetEntryFromSnapshot(const char* path) {
+    // get the entry from the open snapshot file
+
+    TString sPath(path);
+    sPath.ReplaceAll("/","*");
+    AliCDBEntry *entry = dynamic_cast<AliCDBEntry*>(fSnapshotFile->Get(sPath.Data()));
+    if(!entry){
+       AliDebug(2,Form("Cannot get a CDB entry for \"%s\" from snapshot file",path));
+       return 0;
+    }
+
+    return entry;
+}
+
+//_____________________________________________________________________________
+Bool_t AliCDBManager::SetSnapshotMode(const char* snapshotFileName) {
+// set the manager in snapshot mode
+    
+    if(!fCache){
+       AliError("Cannot set the CDB manage in snapshot mode if the cache is not active!");
+       return kFALSE;
+    }
+
+    fSnapshotMode = kTRUE;
+
+    //open snapshot file
+    TString snapshotFile(snapshotFileName);
+    if(snapshotFile.BeginsWith("alien://")){
+       if(!gGrid) {
+           TGrid::Connect("alien://","");
+           if(!gGrid) {
+               AliError("Connection to alien failed!");
+               return kFALSE;
+           }
+       }
+    }
+
+    fSnapshotFile = TFile::Open(snapshotFileName);
+    if (!fSnapshotFile || fSnapshotFile->IsZombie()){
+       AliError(Form("Cannot open file %s",snapshotFileName));
+       return kFALSE;
+    }
+
+    /*
+    // retrieve pointer to entries' map from snapshot file
+    TIter next(fSnapshotFile->GetListOfKeys());
+    TKey *key;
+    while ((key = (TKey*)next())) {
+       if (strcmp(key->GetClassName(),"TMap") != 0) continue;
+       fSnapshotCache = (TMap*)key->ReadObj();
+       break;
+    }
+    if (!fSnapshotCache || fSnapshotCache->GetEntries()==0){
+       AliError("Cannot get valid map of CDB entries from snapshot file");
+       return kFALSE;
+    }
+
+    // retrieve pointer to ids' list from snapshot file
+    TIter nextKey(fSnapshotFile->GetListOfKeys());
+    TKey *keyN;
+    while ((keyN = (TKey*)nextKey())) {
+       if (strcmp(keyN->GetClassName(),"TList") != 0) continue;
+       fSnapshotIdsList = (TList*)keyN->ReadObj();
+       break;
+    }
+    if (!fSnapshotIdsList || fSnapshotIdsList->GetEntries()==0){
+       AliError("Cannot get valid list of CDB entries from snapshot file");
+       return kFALSE;
+    }
+    */
+    return kTRUE;
+
+}
+
+//_____________________________________________________________________________
 const char* AliCDBManager::GetURI(const char* path) {
 // return the URI of the storage where to look for path
 
index 8ec144f..2ceecd0 100644 (file)
@@ -14,6 +14,7 @@
 #include <TList.h>
 #include <TMap.h>
 #include <TSystem.h>
+#include <TFile.h>
 
 class AliCDBEntry;
 class AliCDBId;
@@ -76,6 +77,7 @@ class AliCDBManager: public TObject {
                                Int_t version = -1, Int_t subVersion = -1);
        AliCDBEntry* Get(const AliCDBPath& path, const AliCDBRunRange& runRange,
                                 Int_t version = -1, Int_t subVersion = -1);
+       AliCDBEntry* GetEntryFromSnapshot(const char* path);
 
        const char* GetURI(const char* path);                            
                                 
@@ -128,7 +130,9 @@ class AliCDBManager: public TObject {
        void Init();
        void InitFromCache(TMap *entryCache, Int_t run);
        Bool_t InitFromSnapshot(const char* snapshotFileName, Bool_t overwrite=kTRUE);
-       void DumpToSnapshotFile(const char* snapshotFileName);
+       Bool_t SetSnapshotMode(const char* snapshotFileName="OCDB.root");
+       void UnsetSnapshotMode() {fSnapshotMode=kFALSE;}
+       void DumpToSnapshotFile(const char* snapshotFileName, Bool_t singleKeys);
   
 protected:
 
@@ -177,6 +181,11 @@ protected:
        Bool_t fCache;                  //! The cache flag
        Bool_t fLock;   //! Lock flag, if ON default storage and run number cannot be reset
 
+        Bool_t fSnapshotMode;           //! flag saying if we are in snapshot mode
+       //TMap* fSnapshotCache;         //! pointer to the cache of objects in the snapshot
+       //TList* fSnapshotIdsList;        //! pointer to the list of the object Id's in the snapshot
+       TFile *fSnapshotFile;
+
        Bool_t fRaw;   // flag to say whether we are in the raw case
        Int_t fStartRunLHCPeriod; // 1st run of the LHC period set
        Int_t fEndRunLHCPeriod;   // last run of the LHC period set
index 55124e1..3e5caea 100644 (file)
@@ -1599,7 +1599,7 @@ void AliReconstruction::Begin(TTree *)
   AliSysInfo::AddStamp("InitRecoParams");
 
   if(toCDBSnapshot)
-      AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data());
+      AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
   AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
   AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
 
index 223f6a1..8e42d58 100644 (file)
@@ -769,7 +769,7 @@ Bool_t AliSimulation::Run(Int_t nEvents)
          snapshotFileOut = snapshotFile;
       else 
          snapshotFileOut="OCDB.root"; 
-      AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data()); 
+      AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE); 
   }
 
   // Cleanup of CDB manager: cache and active storages!
index fbddd9c..94c0dcb 100644 (file)
@@ -82,6 +82,7 @@ public:
   void SetDefaultStorage(const char* uri);
   void SetSpecificStorage(const char* calibType, const char* uri);
   void SetFromCDBSnapshot(const char* snapshotFileName) {fFromCDBSnapshot = kTRUE; fSnapshotFileName=snapshotFileName;}
+  void SetSnapshotMode(const char* snapshotFileName) {AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName);}
   void UnSetFromCDBSnapshot() {fFromCDBSnapshot = kFALSE;}
 
   virtual Bool_t Run(Int_t nEvents = 0);