hsm_JobElemVecMgr Class Reference
[Classes for managing object list]

#include <hsm_joblistmgr.h>

Inheritance diagram for hsm_JobElemVecMgr:

[legend]

Collaboration diagram for hsm_JobElemVecMgr:

[legend]

List of all members.

Detailed Description

Definition at line 91 of file hsm_joblistmgr.h.


Public Member Functions
	hsm_JobElemVecMgr ()
void	Reserve (UInt32_t a_size)
	reserve amount of space for all job's elements
bool	ReleaseElement (UInt32_t a_idx, ivd_FileSize_t a_fileSize)
	release proper job element return true If is already released return false
bool	ReleaseElement (UInt32_t a_idx)
bool	ReleaseElementNoLock (UInt32_t a_idx)
bool	ReleaseJobWithTest ()
	release only if all elements are released
bool	ReleaseJobWithTest (UInt32_t &a_numOfHandledFiles, UInt64_t &a_sizeOfHandledFiles)
void	ReleaseJob ()
	release always
UInt32_t	Insert (hsm_FileHeader *a_fh_p)
hsm_FileHeader *	At (UInt32_t a_jobElemIdx)
	return pointer to job element
UInt32_t	GetNumOfReleasedElem ()
UInt64_t	GetSizeOfHandledFiles ()
UInt32_t	GetNumOfHandledFiles ()
UInt32_t	GetReservedSize ()
ivd_MigrationID_t	GetMigrationID ()
UInt64_t	GetPMJobID ()
void	SetMigJobID (UInt64_t a_pmJobID, ivd_MigrationID_t a_migID)
void	SetJobStatus (hsm_JobStatus_e a_jobStatus)
hsm_JobStatus_e	GetJobStatus ()
void	JobToSequence (i_JobRequestList_t &seqTFileList)
Public Attributes
cmn_Mutex	m_jobElemVecMgr_x
	log_CLASSID_m
Private Attributes
UInt32_t	m_numOfReleasedElem
	number of already released job elements
UInt64_t	m_sizeOfHandledFiles
	The size of data of succeed handled files.
UInt32_t	m_numOfHandledFiles
	The number of succeed handled files.
UInt32_t	m_reservedSize
	the initial vector space real vector size can be extend later by adding dependent FH
ivd_MigrationID_t	m_migID
	vhen used in job list the migrationID is set
UInt64_t	m_pmJobID
	JobID got from partition manager set at reservation.
hsm_JobStatus_e	m_jobStatus

Constructor & Destructor Documentation

hsm_JobElemVecMgr::hsm_JobElemVecMgr ( ) [inline]

Definition at line 93 of file hsm_joblistmgr.h.

00094         :
00095         m_numOfReleasedElem(0),
00096         m_sizeOfHandledFiles(0),
00097         m_numOfHandledFiles(0),
00098         m_reservedSize(0),
00099         m_migID(0),
00100         m_pmJobID(0),
00101         m_jobStatus(hjs_NOTUSED) {
00102         // Empty
00103     };

Member Function Documentation

void hsm_JobElemVecMgr::Reserve ( UInt32_t a_size )

reserve amount of space for all job's elements

Definition at line 43 of file hsm_joblistmgr.cpp.

References log_FUNC_m, m_jobElemVecMgr_x, and m_reservedSize.

00043                                                {
00044     log_FUNC_m(Reserve);
00045 
00046     cmn_MutexLock l(m_jobElemVecMgr_x);
00047     m_reservedSize = a_size;
00048     reserve(a_size);
00049 }

bool hsm_JobElemVecMgr::ReleaseElement	(	UInt32_t	a_idx,
		ivd_FileSize_t	a_fileSize
	)

release proper job element return true If is already released return false

Definition at line 52 of file hsm_joblistmgr.cpp.

References log_FUNC_A_m, m_jobElemVecMgr_x, m_numOfHandledFiles, m_sizeOfHandledFiles, and ReleaseElementNoLock().

Referenced by hsm_JobListMgr::ReleaseElement(), ReleaseElement(), and ReleaseElementNoLock().

00052                                                                                 {
00053     log_FUNC_A_m(ReleaseElement, "a_idx: " << a_idx << ", a_fileSize: " << a_fileSize);
00054 
00055     cmn_MutexLock l(m_jobElemVecMgr_x);
00056     if (ReleaseElementNoLock(a_idx)) {
00057         m_sizeOfHandledFiles += a_fileSize;
00058         ++m_numOfHandledFiles;
00059         return true;
00060     }
00061     return false;
00062 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool hsm_JobElemVecMgr::ReleaseElement ( UInt32_t a_idx )

Definition at line 65 of file hsm_joblistmgr.cpp.

References log_FUNC_m, m_jobElemVecMgr_x, ReleaseElement(), and ReleaseElementNoLock().

00065                                                      {
00066     log_FUNC_m(ReleaseElement);
00067 
00068     cmn_MutexLock l(m_jobElemVecMgr_x);
00069     return ReleaseElementNoLock(a_idx);
00070 }

Here is the call graph for this function:

bool hsm_JobElemVecMgr::ReleaseElementNoLock ( UInt32_t a_idx )

Definition at line 73 of file hsm_joblistmgr.cpp.

References cmn_Num2Str(), hsm_FileHeader::DecrRef(), ie_INVALID_ARG, log_FUNC_m, m_numOfReleasedElem, NULL, ReleaseElement(), and size.

Referenced by ReleaseElement().

00073                                                            {
00074     log_FUNC_m(ReleaseElementNoLock);
00075 
00076     UInt32_t elemNum = size();
00077 
00078     if ( a_idx >= elemNum ) {
00079         log_FUNC_m(ReleaseElement);
00080         throw ivd_InternalError(ie_INVALID_ARG, 
00081             "Job element vector index exceed vector size. " + cmn_Num2Str(a_idx), true);
00082     }
00083 
00084     hsm_FileHeader* fh_p = operator[](a_idx);
00085     if (fh_p != NULL) {
00086         fh_p->DecrRef();
00087         operator[](a_idx)  = NULL;
00088         ++m_numOfReleasedElem;
00089         return true;  
00090     }
00091     return false;
00092 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool hsm_JobElemVecMgr::ReleaseJobWithTest ( )

release only if all elements are released

Definition at line 95 of file hsm_joblistmgr.cpp.

References log_FUNC_m, m_jobElemVecMgr_x, NULL, and ReleaseJob().

Referenced by hsm_JobListMgr::ReleaseJobIdxWithTest(), and ReleaseJobWithTest().

00095                                            {
00096     log_FUNC_m(ReleaseJobWithTest);
00097 
00098     cmn_MutexLock l(m_jobElemVecMgr_x);
00099     for (hsm_JobElem_v_i iter = begin(); iter != end(); iter++) {
00100         if (*iter != NULL) {
00101             return false;
00102         }
00103     }
00104     ReleaseJob();
00105     return true;
00106 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool hsm_JobElemVecMgr::ReleaseJobWithTest	(	UInt32_t &	a_numOfHandledFiles,
		UInt64_t &	a_sizeOfHandledFiles
	)

Definition at line 109 of file hsm_joblistmgr.cpp.

References log_FUNC_m, m_jobElemVecMgr_x, m_numOfHandledFiles, m_sizeOfHandledFiles, NULL, ReleaseJob(), and ReleaseJobWithTest().

00110                                                                            {
00111     log_FUNC_m(ReleaseJobWithTest);
00112 
00113     cmn_MutexLock l(m_jobElemVecMgr_x);
00114     for (hsm_JobElem_v_i iter = begin(); iter != end(); iter++) {
00115         if (*iter != NULL) {
00116             return false;
00117         }
00118     }
00119     a_numOfHandledFiles  = m_numOfHandledFiles;
00120     a_sizeOfHandledFiles = m_sizeOfHandledFiles;
00121     ReleaseJob();
00122     return true;
00123 }

Here is the call graph for this function:

void hsm_JobElemVecMgr::ReleaseJob ( )

release always

Definition at line 126 of file hsm_joblistmgr.cpp.

References hjs_NOTUSED, log_FUNC_m, m_jobStatus, m_migID, m_numOfHandledFiles, m_numOfReleasedElem, m_pmJobID, m_reservedSize, and m_sizeOfHandledFiles.

Referenced by ReleaseJobWithTest().

00126                                    {
00127     log_FUNC_m(ReleaseJob);
00128 
00129     m_reservedSize = m_numOfReleasedElem = 0;
00130     m_sizeOfHandledFiles = 0;
00131     m_numOfHandledFiles  = 0;
00132     m_migID        = 0;
00133     m_pmJobID      = 0;
00134     m_jobStatus    = hjs_NOTUSED;
00135     clear();
00136 }

Here is the caller graph for this function:

UInt32_t hsm_JobElemVecMgr::Insert ( hsm_FileHeader * a_fh_p )

Definition at line 140 of file hsm_joblistmgr.cpp.

References hsm_FileHeader::IncrRef(), log_FUNC_m, m_jobElemVecMgr_x, push_back(), and size.

00140                                                          {
00141     log_FUNC_m(Insert);
00142 
00143     cmn_MutexLock l(m_jobElemVecMgr_x);
00144     Int32_t idx = size();
00145 //    a_fh_p->SetJobElemIdx(static_cast<Int32_t>(size()));
00146     
00147     push_back(a_fh_p);
00148     a_fh_p->IncrRef();    
00149     return idx;
00150 }

Here is the call graph for this function:

hsm_FileHeader * hsm_JobElemVecMgr::At ( UInt32_t a_jobElemIdx )

return pointer to job element

Definition at line 153 of file hsm_joblistmgr.cpp.

References cmn_Num2Str(), ie_HSM_INVJOBELEMIDX, log_FUNC_m, and size.

Referenced by i_HSM_i::CompleteMigration(), i_HSM_i::DoMigrationJob(), i_HSM_i::EfficientRecall(), hsm_Recall::IsFileFromDFforRecall(), and i_HSM_i::Recall().

00153                                                            {
00154     log_FUNC_m(At);
00155 
00156     if (size() > a_jobElemIdx) {
00157         return at(a_jobElemIdx);
00158     }
00159     else {
00160         throw ivd_InternalError(ie_HSM_INVJOBELEMIDX, 
00161             "JobElemIdx " + cmn_Num2Str(a_jobElemIdx) +
00162             "  VecSize " + cmn_Num2Str(size()), true);
00163     }
00164 }

Here is the call graph for this function:

Here is the caller graph for this function:

UInt32_t hsm_JobElemVecMgr::GetNumOfReleasedElem ( ) [inline]

Definition at line 158 of file hsm_joblistmgr.h.

References m_numOfReleasedElem.

00158 { return m_numOfReleasedElem; };

UInt64_t hsm_JobElemVecMgr::GetSizeOfHandledFiles ( ) [inline]

Definition at line 160 of file hsm_joblistmgr.h.

References m_sizeOfHandledFiles.

00160 { return m_sizeOfHandledFiles; };

UInt32_t hsm_JobElemVecMgr::GetNumOfHandledFiles ( ) [inline]

Definition at line 161 of file hsm_joblistmgr.h.

References m_numOfHandledFiles.

00161 { return m_numOfHandledFiles; };

UInt32_t hsm_JobElemVecMgr::GetReservedSize ( ) [inline]

Definition at line 163 of file hsm_joblistmgr.h.

References m_reservedSize.

00163 { return m_reservedSize; };

ivd_MigrationID_t hsm_JobElemVecMgr::GetMigrationID ( ) [inline]

Definition at line 165 of file hsm_joblistmgr.h.

References m_migID.

Referenced by hsm_JobListMgr::MigrateFailedJob().

00165 { return m_migID;};

Here is the caller graph for this function:

UInt64_t hsm_JobElemVecMgr::GetPMJobID ( ) [inline]

Definition at line 167 of file hsm_joblistmgr.h.

References m_pmJobID.

00167 { return m_pmJobID;};

void hsm_JobElemVecMgr::SetMigJobID	(	UInt64_t	a_pmJobID,
		ivd_MigrationID_t	a_migID
	)

Definition at line 167 of file hsm_joblistmgr.cpp.

References log_FUNC_m, m_migID, and m_pmJobID.

Referenced by i_HSM_i::DoMigrationJob(), and hsm_JobListMgr::MigrateFailedJob().

00167                                                                                  {
00168     log_FUNC_m(SetMigJobID);
00169 
00170     m_migID   = a_migID;
00171     m_pmJobID = a_pmJobID;
00172 }

Here is the caller graph for this function:

void hsm_JobElemVecMgr::SetJobStatus ( hsm_JobStatus_e a_jobStatus )

Definition at line 175 of file hsm_joblistmgr.cpp.

References log_FUNC_m, m_jobElemVecMgr_x, and m_jobStatus.

Referenced by i_HSM_i::CompleteMigration(), i_HSM_i::DoMigrationJob(), and hsm_JobListMgr::MigrateFailedJob().

00175                                                                 {
00176     log_FUNC_m(SetJobStatus);
00177 
00178     cmn_MutexLock l(m_jobElemVecMgr_x);
00179     m_jobStatus = a_jobStatus;
00180 }

Here is the caller graph for this function:

hsm_JobStatus_e hsm_JobElemVecMgr::GetJobStatus ( ) [inline]

Definition at line 171 of file hsm_joblistmgr.h.

References m_jobStatus.

Referenced by hsm_JobListMgr::MigrateFailedJob().

00171 { return m_jobStatus;};

Here is the caller graph for this function:

void hsm_JobElemVecMgr::JobToSequence ( i_JobRequestList_t & seqTFileList )

Definition at line 183 of file hsm_joblistmgr.cpp.

References dbg_DETAIL, hsm_FileHeader::FileToSeqElem(), g_hsm_fhLock, hsm_FileHeader::GetInode(), hsm_ListPos::GetJobElemIdx(), cmn_Mutex::Lock(), log_DBG_m, log_FUNC_m, m_jobElemVecMgr_x, NULL, size, and cmn_Mutex::Unlock().

Referenced by hsm_JobListMgr::MigrateFailedJob().

00183                                                                       {
00184     log_FUNC_m(MigrateFailedJob);
00185 
00186     m_jobElemVecMgr_x.Lock();    
00187     int jobSize = size();
00188     seqTFileList.length(jobSize);
00189 
00190     UInt32_t    numfiles = 0;
00191 
00192     hsm_FileHeader** ip = &*begin();
00193     hsm_FileHeader** ep = &*end();
00194     for (; ip != ep; ++ip) {
00195         hsm_FileHeader &fh = (**ip);
00196         if (&fh == NULL) {
00197             log_DBG_m(dbg_DETAIL, "fh == NULL. Changed in meantime.");
00198             continue; // probably moved to dirty list
00199         }
00200         ivd_GenInode_t inode = fh.GetInode();
00201         if (!g_hsm_fhLock.CanLockByID(inode)) {
00202             log_DBG_m(dbg_DETAIL, "Already locked.");
00203             continue;  // can't use this FH already locked (changed), so skip it,
00204         }
00205         m_jobElemVecMgr_x.Unlock();
00206         if (fh.GetJobElemIdx() == -1 ) {
00207             log_DBG_m(dbg_DETAIL, "Element idx == -1. No more in job list.");
00208             g_hsm_fhLock.UnLockByID(inode);
00209             continue; // probably moved to dirty list            
00210         }
00211         fh.FileToSeqElem(seqTFileList[numfiles++]);            
00212         g_hsm_fhLock.UnLockByID(inode);
00213         m_jobElemVecMgr_x.Lock();    
00214     }
00215     m_jobElemVecMgr_x.Unlock();
00216     seqTFileList.length(numfiles);
00217 }