fio_JourMgr Class Reference
[Classes for large file i/o, relative file, and DataBase]

#include <fio_JourMgr.h>

Collaboration diagram for fio_JourMgr:

Collaboration graph
[legend]

List of all members.

Detailed Description

Definition at line 47 of file fio_JourMgr.h.


Public Member Functions

 fio_JourMgr (fio_DataBase *a_database_p)
virtual ~fio_JourMgr ()
fio_JourHandle * GetJourWriteHandle (ivd_FileBufSize_t a_transSize, bool &a_newJourFile)
 When transaction end event occure than transaction is going to store its data to journal file.
fio_JourHandle * GetJourReadHandle (fio_JourFile *a_jourFile_p, ivd_FilePosition_t a_position)
 When Reply only handle for read is need, but it must be released as write handle, to proper update of PDBI.
void ReleaseJourHandle (fio_JourHandle *s_jourHnd_p)
 At the end of transaction commit the jour handle is going to release.
void ReleaseWaiters ()
void Replay (fio_JourFile &jourFile, ivd_FilePosition_t position, fio_Transaction &trans)
void SetLastSyncPosition (bool a_forced)
void Synchronize ()
 all data on disk are synchronized with memory
void RemoveArhivedJourFile ()

Public Attributes

fio_PermDBinfoMgr m_permDBinfoMgr
 manage permanent DB information
ivd_FileBufSize_t m_changedDataSize
 changed data size of all transaction from last DB commit
int m_numOfTrans
 num of transactions from last DB commit
 log_CLASSID_m

Private Member Functions

void CleanJourHandleListUpTo (fio_JourHandle_p_l_t::iterator iter)
 remove journal handlers from jour hand poiter list up to specified iterator
void AddNewJourFile ()
 When current jour file has exceded minimum size a new one is created.
ivd_TransNumber_t IncTransNumber ()
 return current transaction number and increment it for future

Private Attributes

fio_JourHandle_p_l_t m_jourHandle_p_l
 list of journal handler pointers
fio_DataBase * m_database_p
 pointer to DB
fio_JourFile * m_currentJourFile_p
 current active file
cmn_Mutex m_jourFile_x
 exclusive lock to current journal file
ivd_TransNumber_t m_transNumber
 current available transaction number for use in journal handle
cmn_Mutex m_transNumber_x
 exclusive access to transaction number
ivd_FileID_t m_lastJourFileNumber
 number of last journal got from name
int m_maxWaitersToPDBIUpdate
 how much transaction could wait in list to its info be updatted in PDBI

Constructor & Destructor Documentation

fio_JourMgr::fio_JourMgr ( fio_DataBase *  a_database_p  ) 

Definition at line 47 of file fio_JourMgr.cpp.

References AddNewJourFile(), c_fio_JourFileExt, c_fio_maxWaitersToPDBIUpdate, dbg_NORM, fio_File::GetFileName(), fio_PermDBinfoMgr::GetLastJourFileID(), fio_PermDBinfoMgr::GetLastSyncJourFileID(), fio_PermDBinfoMgr::GetLastSyncPosition(), cmn_DirLst::GetNextName(), fio_DataBase::GetPath(), fio_PermDBinfoMgr::GetPermDBinfo(), fio_DataBase::GetTransObj(), ie_JOUR_FILE_MISSING, fio_JourFile::IncRefCount(), ivd_Error, ivd_NULLCHK_m, fio_JourFile::JourFileName(), fio_JourFile::JourFileNumber(), log_DBG_m, log_FUNC_m, log_WriteEvent(), m_currentJourFile_p, m_database_p, m_lastJourFileNumber, m_maxWaitersToPDBIUpdate, m_permDBinfoMgr, path, fio_DataBase::ReleaseTransObj(), Replay(), and s_className.

00049             :
00050             m_database_p(a_database_p),
00051             m_currentJourFile_p(NULL),
00052             m_transNumber(0),
00053             m_lastJourFileNumber(0),
00054             m_maxWaitersToPDBIUpdate(c_fio_maxWaitersToPDBIUpdate),
00055             m_permDBinfoMgr(false, // never read only mode
00056                             m_database_p->GetDataBaseID(),
00057                             m_database_p->GetPath(),
00058                             "pdbi.ldb"),
00059             m_changedDataSize(0),  //before DB commit
00060             m_numOfTrans(0)         //before DB commit
00061 {
00062     log_FUNC_m(fio_JourMgr);
00063 
00064     cmn_Path path(m_database_p->GetPath());
00065 
00066     list<string> journalFiles_l;
00067 
00068     cmn_DirLst dirList(path, c_fio_JourFileExt);
00069 
00070     string name = dirList.GetNextName();
00071     while  (name.length() > 0) {        // get all journal files from directory
00072         journalFiles_l.push_back(name); // store them to list
00073         name = dirList.GetNextName();
00074     }
00075 
00076     if (journalFiles_l.size() > 0) {   // if already exist journal file(s)
00077         journalFiles_l.sort();         // do a sort 
00078 
00079 
00080 
00081         // only one wait transaction could be in list at Reply
00082         m_maxWaitersToPDBIUpdate = 1;
00083 
00084         ivd_FileID_t lastSyncJourID   = m_permDBinfoMgr.GetLastSyncJourFileID();
00085         if (lastSyncJourID == 0) {
00086             lastSyncJourID = 1;  // Reaply must start from first journal file
00087         }
00088 
00089         ivd_FileID_t lastJourID       = m_permDBinfoMgr.GetLastJourFileID();
00090 
00091         ivd_FileID_t repliedJourID = 0;
00092 
00093         ivd_FilePosition_t position = m_permDBinfoMgr.GetLastSyncPosition();
00094         log_DBG_m(dbg_NORM, "Last sync jourID 0x" << hex << lastSyncJourID << dec
00095                          << ",  position " << position);
00096 
00097         fio_Transaction *trans = m_database_p->GetTransObj();
00098 
00099         list<string>::iterator last = --journalFiles_l.end();
00100         list<string>::iterator p;
00101 
00102         string lastJourFileName = *last;
00103         if (lastJourID > fio_JourFile::JourFileNumber(*last)) {
00104             lastJourFileName = fio_JourFile::JourFileName(lastJourID);
00105         }
00106 
00107         ostringstream errorMessage;
00108         errorMessage << " DB '" << path << "' can not be properly reaplied." << endl
00109             << " The mentioned file and sequence of other journal files up to "
00110             << hex << lastJourFileName << dec
00111             << " are needed to reaply DB." << endl
00112             << " If journal files are no more available then "
00113             << " remove journal directory and restart the system." << endl
00114             << " Some transactions will be lost when removing journal directory."
00115             << " Use check tool to find mismatches.";
00116 
00117         ivd_FileID_t jourFileID = 0;
00118         for (p  = (journalFiles_l.begin());
00119              p !=  journalFiles_l.end(); 
00120              p++) {
00121             jourFileID = fio_JourFile::JourFileNumber(*p);
00122             log_DBG_m(dbg_NORM, "Check jour file '" << fio_JourFile::JourFileName(jourFileID) << "'.");
00123             if (jourFileID >= lastSyncJourID) {
00124 
00125                 if ( repliedJourID == 0) {
00126                     if (jourFileID > lastSyncJourID) {
00127                         ostringstream sstr;
00128                         sstr << "Missing journal file '" << fio_JourFile::JourFileName(lastSyncJourID) << "'." << endl
00129                             << errorMessage.str();
00130                         throw ivd_Error(ie_JOUR_FILE_MISSING,
00131                             sstr.str(), true);
00132                     }
00133                     repliedJourID = jourFileID;
00134                     // write a log
00135                     ostringstream sstr;
00136                     sstr << "Reapply of DB '" << path << "' started at journal file '" << *p
00137                          << "' last needed journal file is '" << lastJourFileName;
00138                     log_WriteEvent(sstr.str());
00139                 }
00140                 else if (++repliedJourID != jourFileID) {
00141                         ostringstream sstr;
00142                         sstr << "Expected journal file '" << fio_JourFile::JourFileName(repliedJourID) << "' not found." << endl
00143                             << errorMessage.str();
00144                             throw ivd_Error(ie_JOUR_FILE_MISSING,
00145                                 sstr.str(), true);
00146                 }
00147 
00148                 fio_JourFile *jf = new fio_JourFile(m_permDBinfoMgr.GetPermDBinfo(),
00149                                                     false,  // never read only mode
00150                                                     jourFileID,
00151                                                     path,
00152                                                    *p);
00153                 ivd_NULLCHK_m(jf, fio_JourFile::s_className);
00154                 if (p == last) {  // use last jour file as active
00155                     m_currentJourFile_p = jf;
00156                     m_currentJourFile_p->IncRefCount();
00157                 }
00158                 // reconstruct UV buffer and reply unfinished transaction 
00159                 Replay(*jf, position, *trans);
00160                 // fix bug 526
00161                 position = 0; // other jour files are read from beginning
00162 
00163                 //if (p != last) { // NOTE removing jf produce corre dump ????
00164                 //    delete jf;
00165                 //}
00166             }
00167         }
00168         if (jourFileID < lastJourID) {
00169             //
00170             //
00171             ostringstream sstr;
00172             sstr << "Expected journal file '" << fio_JourFile::JourFileName(++jourFileID) << "' not found." << endl
00173                 << errorMessage.str();
00174                 throw ivd_Error(ie_JOUR_FILE_MISSING,
00175                     sstr.str(), true);
00176         }
00177 
00178         m_database_p->ReleaseTransObj(&trans);
00179         // when reply is done then set trans waiters to higher value
00180         m_maxWaitersToPDBIUpdate = c_fio_maxWaitersToPDBIUpdate;
00181     }
00182     else {
00183         AddNewJourFile();
00184     }
00185 
00186     m_lastJourFileNumber =  fio_JourFile::JourFileNumber(m_currentJourFile_p->GetFileName());
00187 }
//============================================================================//

Here is the call graph for this function:

fio_JourMgr::~fio_JourMgr (  )  [virtual]

Definition at line 191 of file fio_JourMgr.cpp.

References fio_JourFile::DecRefCount(), log_FUNC_m, m_currentJourFile_p, and NULL.

00191                           {
00192     log_FUNC_m(~fio_JourMgr);
00193 // fix bug 507
00194 // all other jour file are deletted when
00195 // last jourHandle of particular file is deletted too
00196     if (m_currentJourFile_p != NULL) {
00197         m_currentJourFile_p->DecRefCount();
00198     }
00199 // end
00200 }

Here is the call graph for this function:

Member Function Documentation

fio_JourHandle * fio_JourMgr::GetJourWriteHandle ( ivd_FileBufSize_t  a_transSize,
bool &  a_newJourFile 
)

When transaction end event occure than transaction is going to store its data to journal file.

To do that needs journal handle. The jour handle has method to store and read data to jour file. To get a journal handle you need size of transaciton.

Definition at line 204 of file fio_JourMgr.cpp.

References AddNewJourFile(), c_fio_MaxJourSize, fio_JourFile::GetFreeTransPosition(), fio_JourFile::GetJourWriteHandle(), IncTransNumber(), cmn_Mutex::Lock(), m_currentJourFile_p, m_jourFile_x, m_jourHandle_p_l, fio_JourHandle::SetTransNumber(), and cmn_Mutex::Unlock().

Referenced by fio_Transaction::EndTransaction().

00205                                                                      {
00206 //    log_FUNC_m(GetJourWriteHandle);
00207     m_jourFile_x.Lock();
00208     if (m_currentJourFile_p->GetFreeTransPosition() > c_fio_MaxJourSize) {
00209         a_newJourFile = true;
00210         AddNewJourFile();
00211     }
00212     fio_JourHandle *jourHandle = m_currentJourFile_p->GetJourWriteHandle(a_transSize);
00213 
00214     // update journal handle with proper transaction number
00215     jourHandle->SetTransNumber(IncTransNumber());
00216     m_jourHandle_p_l.push_back(jourHandle);
00217     m_jourFile_x.Unlock(); // guarantee sequence of transaction number
00218 
00219     return jourHandle;
00220 }

Here is the call graph for this function:

Here is the caller graph for this function:

fio_JourHandle * fio_JourMgr::GetJourReadHandle ( fio_JourFile *  a_jourFile_p,
ivd_FilePosition_t  a_position 
)

When Reply only handle for read is need, but it must be released as write handle, to proper update of PDBI.

Definition at line 224 of file fio_JourMgr.cpp.

References fio_JourFile::GetJourReadHandle(), cmn_Mutex::Lock(), m_jourFile_x, m_jourHandle_p_l, and cmn_Mutex::Unlock().

Referenced by Replay().

00226                                                 {
00227 //    log_FUNC_m(GetJourReadHandle);
00228     m_jourFile_x.Lock();
00229     fio_JourHandle *jourHandle = a_jourFile_p->GetJourReadHandle(a_position);
00230     m_jourHandle_p_l.push_back(jourHandle);
00231     m_jourFile_x.Unlock(); // guarantee sequence of transaction number
00232 
00233     return jourHandle;
00234 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::ReleaseJourHandle ( fio_JourHandle *  s_jourHnd_p  ) 

At the end of transaction commit the jour handle is going to release.

this even is used to update transaction list of finished transaction and update permanent DB info.

See also:
fio_PermDBinfoMgr

Definition at line 238 of file fio_JourMgr.cpp.

References fio_JourHandle::Release(), and ReleaseWaiters().

Referenced by fio_Transaction::EndTransaction(), and Replay().

00238                                                                {
00239 //    log_FUNC_m(ReleaseJourHandle);
00240 //    log_DBG_m(dbg_NORM, "ReleaseJourHandle");
00241     s_jourHnd_p->Release();
00242     ReleaseWaiters();
00243 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::ReleaseWaiters (  ) 

Definition at line 247 of file fio_JourMgr.cpp.

References CleanJourHandleListUpTo(), fio_DataBase::Commit(), dbg_NORM, fio_JourHandle::GetFileID(), fio_JourHandle::GetLimitPosition(), fio_JourHandle::GetTransNumber(), cmn_Mutex::Lock(), log_DBG_m, log_FUNC_m, m_database_p, m_jourFile_x, m_jourHandle_p_l, m_maxWaitersToPDBIUpdate, m_permDBinfoMgr, fio_PermDBinfoMgr::SetLastTransaction(), and cmn_Mutex::Unlock().

Referenced by ReleaseJourHandle(), and Synchronize().

00247                                  {
00248 //    log_DBG_m(dbg_NORM, "ReleaseWaiters");
00249     m_jourFile_x.Lock();
00250 
00251     // iterate through journal handle pointer list
00252     // and check if all from begin until current are released
00253     // if so, then update PDBI in case this is the last in list
00254     // or there are enought journal handle delayed (it's time to flush)
00255     // otherwise is just set as released.
00257     fio_JourHandle_p_l_t::iterator p;
00258     int relesedWaiters = 0;
00259     for (p  = m_jourHandle_p_l.begin();
00260          p != m_jourHandle_p_l.end();
00261          p++) {
00262         if ((*p)->GetReleased()) {
00263              relesedWaiters++;
00264              continue; // count countinuous realsed journal handles
00265         }
00266         break; // break as soon found one not released
00267     }
00268 //    log_DBG_m(dbg_NORM, "ReleasedWaiters " << relesedWaiters);
00269 
00270     // when enought journal handleas are released then update PDBI
00271     if (relesedWaiters >= m_maxWaitersToPDBIUpdate) {
00272         log_FUNC_m(ReleaseWaiters);
00273         log_DBG_m(dbg_NORM, "Time to commit DB and release waiting journal handles JH."
00274                             " Released JH" << relesedWaiters
00275                             << "  All JH " << m_jourHandle_p_l.size());
00276         m_database_p->Commit();
00277         p--; // get previous iterator that is last released
00278         fio_JourHandle* lastJourHnd_p = *p;
00279         m_permDBinfoMgr.SetLastTransaction(lastJourHnd_p->GetTransNumber(),
00280                                            lastJourHnd_p->GetFileID(),
00281                                            lastJourHnd_p->GetLimitPosition());
00282         p++;  // remove all until next
00283         CleanJourHandleListUpTo(p);
00284     }
00285     m_jourFile_x.Unlock();
00286 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::Replay ( fio_JourFile &  jourFile,
ivd_FilePosition_t  position,
fio_Transaction &  trans 
)

Definition at line 325 of file fio_JourMgr.cpp.

References dbg_DETAIL, fio_JourHandle::GetCurrentPosition(), fio_File::GetFileName(), fio_JourFile::GetFreeTransPosition(), GetJourReadHandle(), fio_PermDBinfoMgr::GetLastTransNumber(), fio_JourHandle::GetTransNumber(), ie_FATAL_ERROR, log_DBG_m, log_FUNC_m, m_permDBinfoMgr, m_transNumber, fio_Transaction::ReadTransactionFromLog(), ReleaseJourHandle(), and fio_JourHandle::SetLastDBTransNum().

Referenced by fio_JourMgr().

00325                                                                                                     {
00326     log_FUNC_m(Replay);
00327 
00328     fio_JourHandle *jourHnd = GetJourReadHandle(&jourFile, position);
00329     // update DB from this transacton further
00330     jourHnd->SetLastDBTransNum(m_permDBinfoMgr.GetLastTransNumber());
00331     
00332     log_DBG_m(dbg_DETAIL, "Reply journal file " << jourFile.GetFileName() 
00333                        << " position " << position 
00334                        << " last trans in DB " << m_permDBinfoMgr.GetLastTransNumber());
00335 
00336     ivd_FilePosition_t fileSize = jourFile.GetFreeTransPosition();
00337     if (fileSize < position) {
00338         ostringstream sstr;
00339         sstr << " Journal file is shorter than expected. Journal file size=" << fileSize
00340              << ", but expected size=" << position << " " << endl
00341              << *jourHnd;
00342 //        log_DBG_m(dbg_DETAIL, sstr.str());
00343         throw ivd_InternalError(ie_FATAL_ERROR, sstr.str());
00344     }
00345     
00346     while (jourHnd->GetCurrentPosition() < fileSize) {
00347         // use jourhandle to proper file position
00348         // update DB from transaction number
00349         // transaction with trans numb < a_transNum is used for UV list build
00350         trans.ReadTransactionFromLog(jourHnd);
00351     }
00352 
00353     ivd_TransNumber_t    transNum = jourHnd->GetTransNumber();
00354     if (transNum > 0) {
00355         m_transNumber = transNum;
00356     }
00357     log_DBG_m(dbg_DETAIL, "Last transaction number = " << m_transNumber);
00358     ReleaseJourHandle(jourHnd);
00359 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::SetLastSyncPosition ( bool  a_forced  ) 

Definition at line 300 of file fio_JourMgr.cpp.

References fio_File::GetFileID(), fio_JourFile::GetFreeTransPosition(), log_FUNC_m, m_currentJourFile_p, m_permDBinfoMgr, fio_PermDBinfoMgr::SetLastSyncPosition(), and Synchronize().

Referenced by fio_DataBase::Synchronize().

00300                                                    {
00301     log_FUNC_m(SetLastSyncPosition);
00302     Synchronize();
00303 //TODO exclusive get of last sync position
00304     m_permDBinfoMgr.SetLastSyncPosition(m_currentJourFile_p->GetFileID(),
00305                                         m_currentJourFile_p->GetFreeTransPosition(),
00306                                         a_forced);
00307 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::Synchronize (  ) 

all data on disk are synchronized with memory

Definition at line 290 of file fio_JourMgr.cpp.

References c_fio_maxWaitersToPDBIUpdate, log_FUNC_m, m_maxWaitersToPDBIUpdate, and ReleaseWaiters().

Referenced by SetLastSyncPosition().

00290                               {
00291     log_FUNC_m(Synchronize);
00292     // Flush all changes to DB and update PDBI
00293     m_maxWaitersToPDBIUpdate = 1;
00294     ReleaseWaiters();
00295     m_maxWaitersToPDBIUpdate = c_fio_maxWaitersToPDBIUpdate;
00296 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::RemoveArhivedJourFile (  ) 

Definition at line 394 of file fio_JourMgr.cpp.

References c_fio_JourFileExt, cmn_File::DeleteFile(), fio_PermDBinfoMgr::GetArhivedSyncJourFileID(), cmn_DirLst::GetNextName(), fio_DataBase::GetPath(), fio_JourFile::JourFileNumber(), m_database_p, m_permDBinfoMgr, and path.

Referenced by fio_DataBase::Continue().

00394                                         {
00395     // get last sink possition
00396     ivd_FileID_t syncJourID = m_permDBinfoMgr.GetArhivedSyncJourFileID();
00397 
00398     if (syncJourID == 0) {
00399         return;
00400     }
00401     
00402     // remove all jour files older than last arhived sync
00403     cmn_Path path = m_database_p->GetPath();
00404     cmn_DirLst dirList(path, c_fio_JourFileExt);
00405 
00406     string name = dirList.GetNextName();
00407     while  (name.length() > 0) {        // get all journal files from directory
00408         ivd_FileID_t jourID = fio_JourFile::JourFileNumber(name);
00409         if (jourID < syncJourID) {
00410             cmn_File::DeleteFile(path + name);
00411         }
00412         name = dirList.GetNextName();
00413     }
00414 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_JourMgr::CleanJourHandleListUpTo ( fio_JourHandle_p_l_t::iterator  iter  )  [private]

remove journal handlers from jour hand poiter list up to specified iterator

Definition at line 311 of file fio_JourMgr.cpp.

References m_jourHandle_p_l.

Referenced by ReleaseWaiters().

00311                                                                            {
00312 //    log_FUNC_m(CleanJourHandleListUpTo);
00313 
00314     fio_JourHandle_p_l_t::iterator p;
00315     for (p  = m_jourHandle_p_l.begin();
00316          p != iter;
00317          p++) {
00318         delete (*p);
00319     }
00320     m_jourHandle_p_l.erase(m_jourHandle_p_l.begin(), iter);
00321 }

Here is the caller graph for this function:

void fio_JourMgr::AddNewJourFile (  )  [private]

When current jour file has exceded minimum size a new one is created.

Definition at line 363 of file fio_JourMgr.cpp.

References fio_JourFile::DecRefCount(), fio_DataBase::GetPath(), fio_PermDBinfoMgr::GetPermDBinfo(), fio_JourFile::IncRefCount(), ivd_NULLCHK_m, log_FUNC_m, m_currentJourFile_p, m_database_p, m_lastJourFileNumber, m_permDBinfoMgr, NULL, and s_className.

Referenced by fio_JourMgr(), and GetJourWriteHandle().

00363                                  {
00364     log_FUNC_m(AddNewJourFile);
00365     m_lastJourFileNumber++;
00366     fio_JourFile *jf = new fio_JourFile(m_permDBinfoMgr.GetPermDBinfo(),
00367                                         false, // never read only mode
00368                                         m_lastJourFileNumber,
00369                                         m_database_p->GetPath());
00370     ivd_NULLCHK_m(jf, fio_JourFile::s_className);
00371 // fix bug 507
00372     if (m_currentJourFile_p != NULL) {
00373         m_currentJourFile_p->DecRefCount(); // old journal file
00374     }
00375     m_currentJourFile_p = jf;
00376     m_currentJourFile_p->IncRefCount(); // new journal file
00377 // end
00378 }

Here is the call graph for this function:

Here is the caller graph for this function:

ivd_TransNumber_t fio_JourMgr::IncTransNumber (  )  [private]

return current transaction number and increment it for future

Definition at line 382 of file fio_JourMgr.cpp.

References cmn_Mutex::Lock(), log_FUNC_m, m_transNumber, m_transNumber_x, and cmn_Mutex::Unlock().

Referenced by GetJourWriteHandle().

00382                                               {
00383     log_FUNC_m(IncTransNumber);
00384 
00385     m_transNumber_x.Lock();
00386     ivd_TransNumber_t tn = ++m_transNumber;
00387     m_transNumber_x.Unlock();
00388 
00389     return tn;
00390 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fio_JourHandle_p_l_t fio_JourMgr::m_jourHandle_p_l [private]

list of journal handler pointers

Definition at line 56 of file fio_JourMgr.h.

Referenced by CleanJourHandleListUpTo(), GetJourReadHandle(), GetJourWriteHandle(), and ReleaseWaiters().

fio_DataBase* fio_JourMgr::m_database_p [private]

pointer to DB

Definition at line 59 of file fio_JourMgr.h.

Referenced by AddNewJourFile(), fio_JourMgr(), ReleaseWaiters(), and RemoveArhivedJourFile().

fio_JourFile* fio_JourMgr::m_currentJourFile_p [private]

current active file

Definition at line 62 of file fio_JourMgr.h.

Referenced by AddNewJourFile(), fio_JourMgr(), GetJourWriteHandle(), SetLastSyncPosition(), and ~fio_JourMgr().

cmn_Mutex fio_JourMgr::m_jourFile_x [private]

exclusive lock to current journal file

Definition at line 65 of file fio_JourMgr.h.

Referenced by GetJourReadHandle(), GetJourWriteHandle(), and ReleaseWaiters().

ivd_TransNumber_t fio_JourMgr::m_transNumber [private]

current available transaction number for use in journal handle

Definition at line 68 of file fio_JourMgr.h.

Referenced by IncTransNumber(), and Replay().

cmn_Mutex fio_JourMgr::m_transNumber_x [private]

exclusive access to transaction number

Definition at line 71 of file fio_JourMgr.h.

Referenced by IncTransNumber().

ivd_FileID_t fio_JourMgr::m_lastJourFileNumber [private]

number of last journal got from name

Definition at line 75 of file fio_JourMgr.h.

Referenced by AddNewJourFile(), and fio_JourMgr().

int fio_JourMgr::m_maxWaitersToPDBIUpdate [private]

how much transaction could wait in list to its info be updatted in PDBI

Definition at line 78 of file fio_JourMgr.h.

Referenced by fio_JourMgr(), ReleaseWaiters(), and Synchronize().

fio_PermDBinfoMgr fio_JourMgr::m_permDBinfoMgr

manage permanent DB information

Definition at line 82 of file fio_JourMgr.h.

Referenced by AddNewJourFile(), fio_JourMgr(), ReleaseWaiters(), RemoveArhivedJourFile(), Replay(), and SetLastSyncPosition().

ivd_FileBufSize_t fio_JourMgr::m_changedDataSize

changed data size of all transaction from last DB commit

Definition at line 85 of file fio_JourMgr.h.

int fio_JourMgr::m_numOfTrans

num of transactions from last DB commit

Definition at line 88 of file fio_JourMgr.h.

fio_JourMgr::log_CLASSID_m

Definition at line 91 of file fio_JourMgr.h.

The documentation for this class was generated from the following files:
Generated on Mon Feb 27 19:16:33 2012 for OPENARCHIVE by  doxygen 1.5.6