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

#include <fio_CirFileTrans.h>

Inheritance diagram for fio_CirFileTrans:

[legend]

Collaboration diagram for fio_CirFileTrans:

[legend]

List of all members.

Detailed Description

Definition at line 109 of file fio_CirFileTrans.h.


Public Member Functions
	fio_CirFileTrans (bool a_readOnly, const int a_fileID, const cmn_Path a_path, const string a_fileName, const int a_recordSize, const Int16_t a_recordStructVersion, const UInt16_t a_numOfDifVector=1, const UInt16_t a_smallestVectorSize=0x0400)
	Default constructor.
virtual	~fio_CirFileTrans ()
virtual void	SyncRelFileObj ()
	Sync relative file object with data on disk after transaction reply.
ivd_RecordIDX_t	ReadFront (void *a_buffer_p)
	Read first element from circular file and forgot it.
ivd_RecordIDX_t	WriteBack (const void *a_buffer_p, fio_Transaction &a_transaction_p)
	Write new element to circular file.
int	WriteRec (const fio_RecordIDX_t a_index, const void *a_buffer_p, const unsigned int a_numOfRec, fio_Transaction &a_transaction_p)
	update any record in file
int	ReadRec (const fio_RecordIDX_t a_index, void *a_buffer_p, const unsigned int a_numOfRec)
	Read any record from file.
fio_RecordIDX_t	ReadNext (void *a_buffer_p)
	Read next record, use ReadReset to set start position;.
void	ReadNextReset ()
	Set the start position for ReadNext, it is set to first logical record by default.
virtual void	DumpHdr (ostream &os)
	dump header to stream
Public Attributes
	log_CLASSID_m
	readnext block index
Private Member Functions
ivd_RecordIDX_t	NewWriteBackBlock ()
	To have consistent DB sinhronize method, flush all unused record form list to disk.
void	SetRecIndeces ()
ivd_RecordIDX_t	GetRFIdxFromNextBlock ()
	when Idx exceed from block cause of write back, then new idx from next block is got
ivd_RecordIDX_t	GetRNIdxFromNextBlock ()
void	UpdateReadFrontBlockIdx (ivd_RecordIDX_t a_idx, fio_Transaction &a_transaction)
void	UpdateWriteBackBlockIdx (ivd_RecordIDX_t a_idx, fio_Transaction &a_transaction)
void	CheckBlockChain ()
Private Attributes
UInt16_t	m_blockRecordOffset
	ofset of the first record inside block or how much record ocupy block header?
fio_CirFileHeader_t	m_cirFileHdr
	in circular file header are permanent information BackBlockIdx, FrontBlockIdx,
ivd_RecordIDX_t	m_currentWriteBackIdx
	All three block heders have to be acordingly updated when another point to the same block header / memory buffered front block header, fio_CirBlockHeader_t m_frontBlockHead;.
ivd_RecordIDX_t	m_currentReadFrontIdx
	first index that will be pop by ReadFront method
ivd_RecordIDX_t	m_currentReadNextBlockIdx
ivd_RecordIDX_t	m_currentReadNextIdx
cmn_Mutex	m_writeBackIdx_x
	mutex to lock write back index
int	m_writeBackBlockIdxFilePos
int	m_readFrontBlockIdxFilePos
const int	m_buffSize
char *	m_zerroesBuff

Constructor & Destructor Documentation

fio_CirFileTrans::fio_CirFileTrans	(	bool	a_readOnly,
		const int	a_fileID,
		const cmn_Path	a_path,
		const string	a_fileName,
		const int	a_recordSize,
		const Int16_t	a_recordStructVersion,
		const UInt16_t	a_numOfDifVector = `1`,
		const UInt16_t	a_smallestVectorSize = `0x0400`
	)

Default constructor.

Definition at line 122 of file fio_CirFileTrans.cpp.

References c_fio_CirFileHdrPosition, dbg_DETAIL, dbg_NORM, fio_CirFileHeader_t::Dump(), fio_File::GetFileName(), fio_RelFile::Idx2Pos(), ie_CIR_FILE_HEADER_INV, ie_INV_HEADER_POSITION, ivd_NULLCHK_m, log_DBG_m, log_FUNC_m, m_blockRecordOffset, m_buffSize, m_cirFileHdr, m_readFrontBlockIdxFilePos, fio_RelFile::m_smallestVectorSize, m_writeBackBlockIdxFilePos, m_zerroesBuff, fio_File::PosRead(), fio_File::PosWrite(), fio_CirFileHeader_t::readFrontBlockIdx, fio_RelFile::SetFirstNewIDX(), and fio_CirFileHeader_t::writeBackBlockIdx.

00132         :
00133         fio_RelFileTrans(
00134                     a_readOnly,
00135                     a_fileID, 
00136                     a_path, 
00137                     a_fileName, 
00138                     a_recordSize, 
00139                     a_recordStructVersion,
00140                     a_numOfDifVector,
00141                     a_smallestVectorSize,
00142                     false,
00143                     1),    // recommend UV buffer size. exten and sring buffer by 1 vector
00144         // how much records ocupy fio_CirBlockHeader_t
00145         m_blockRecordOffset((sizeof(fio_CirBlockHeader_t) / a_recordSize) + 1),
00146         m_buffSize(a_smallestVectorSize * a_recordSize),
00147         m_zerroesBuff(NULL)
00148 {
00149     log_FUNC_m(fio_CirFileTrans);
00150 
00151     // set buffer with zeroes
00152     m_zerroesBuff = new char[m_buffSize];
00153     static string nullChkMsg("char[m_buffSize]");
00154     ivd_NULLCHK_m(m_zerroesBuff, nullChkMsg);
00155     memset(m_zerroesBuff, 0, m_buffSize);
00156 
00157     
00158     // calculate file possition of write back block index inside CirFileHdr structure
00159     m_writeBackBlockIdxFilePos = c_fio_CirFileHdrPosition + 
00160                                 (char*)&m_cirFileHdr.writeBackBlockIdx -
00161                                 (char*)&m_cirFileHdr;
00162 
00163     // calculate file possition of read front block index inside CirFileHdr structure
00164     m_readFrontBlockIdxFilePos = c_fio_CirFileHdrPosition + 
00165                                 (char*)&m_cirFileHdr.readFrontBlockIdx - 
00166                                 (char*)&m_cirFileHdr;
00167 
00168     if ( sizeof(fio_RelFileHeader_t) >= c_fio_CirFileHdrPosition) {
00169         throw ivd_InternalError(ie_INV_HEADER_POSITION, 
00170             "Circular file header of " + GetFileName() + " overwrite relative file header.", true);
00171     }
00172 
00173     // header created from current constructor parameters
00174     fio_CirFileHeader_t cirFileHdr(m_smallestVectorSize, m_blockRecordOffset);
00175 
00176     fio_CirFileHeader_t nullCirFileHdr;
00177     // header read form file
00178     fio_File::PosRead(c_fio_CirFileHdrPosition, &m_cirFileHdr, sizeof(fio_CirFileHeader_t));
00179     log_DBG_m(dbg_NORM, "Cirkular file header read from file.");
00180     m_cirFileHdr.Dump();
00181     
00182     // check if header form file is null
00183     if (m_cirFileHdr == nullCirFileHdr) { // then new file was created
00184         m_cirFileHdr = cirFileHdr;
00185         log_DBG_m(dbg_DETAIL, " file is new. Set header and first block.");
00186 
00187         // prepare file with one prepared block
00188         // NOTE this is a little triky, cause method NewWriteBackBlock()
00189         // do same think beetter and set all neccessary members,
00190         // BUT need DATABASE and DB is not yet accessible.
00191         ivd_FilePosition_t FirstBlockPos = Idx2Pos(1);
00192         fio_File::PosWrite(FirstBlockPos, m_zerroesBuff, m_buffSize);
00193         SetFirstNewIDX();
00194         m_cirFileHdr.readFrontBlockIdx = 1;
00195         m_cirFileHdr.writeBackBlockIdx = 1;
00196         fio_File::PosWrite(c_fio_CirFileHdrPosition, &m_cirFileHdr, sizeof(fio_CirFileHeader_t));
00197     }
00198     else {
00199         //  match header form file and header constructed by constructor parameters
00200         if (! (m_cirFileHdr == cirFileHdr)) {
00201             throw ivd_InternalError(ie_CIR_FILE_HEADER_INV, 
00202                 "In file " + GetFileName(), true);
00203         }
00204     }
00205 }    
//============================================================================//

Here is the call graph for this function:

fio_CirFileTrans::~fio_CirFileTrans ( ) [virtual]

Definition at line 209 of file fio_CirFileTrans.cpp.

References m_zerroesBuff, and NULL.

00209                                      {
00210     if (m_zerroesBuff != NULL) {
00211         delete [] m_zerroesBuff;
00212     }
00213 }

Member Function Documentation

void fio_CirFileTrans::SyncRelFileObj ( ) [virtual]

Sync relative file object with data on disk after transaction reply.

Reimplemented from fio_RelFileTrans.

Definition at line 216 of file fio_CirFileTrans.cpp.

References c_fio_CirFileHdrPosition, CheckBlockChain(), log_FUNC_m, m_cirFileHdr, fio_File::PosRead(), ReadNextReset(), SetRecIndeces(), and fio_RelFileTrans::SyncRelFileObj().

00216                                       {
00217     log_FUNC_m(SyncRelFileObj);
00218     // sync inherited object first
00219     fio_RelFileTrans::SyncRelFileObj();
00220     // read values from relative file
00221     fio_File::PosRead(c_fio_CirFileHdrPosition, &m_cirFileHdr, sizeof(fio_CirFileHeader_t));
00222     SetRecIndeces();
00223     ReadNextReset();
00224     CheckBlockChain();
00225 }

Here is the call graph for this function:

fio_RecordIDX_t fio_CirFileTrans::ReadFront ( void * a_buffer_p )

Read first element from circular file and forgot it.

Definition at line 253 of file fio_CirFileTrans.cpp.

References dbg_DETAIL, fio_File::GetFileName(), GetRFIdxFromNextBlock(), ie_FILE_ERROR, cmn_Mutex::Lock(), log_DBG_m, log_FUNC_m, m_cirFileHdr, m_currentReadFrontIdx, m_currentReadNextBlockIdx, m_currentReadNextIdx, m_currentWriteBackIdx, fio_RelFile::m_smallestVectorSize, m_writeBackIdx_x, fio_CirFileHeader_t::readFrontBlockIdx, ReadRec(), cmn_Mutex::Unlock(), and fio_CirFileHeader_t::writeBackBlockIdx.

Referenced by hsm_ReleaseCandRec::FindNextRec(), and hsm_ActiveFH::FindNextRec().

00256 {
00257     log_FUNC_m(ReadFront);
00258 
00259     m_writeBackIdx_x.Lock();
00260 
00261     ivd_RecordIDX_t idx = m_currentReadFrontIdx;
00262 
00263     if (++idx >= m_cirFileHdr.readFrontBlockIdx + m_smallestVectorSize) {
00264         idx = GetRFIdxFromNextBlock() + 1;
00265     }
00266 
00267     if (  m_cirFileHdr.writeBackBlockIdx == m_cirFileHdr.readFrontBlockIdx
00268        && m_currentWriteBackIdx == idx) {
00269         m_writeBackIdx_x.Unlock();
00270         log_DBG_m(dbg_DETAIL, " No more data in circular file." << GetFileName());
00271         return 0;  // no data to read
00272     }
00273 
00274     m_writeBackIdx_x.Unlock();  // because of goto
00275     
00276     if (ReadRec(idx, a_buffer_p, 1) != 1) {
00277         throw ivd_InternalError(ie_FILE_ERROR, "Record not read in file " + GetFileName());
00278     }
00279     // data is read now
00280     m_currentReadFrontIdx++;
00281 
00282     if (  m_currentReadNextBlockIdx == m_cirFileHdr.readFrontBlockIdx
00283        && m_currentReadNextIdx      <  m_currentReadFrontIdx) {
00284         m_currentReadNextIdx = m_currentReadFrontIdx;
00285     }
00286 
00287     return idx;
00288 }

Here is the call graph for this function:

Here is the caller graph for this function:

fio_RecordIDX_t fio_CirFileTrans::WriteBack	(	const void *	a_buffer_p,
		fio_Transaction &	a_transaction_p
	)

Write new element to circular file.

Definition at line 228 of file fio_CirFileTrans.cpp.

References ie_FILE_ERROR, cmn_Mutex::Lock(), log_FUNC_m, m_cirFileHdr, m_currentWriteBackIdx, fio_RelFile::m_recordSize, fio_RelFile::m_smallestVectorSize, m_writeBackIdx_x, NewWriteBackBlock(), cmn_Mutex::Unlock(), fio_CirFileHeader_t::writeBackBlockIdx, and WriteRec().

Referenced by hsm_ReleaseCandRec::Append(), and hsm_ActiveFH::Append().

00231 {
00232     log_FUNC_m(WriteBack);
00233 
00234     m_writeBackIdx_x.Lock();
00235 
00236     ivd_RecordIDX_t idx = m_currentWriteBackIdx;
00237 
00238     if (WriteRec(idx, a_buffer_p, 1, a_transaction_p) < (int)m_recordSize) {
00239         throw ivd_InternalError(ie_FILE_ERROR, "Record not written");
00240     }
00241 
00242     m_currentWriteBackIdx++;
00243     if (m_currentWriteBackIdx >= m_cirFileHdr.writeBackBlockIdx + m_smallestVectorSize) {
00244         m_currentWriteBackIdx = NewWriteBackBlock();
00245     }
00246 
00247     m_writeBackIdx_x.Unlock();
00248     return idx;
00249 }

Here is the call graph for this function:

Here is the caller graph for this function:

int fio_CirFileTrans::WriteRec	(	const fio_RecordIDX_t	a_index,
		const void *	a_buffer_p,
		const unsigned int	a_numOfRec,
		fio_Transaction &	a_transaction_p
	)			`[inline]`

update any record in file

Definition at line 196 of file fio_CirFileTrans.h.

References fio_RelFile::WriteRec().

Referenced by hsm_ActiveFH::ActiveToList(), hsm_ReleaseCandRec::FindNextClearCurrRec(), hsm_ActiveFH::FindNextClearCurrRec(), hsm_ActiveFH::OrphanedToMigList(), hsm_ReleaseCandRec::Release(), hsm_ActiveFH::Release(), hsm_ActiveFH::Update(), and WriteBack().

00199                                                          {
00200         return fio_RelFile::WriteRec(a_index, a_buffer_p, a_numOfRec, &a_transaction_p); 
00201     };

Here is the call graph for this function:

Here is the caller graph for this function:

int fio_CirFileTrans::ReadRec	(	const fio_RecordIDX_t	a_index,
		void *	a_buffer_p,
		const unsigned int	a_numOfRec
	)			`[inline]`

Read any record from file.

Reimplemented from fio_RelFile.

Definition at line 205 of file fio_CirFileTrans.h.

References fio_RelFile::ReadRec().

Referenced by hsm_ReleaseCandRec::IsValid(), ReadFront(), and ReadNext().

00207                                                         {
00208         return fio_RelFile::ReadRec(a_index, a_buffer_p, a_numOfRec);
00209     };

Here is the call graph for this function:

Here is the caller graph for this function:

fio_RecordIDX_t fio_CirFileTrans::ReadNext ( void * a_buffer_p )

Read next record, use ReadReset to set start position;.

Definition at line 292 of file fio_CirFileTrans.cpp.

References fio_File::GetFileName(), GetRNIdxFromNextBlock(), ie_FILE_ERROR, cmn_Mutex::Lock(), log_FUNC_m, m_cirFileHdr, m_currentReadNextBlockIdx, m_currentReadNextIdx, m_currentWriteBackIdx, fio_RelFile::m_smallestVectorSize, m_writeBackIdx_x, ReadRec(), cmn_Mutex::Unlock(), and fio_CirFileHeader_t::writeBackBlockIdx.

Referenced by hsm_ActiveFH::ActiveToList(), hdb_Tables::DumpActiveEntries(), hdb_Tables::DumpReleaseCand(), and hsm_ActiveFH::OrphanedToMigList().

00292                                                            {
00293 
00294 
00295     m_writeBackIdx_x.Lock();
00296 
00297     ivd_RecordIDX_t idx = m_currentReadNextIdx;
00298 
00299     if (++idx >= m_currentReadNextBlockIdx + m_smallestVectorSize) {
00300         idx = GetRNIdxFromNextBlock() + 1;
00301     }
00302 
00303     if (  m_cirFileHdr.writeBackBlockIdx == m_currentReadNextBlockIdx
00304        && m_currentWriteBackIdx == idx) {
00305         m_writeBackIdx_x.Unlock();
00306         return 0;  // no data to read
00307     }
00308 
00309 
00310     m_writeBackIdx_x.Unlock();  // because of goto
00311     if (ReadRec(idx, a_buffer_p, 1) != 1) {
00312         log_FUNC_m(ReadNext);
00313         throw ivd_InternalError(ie_FILE_ERROR, "Record not read in file " + GetFileName());
00314     }
00315     m_currentReadNextIdx++;
00316 
00317     return idx;
00318 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_CirFileTrans::ReadNextReset ( )

Set the start position for ReadNext, it is set to first logical record by default.

Definition at line 322 of file fio_CirFileTrans.cpp.

References log_FUNC_m, m_cirFileHdr, m_currentReadFrontIdx, m_currentReadNextBlockIdx, m_currentReadNextIdx, and fio_CirFileHeader_t::readFrontBlockIdx.

Referenced by hsm_ActiveFH::ActiveToList(), hdb_Tables::DumpActiveEntries(), hdb_Tables::DumpReleaseCand(), GetRFIdxFromNextBlock(), hsm_ActiveFH::OrphanedToMigList(), and SyncRelFileObj().

00322                                      {
00323     log_FUNC_m(ReadReset);
00324 
00325     // read block header is same as front header at staru up and reset
00326     m_currentReadNextBlockIdx  = m_cirFileHdr.readFrontBlockIdx;
00327     m_currentReadNextIdx       = m_currentReadFrontIdx;
00328 }

Here is the caller graph for this function:

void fio_CirFileTrans::DumpHdr ( ostream & os ) [virtual]

dump header to stream

Reimplemented from fio_RelFile.

Definition at line 523 of file fio_CirFileTrans.cpp.

References fio_RelFile::DumpHdr(), log_FUNC_m, and m_cirFileHdr.

Referenced by hdb_Tables::DumpActiveEntries().

00523                                           {
00524     log_FUNC_m(DumpHdr);
00525     fio_RelFile::DumpHdr(os);
00526     os << m_cirFileHdr;
00527 }

Here is the call graph for this function:

Here is the caller graph for this function:

ivd_RecordIDX_t fio_CirFileTrans::NewWriteBackBlock ( ) [private]

To have consistent DB sinhronize method, flush all unused record form list to disk.

used by DBLock method;

Definition at line 354 of file fio_CirFileTrans.cpp.

References dbg_DETAIL, fio_Transaction::EndTransaction(), ftt_CIRC_VECT, fio_File::GetFileName(), fio_DataBase::GetTransObj(), fio_RelFileTrans::GetVectorIDX(), fio_RelFile::Idx2Pos(), log_DBG_m, log_FUNC_m, m_blockRecordOffset, m_cirFileHdr, fio_RelFileTrans::m_database_p, fio_RelFile::m_smallestVectorSize, m_zerroesBuff, fio_CirBlockHeader_t::NextBlockIdx, fio_RelFileTrans::PosWrite(), fio_DataBase::ReleaseTransObj(), fio_Transaction::StartTransaction(), UpdateWriteBackBlockIdx(), fio_CirFileHeader_t::writeBackBlockIdx, and fio_RelFile::WriteRec().

Referenced by WriteBack().

00354                                                     {
00355     log_FUNC_m(NewWriteBackBlock);
00356 
00357     fio_Transaction *trans_p = m_database_p->GetTransObj();
00358     trans_p->StartTransaction(ftt_CIRC_VECT);
00359 
00360     fio_CirBlockHeader_t blockHead; // default block header next idx = 0
00361 
00362     blockHead.NextBlockIdx = GetVectorIDX(m_smallestVectorSize, trans_p);
00363     log_DBG_m(dbg_DETAIL, "Got vector on idx " <<  blockHead.NextBlockIdx 
00364                        << " with size " << m_smallestVectorSize
00365                        << " file " << GetFileName());
00366 
00367     // write zeroes to all block
00368     fio_RelFileTrans::WriteRec(blockHead.NextBlockIdx, m_zerroesBuff, m_smallestVectorSize, trans_p);
00369 
00370     // update current WBB header
00371     if (m_cirFileHdr.writeBackBlockIdx != 0) {
00372         fio_RelFileTrans::PosWrite(Idx2Pos(m_cirFileHdr.writeBackBlockIdx), 
00373                                   &blockHead, 
00374                                   sizeof(fio_CirBlockHeader_t),
00375                                   trans_p);
00376     }
00377 
00378     // update WBB index inside circular file header 
00379     UpdateWriteBackBlockIdx(blockHead.NextBlockIdx, *trans_p);
00380 
00381     trans_p->EndTransaction();
00382     m_database_p->ReleaseTransObj(&trans_p);
00383 
00384     return blockHead.NextBlockIdx + m_blockRecordOffset;
00385 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_CirFileTrans::SetRecIndeces ( ) [private]

Definition at line 475 of file fio_CirFileTrans.cpp.

References cmn_Num2Str(), fio_File::GetFileName(), ie_CIR_FILE_HEADER_INV, ivd_NULLCHK_m, log_FUNC_m, m_blockRecordOffset, m_cirFileHdr, m_currentReadFrontIdx, m_currentWriteBackIdx, fio_RelFile::m_recordSize, fio_RelFile::m_smallestVectorSize, fio_CirFileHeader_t::readFrontBlockIdx, fio_RelFile::ReadRec(), and fio_CirFileHeader_t::writeBackBlockIdx.

Referenced by SyncRelFileObj().

00475                                      {
00476     log_FUNC_m(SetIndeces);
00477 
00478     if (   m_cirFileHdr.readFrontBlockIdx == 0
00479         || m_cirFileHdr.writeBackBlockIdx == 0) {
00480 
00481         throw ivd_InternalError(ie_CIR_FILE_HEADER_INV, 
00482           "Can't set record indeces, cause some block index is zero. readFrontBlockIdx " 
00483                   + cmn_Num2Str(m_cirFileHdr.readFrontBlockIdx) 
00484                   + "  writeBackBlockIdx "
00485                   + cmn_Num2Str(m_cirFileHdr.writeBackBlockIdx)
00486                   + " file " + GetFileName());
00487     }
00488 
00489     // find last not zerro record in block, that represent write back index
00490     // last filled rec in block because index is incremented before use
00491     // it is possible that exist emply records in middle of data
00492     
00493     int buffSize = m_smallestVectorSize * m_recordSize;
00494 
00496     char * buff = new char[buffSize];
00497     static string nullChkMsg("char[m_smallestVectorSize * m_recordSize]");
00498     ivd_NULLCHK_m(buff, nullChkMsg);
00499 
00500     // read whole block
00501     fio_RelFileTrans::ReadRec(m_cirFileHdr.writeBackBlockIdx, 
00502                               buff, 
00503                               m_smallestVectorSize);
00504     // last char in buffer;
00505     char *p = buff + buffSize;
00506 
00507     // set guard that block header is not null
00508     buff[m_blockRecordOffset * m_recordSize - 1] = 1;
00509     while ( *--p == 0 ) {
00510         // Empty
00511     }
00512     // block index + idx of first used record (backward) in block + 1 (next is unused)
00513     m_currentWriteBackIdx = m_cirFileHdr.writeBackBlockIdx + (p - buff) / m_recordSize + 1;
00514 
00515     m_currentReadFrontIdx = m_cirFileHdr.readFrontBlockIdx 
00516                           + m_blockRecordOffset - 1;
00517                           
00518     delete [] buff;
00519 }

Here is the call graph for this function:

Here is the caller graph for this function:

ivd_RecordIDX_t fio_CirFileTrans::GetRFIdxFromNextBlock ( ) [private]

when Idx exceed from block cause of write back, then new idx from next block is got

when Idx exceed from block cause of read front, then new idx from next block is got

Definition at line 389 of file fio_CirFileTrans.cpp.

References cmn_Num2Str(), dbg_DETAIL, fio_Transaction::EndTransaction(), ftt_CIRC_VECT, fio_File::GetFileName(), fio_DataBase::GetTransObj(), fio_RelFile::Idx2Pos(), ie_CIR_FILE_HEADER_INV, log_DBG_m, log_FUNC_m, m_blockRecordOffset, m_cirFileHdr, m_currentReadFrontIdx, m_currentReadNextBlockIdx, fio_RelFileTrans::m_database_p, fio_RelFile::m_smallestVectorSize, fio_CirBlockHeader_t::NextBlockIdx, fio_File::PosRead(), fio_CirFileHeader_t::readFrontBlockIdx, ReadNextReset(), fio_DataBase::ReleaseTransObj(), fio_RelFileTrans::ReleaseVectorIdx(), fio_Transaction::StartTransaction(), and UpdateReadFrontBlockIdx().

Referenced by ReadFront().

00389                                                         {
00390     log_FUNC_m(GetRFIdxFromNextBlock);
00391 
00392     bool updateReadNextIdx = m_currentReadNextBlockIdx == m_cirFileHdr.readFrontBlockIdx;
00393     
00394     fio_CirBlockHeader_t blockHead;
00395     ivd_FilePosition_t BHPos = Idx2Pos(m_cirFileHdr.readFrontBlockIdx);
00396 
00397     fio_RelFileTrans::PosRead(BHPos, 
00398                               &blockHead, 
00399                               sizeof(fio_CirBlockHeader_t));
00400 
00401     if (blockHead.NextBlockIdx == 0) {
00402         throw ivd_InternalError(ie_CIR_FILE_HEADER_INV, 
00403                   "Read front circular block header must have next one. " 
00404                   " Block idx = " +
00405                   cmn_Num2Str(m_cirFileHdr.readFrontBlockIdx) +
00406                   " file " + GetFileName());
00407     }
00408     else {
00409         fio_Transaction *trans_p = m_database_p->GetTransObj();
00410         trans_p->StartTransaction(ftt_CIRC_VECT);
00411 
00412         ReleaseVectorIdx(m_cirFileHdr.readFrontBlockIdx, m_smallestVectorSize, trans_p);
00413         log_DBG_m(dbg_DETAIL, "Released vector on idx " <<  m_cirFileHdr.readFrontBlockIdx 
00414                            << " with size " << m_smallestVectorSize
00415                            << " file " << GetFileName());
00416 
00417         UpdateReadFrontBlockIdx(blockHead.NextBlockIdx, *trans_p);        
00418         m_currentReadFrontIdx =  blockHead.NextBlockIdx + m_blockRecordOffset - 1;
00419         
00420         if (updateReadNextIdx) {
00421             ReadNextReset();
00422         }
00423 
00424         trans_p->EndTransaction();
00425         m_database_p->ReleaseTransObj(&trans_p);
00426     }
00427     return m_currentReadFrontIdx;
00428 }

Here is the call graph for this function:

Here is the caller graph for this function:

ivd_RecordIDX_t fio_CirFileTrans::GetRNIdxFromNextBlock ( ) [private]

Definition at line 432 of file fio_CirFileTrans.cpp.

References dbg_DETAIL, fio_File::GetFileName(), fio_RelFile::Idx2Pos(), ie_CIR_FILE_HEADER_INV, log_DBG_m, log_FUNC_m, m_blockRecordOffset, m_currentReadNextBlockIdx, m_currentReadNextIdx, fio_CirBlockHeader_t::NextBlockIdx, and fio_File::PosRead().

Referenced by ReadNext().

00432                                                         {
00433     log_FUNC_m(GetRNIdxFromNextBlock);
00434 
00435     fio_CirBlockHeader_t blockHead;
00436     ivd_FilePosition_t BHPos = Idx2Pos(m_currentReadNextBlockIdx);
00437 
00438     fio_RelFileTrans::PosRead(BHPos, 
00439                               &blockHead, 
00440                               sizeof(fio_CirBlockHeader_t));
00441 
00442     log_DBG_m(dbg_DETAIL, "Read circular block header: "
00443             << " Block idx = " << m_currentReadNextBlockIdx 
00444             << " file pos = " << BHPos
00445             << " File " << GetFileName()
00446             << blockHead);
00447 
00448     if (blockHead.NextBlockIdx == 0) {
00449         ostringstream sstr;
00450         sstr << "Read front circular block header must have next one. " 
00451              << " Block idx = " << m_currentReadNextBlockIdx 
00452              << " file pos = " << BHPos
00453              << " File " << GetFileName()
00454              << blockHead;
00455              
00456         throw ivd_InternalError(ie_CIR_FILE_HEADER_INV, sstr.str());
00457     }
00458     else {
00459 
00460         m_currentReadNextBlockIdx =  blockHead.NextBlockIdx;        
00461         m_currentReadNextIdx      =  blockHead.NextBlockIdx + m_blockRecordOffset - 1;        
00462     }
00463     return m_currentReadNextIdx;
00464 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_CirFileTrans::UpdateReadFrontBlockIdx	(	ivd_RecordIDX_t	a_idx,
		fio_Transaction &	a_transaction
	)			`[private]`

Definition at line 332 of file fio_CirFileTrans.cpp.

References m_cirFileHdr, m_readFrontBlockIdxFilePos, fio_RelFileTrans::PosWrite(), and fio_CirFileHeader_t::readFrontBlockIdx.

Referenced by GetRFIdxFromNextBlock().

00332                                                                                                      {
00333 
00334     m_cirFileHdr.readFrontBlockIdx = a_idx;
00335     fio_RelFileTrans::PosWrite(m_readFrontBlockIdxFilePos, 
00336                                &m_cirFileHdr.readFrontBlockIdx, 
00337                                sizeof(fio_RecordIDX_t),
00338                                &a_transaction);
00339 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_CirFileTrans::UpdateWriteBackBlockIdx	(	ivd_RecordIDX_t	a_idx,
		fio_Transaction &	a_transaction
	)			`[private]`

Definition at line 343 of file fio_CirFileTrans.cpp.

References m_cirFileHdr, m_writeBackBlockIdxFilePos, fio_RelFileTrans::PosWrite(), and fio_CirFileHeader_t::writeBackBlockIdx.

Referenced by NewWriteBackBlock().

00343                                                                                                      {
00344 
00345     m_cirFileHdr.writeBackBlockIdx = a_idx;
00346     fio_RelFileTrans::PosWrite(m_writeBackBlockIdxFilePos, 
00347                                &m_cirFileHdr.writeBackBlockIdx, 
00348                                sizeof(fio_RecordIDX_t),
00349                                &a_transaction);
00350 }

Here is the call graph for this function:

Here is the caller graph for this function:

void fio_CirFileTrans::CheckBlockChain ( ) [private]

Definition at line 530 of file fio_CirFileTrans.cpp.

References cmn_Num2Str(), dbg_DETAIL, fio_File::GetFileName(), fio_RelFile::Idx2Pos(), ie_CIR_FILE_HEADER_INV, log_DBG_m, log_FUNC_m, m_cirFileHdr, fio_RelFile::m_recordSize, fio_CirBlockHeader_t::NextBlockIdx, fio_File::PosRead(), fio_CirFileHeader_t::readFrontBlockIdx, and fio_CirFileHeader_t::writeBackBlockIdx.

Referenced by SyncRelFileObj().

00530                                        {
00531     log_FUNC_m(CheckBlockChain);
00532     
00533     log_DBG_m(dbg_DETAIL, "Check block chain in file " << GetFileName() << endl
00534                       << m_cirFileHdr
00535                       << " size of record = " << m_recordSize
00536                       << " size of fio_CirBlockHeader_t= " << sizeof(fio_CirBlockHeader_t));
00537     log_DBG_m(dbg_DETAIL,  "nextBlkIdx    file pos" );
00538     log_DBG_m(dbg_DETAIL,  "======================");
00539                       
00540     fio_CirBlockHeader_t blockHead;
00541     blockHead.NextBlockIdx = m_cirFileHdr.readFrontBlockIdx;
00542     
00543     
00544     while (  blockHead.NextBlockIdx != m_cirFileHdr.writeBackBlockIdx)  {
00545         ivd_FilePosition_t BHPos = Idx2Pos(blockHead.NextBlockIdx);
00546         
00547         log_DBG_m(dbg_DETAIL, setw(10) << blockHead.NextBlockIdx << setw(12) << BHPos);
00548         
00549         if (blockHead.NextBlockIdx == 0) {
00550             ostringstream sstr;
00551             sstr << "Check block chain in file " << GetFileName() << endl
00552                  << "missing index to next block header." 
00553                  << " Block idx = "
00554                  << cmn_Num2Str(m_cirFileHdr.readFrontBlockIdx)
00555                  << " file " << GetFileName()
00556                  << m_cirFileHdr
00557                  << blockHead;
00558                  
00559             throw ivd_InternalError(ie_CIR_FILE_HEADER_INV, sstr.str());
00560         }
00561         fio_RelFileTrans::PosRead(BHPos, 
00562                                 &blockHead, 
00563                                 sizeof(fio_CirBlockHeader_t));                                
00564     };  
00565     log_DBG_m(dbg_DETAIL, setw(10) << blockHead.NextBlockIdx << setw(12) << Idx2Pos(blockHead.NextBlockIdx));
00566 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

UInt16_t fio_CirFileTrans::m_blockRecordOffset [private]

ofset of the first record inside block or how much record ocupy block header?

Definition at line 134 of file fio_CirFileTrans.h.

Referenced by fio_CirFileTrans(), GetRFIdxFromNextBlock(), GetRNIdxFromNextBlock(), NewWriteBackBlock(), and SetRecIndeces().

fio_CirFileHeader_t fio_CirFileTrans::m_cirFileHdr [private]

in circular file header are permanent information BackBlockIdx, FrontBlockIdx,

See also:: fio_CirFileHeader_t

Definition at line 139 of file fio_CirFileTrans.h.

Referenced by CheckBlockChain(), DumpHdr(), fio_CirFileTrans(), GetRFIdxFromNextBlock(), NewWriteBackBlock(), ReadFront(), ReadNext(), ReadNextReset(), SetRecIndeces(), SyncRelFileObj(), UpdateReadFrontBlockIdx(), UpdateWriteBackBlockIdx(), and WriteBack().

ivd_RecordIDX_t fio_CirFileTrans::m_currentWriteBackIdx [private]

All three block heders have to be acordingly updated when another point to the same block header / memory buffered front block header, fio_CirBlockHeader_t m_frontBlockHead;.

/ memory buffered back block header, fio_CirBlockHeader_t m_backBlockHead;

/ memory buffered sequentialy read block header fio_CirBlockHeader_t m_seqReadBlockHead; index to last write location update by WriteBack method

Definition at line 156 of file fio_CirFileTrans.h.

Referenced by ReadFront(), ReadNext(), SetRecIndeces(), and WriteBack().