// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSK_ISCONN, "ossSocket::isConnected" ) BOOLEAN _ossSocket::isConnected () { INT32 rc = SDB_OK ; PD_TRACE_ENTRY ( SDB_OSSSK_ISCONN ); if ( !_init ) { PD_TRACE_EXIT ( SDB_OSSSK_ISCONN ); return FALSE ; } #if defined (_WINDOWS) rc = ::send ( _fd, "", 0, 0 ) ; if ( SOCKET_ERROR == rc ) #else rc = ::recv ( _fd, NULL, 0, MSG_DONTWAIT ) ; if ( 0 == rc ) #endif { PD_TRACE_EXIT ( SDB_OSSSK_ISCONN ); return FALSE ; } PD_TRACE_EXIT ( SDB_OSSSK_ISCONN ); return TRUE ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__RTNJOBMGR_FINDJOB, "_rtnJobMgr::findJob" ) _rtnBaseJob* _rtnJobMgr::findJob( EDUID eduID, INT32 *pResult ) { PD_TRACE_ENTRY ( SDB__RTNJOBMGR_FINDJOB ) ; { ossScopedLock lock ( &_latch, SHARED ) ; std::map<EDUID, _rtnBaseJob*>::iterator it = _mapJobs.find( eduID ) ; if ( it != _mapJobs.end() ) { PD_TRACE_EXIT ( SDB__RTNJOBMGR_FINDJOB ) ; return it->second ; } } INT32 res = SDB_OK ; { ossScopedLock lock ( &_latch, EXCLUSIVE ) ; std::map<EDUID, INT32>::iterator itRes = _mapResult.find( eduID ) ; if ( itRes != _mapResult.end() ) { res = itRes->second ; _mapResult.erase( itRes ) ; } } if ( pResult ) { *pResult = res ; } PD_TRACE_EXIT ( SDB__RTNJOBMGR_FINDJOB ) ; return NULL ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__PMDEDUCB_GETINFO, "_pmdEDUCB::getInfo" ) const CHAR *_pmdEDUCB::getInfo ( EDU_INFO_TYPE type ) { PD_TRACE_ENTRY ( SDB__PMDEDUCB_GETINFO ); UINT32 buffSize = 0 ; CHAR *buff = _getBuffInfo ( type, buffSize ) ; if ( buff && buff[0] != 0 ) { PD_TRACE_EXIT ( SDB__PMDEDUCB_GETINFO ); return buff ; } PD_TRACE_EXIT ( SDB__PMDEDUCB_GETINFO ); return NULL ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSWLKSTK, "ossWalkStack" ) void ossWalkStack ( UINT32 framesToSkip, OSS_INSTRUCTION_PTR * ppInstruction, UINT32 framesRequested ) { PD_TRACE_ENTRY ( SDB_OSSWLKSTK ); void * syms[ OSS_MAX_BACKTRACE_FRAMES_SUPPORTED + 1 ] = { 0 } ; UINT32 numFrames, framesOnStk, i ; if ( NULL != ppInstruction ) { numFrames = OSS_MIN( framesToSkip + framesRequested, OSS_MAX_BACKTRACE_FRAMES_SUPPORTED ) ; framesOnStk = (UINT32_64)backtrace( syms, numFrames ) ; for ( i = 0 ; i < framesRequested ; i++ ) { ppInstruction[i] = NULL ; } for ( i = 0 ; i < ( framesOnStk - framesToSkip ) ; i++ ) { ppInstruction[i] = ( OSS_INSTRUCTION_PTR )syms[ framesToSkip + i ] ; } } PD_TRACE_EXIT ( SDB_OSSWLKSTK ); }
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSDUMPREGSINFO2, "ossDumpRegistersInfo" ) void ossDumpRegistersInfo( ossSignalContext pContext, ossPrimitiveFileOp * trapFile ) { PD_TRACE_ENTRY ( SDB_OSSDUMPREGSINFO2 ); greg_t * r ; if ( ( NULL != trapFile ) && trapFile->isValid() ) { if ( NULL != pContext ) { r = pContext->uc_mcontext.gregs ; trapFile->fWrite( "Registers:"OSS_NEWLINE "eax %08X ebx %08X ecx %08X edx %08X"OSS_NEWLINE "ebp %08X esp %08X edi %08X esi %08X"OSS_NEWLINE "efl %08X eip %08X"OSS_NEWLINE "cs %04hx ss %04hx ds %04hx " "ss %04hx fs %04hx ds %04hx"OSS_NEWLINE, r[REG_EAX], r[REG_EBX], r[REG_ECX], r[REG_EDX], r[REG_EBP], r[REG_ESP], r[REG_EDI], r[REG_ESI], r[REG_EFL], r[REG_EIP], r[REG_CS], r[REG_SS], r[REG_DS], r[REG_ES], r[REG_FS], r[REG_GS] ) ; } else { trapFile->Write (OSS_NEWLINE"Unable to dump registers"OSS_NEWLINE) ; } } PD_TRACE_EXIT ( SDB_OSSDUMPREGSINFO2 ); }
BOOLEAN isSameFrom( const qgmOPFieldVec & left, const qgmOPFieldVec & right ) { PD_TRACE_ENTRY( SDB__QGMISSAMEFROM ) ; if ( left.size() != right.size() ) { return FALSE ; } UINT32 i = 0 ; while ( i < left.size() ) { qgmOpField field ; if ( ( !right[i].alias.empty() && left[i].value.attr() != right[i].alias ) || ( right[i].alias.empty() && left[i].value.attr() != right[i].value.attr() ) ) { return FALSE ; } ++i ; } PD_TRACE_EXIT( SDB__QGMISSAMEFROM ) ; return TRUE ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_TOTALDATASIZE, "_dmsStorageUnit::totalDataSize" ) INT64 _dmsStorageUnit::totalDataSize( UINT32 type ) const { INT64 totalSize = 0 ; PD_TRACE_ENTRY ( SDB__DMSSU_TOTALDATASIZE ) ; if ( !_pDataSu || !_pIndexSu || !_pLobSu ) { goto done ; } if ( type & DMS_SU_DATA ) { totalSize += ( totalDataPages( DMS_SU_DATA ) << _pDataSu->pageSizeSquareRoot() ) ; } if ( type & DMS_SU_INDEX ) { totalSize += ( totalDataPages( DMS_SU_INDEX ) << _pDataSu->pageSizeSquareRoot() ) ; } if ( ( type & DMS_SU_LOB ) && _pLobSu->isOpened() ) { totalSize += _pLobSu->getLobData()->getDataSz() ; } done: PD_TRACE1 ( SDB__DMSSU_TOTALDATASIZE, PD_PACK_LONG ( totalSize ) ) ; PD_TRACE_EXIT ( SDB__DMSSU_TOTALDATASIZE ) ; return totalSize ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__PSH2SNDQUEUE, "_dpsReplicaLogMgr::_push2SendQueue" ) void _dpsReplicaLogMgr::_push2SendQueue( const dpsPageMeta &allocated ) { PD_TRACE_ENTRY ( SDB__DPSRPCMGR__PSH2SNDQUEUE ); SDB_ASSERT( allocated.valid(), "impossible" ) ; for ( UINT32 i = 0; i < allocated.pageNum; ++i ) { _dpsLogPage *page = PAGE(allocated.beginSub + i) ; if ( 0 == page->getLastSize() ) { if ( !_restoreFlag ) { _queue.push ( page ) ; _queSize.inc() ; } else { _idleSize.add( page->getLength() ); page->clear() ; } } } PD_TRACE_EXIT ( SDB__DPSRPCMGR__PSH2SNDQUEUE ); return ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB_SCOPE_INIT, "Scope::init" ) BOOLEAN Scope::init() { BOOLEAN ret = FALSE ; PD_TRACE_ENTRY ( SDB_SCOPE_INIT ); SDB_ASSERT( globalEngine, "Script engine has not been initialized" ); SDB_ASSERT( ! _context && ! _global, "Can't init a scope twice" ); _context = JS_NewContext( globalEngine->_runtime, 1024 * 1024 ) ; VERIFY( _context ); JS_SetOptions( _context, JSOPTION_VAROBJFIX ); JS_SetVersion( _context, JSVERSION_LATEST ); JS_SetErrorReporter( _context, sdbReportError ); _global = JS_NewCompartmentAndGlobalObject( _context, &global_class, NULL ); VERIFY( _global ); VERIFY( JS_InitStandardClasses( _context, _global ) ); VERIFY( InitDbClasses( _context, _global ) ) ; VERIFY ( SDB_OK == evalInitScripts ( this ) ) ; ret = TRUE ; done : PD_TRACE_EXIT ( SDB_SCOPE_INIT ); return ret ; error : goto done ; }
void migMaster::popFromQueue( pmdEDUCB *eduCB, UINT32 &offset, UINT32 &size, UINT32 &line, UINT32 &column ) { PD_TRACE_ENTRY ( SDB__MIGLOADJSONPS__POPFROMQUEUE ); BOOLEAN isPop = FALSE ; _dataQueue data ; do { isPop = _queue.timed_wait_and_pop ( data, 100 ) ; }while ( !isPop && !eduCB->isInterrupted() && !eduCB->isDisconnected() && !eduCB->isForced() && _sock->isConnected() ) ; if ( isPop ) { offset = data.offset ; size = data.size ; line = data.line ; column = data.column ; } else { offset = 0 ; size = 0 ; line = 0 ; column = 0 ; } PD_TRACE_EXIT ( SDB__MIGLOADJSONPS__POPFROMQUEUE ); }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU, "_dmsStorageUnit::_dmsStorageUnit" ) _dmsStorageUnit::_dmsStorageUnit ( const CHAR *pSUName, UINT32 sequence, INT32 pageSize, INT32 lobPageSize ) :_apm(this), _pDataSu( NULL ), _pIndexSu( NULL ), _pLobSu( NULL ) { PD_TRACE_ENTRY ( SDB__DMSSU ) ; SDB_ASSERT ( pSUName, "name can't be null" ) ; if ( 0 == pageSize ) { pageSize = DMS_PAGE_SIZE_DFT ; } if ( 0 == lobPageSize ) { lobPageSize = DMS_DEFAULT_LOB_PAGE_SZ ; } CHAR dataFileName[DMS_SU_FILENAME_SZ + 1] = {0} ; CHAR idxFileName[DMS_SU_FILENAME_SZ + 1] = {0} ; _storageInfo._pageSize = pageSize ; _storageInfo._lobdPageSize = lobPageSize ; ossStrncpy( _storageInfo._suName, pSUName, DMS_SU_NAME_SZ ) ; _storageInfo._suName[DMS_SU_NAME_SZ] = 0 ; _storageInfo._sequence = sequence ; _storageInfo._secretValue = ossPack32To64( (UINT32)time(NULL), (UINT32)(ossRand()*239641) ) ; ossSnprintf( dataFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s", _storageInfo._suName, sequence, DMS_DATA_SU_EXT_NAME ) ; ossSnprintf( idxFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s", _storageInfo._suName, sequence, DMS_INDEX_SU_EXT_NAME ) ; _pDataSu = SDB_OSS_NEW dmsStorageData( dataFileName, &_storageInfo ) ; if ( _pDataSu ) { _pIndexSu = SDB_OSS_NEW dmsStorageIndex( idxFileName, &_storageInfo, _pDataSu ) ; } if ( NULL != _pDataSu && NULL != _pIndexSu ) { ossMemset( dataFileName, 0, sizeof( dataFileName ) ) ; ossMemset( idxFileName, 0 , sizeof( idxFileName ) ) ; ossSnprintf( dataFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s", _storageInfo._suName, _storageInfo._sequence, DMS_LOB_META_SU_EXT_NAME ) ; ossSnprintf( idxFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s", _storageInfo._suName, _storageInfo._sequence, DMS_LOB_DATA_SU_EXT_NAME ) ; _pLobSu = SDB_OSS_NEW dmsStorageLob( dataFileName, idxFileName, &_storageInfo, _pDataSu ) ; } PD_TRACE_EXIT ( SDB__DMSSU ) ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_COMMITLSN, "_dpsLogWrapper::commitLsn" ) DPS_LSN _dpsLogWrapper::commitLsn() { PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_COMMITLSN ) ; DPS_LSN lsn = _buf.commitLsn() ; PD_TRACE_EXIT( SDB__DPSLGWRAPP_COMMITLSN ) ; return lsn ; }
const MsgRouteID &_clsSrcSelector::selectPrimary ( UINT32 groupID, MSG_ROUTE_SERVICE_TYPE type ) { PD_TRACE_ENTRY ( SDB__CLSSRCSL_SLPMY ) ; if ( _noRes > CLS_FS_NORES_TIMEOUT ) { _src.value = MSG_INVALID_ROUTEID ; } if ( MSG_INVALID_ROUTEID != _src.value ) { goto done ; } { _noRes = 0 ; INT32 rc = SDB_OK ; rc = sdbGetShardCB()->syncUpdateGroupInfo( groupID ) ; if ( SDB_OK != rc ) { goto done ; } _nodeMgrAgent->lock_r () ; _nodeMgrAgent->groupPrimaryNode( groupID, _src, type ) ; _nodeMgrAgent->release_r () ; } done: PD_TRACE_EXIT ( SDB__CLSSRCSL_SLPMY ) ; return _src ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_GETCURRENTLSN, "_dpsLogWrapper::getCurrentLsn" ) DPS_LSN _dpsLogWrapper::getCurrentLsn() { PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_GETCURRENTLSN ) ; DPS_LSN lsn = _buf.currentLsn() ; PD_TRACE_EXIT( SDB__DPSLGWRAPP_GETCURRENTLSN ) ; return lsn ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_TOTALFREEPAGES, "_dmsStorageUnit::totalFreePages" ) INT64 _dmsStorageUnit::totalFreePages ( UINT32 type ) const { INT64 freePages = 0 ; PD_TRACE_ENTRY ( SDB__DMSSU_TOTALFREEPAGES ) ; if ( !_pDataSu || !_pIndexSu || !_pLobSu ) { goto done ; } if ( type & DMS_SU_DATA ) { freePages += (INT64)_pDataSu->freePageNum() ; } if ( type & DMS_SU_INDEX ) { freePages += (INT64)_pIndexSu->freePageNum() ; } if ( ( type & DMS_SU_LOB ) && _pLobSu->isOpened() ) { freePages += (INT64)_pLobSu->freePageNum() ; } done: PD_TRACE1 ( SDB__DMSSU_TOTALFREEPAGES, PD_PACK_INT ( freePages ) ) ; PD_TRACE_EXIT ( SDB__DMSSU_TOTALFREEPAGES ) ; return freePages ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__OSSSK__OSSSK3, "_ossSocket::_ossSocket" ) _ossSocket::_ossSocket ( SOCKET *sock, INT32 timeoutMilli ) { SDB_ASSERT ( sock, "Input sock is NULL" ) ; INT32 rc = SDB_OK ; PD_TRACE_ENTRY ( SDB__OSSSK__OSSSK3 ); _fd = *sock ; _init = TRUE ; _timeout = timeoutMilli ; _closeWhenDestruct = TRUE ; _addressLen = sizeof ( _sockAddress ) ; ossMemset ( &_peerAddress, 0, sizeof(sockaddr_in) ) ; _peerAddressLen = sizeof ( _peerAddress ) ; ossInitSocket() ; rc = getsockname ( _fd, (sockaddr*)&_sockAddress, &_addressLen ) ; if ( rc ) { PD_LOG ( PDERROR, "Failed to getsockname from socket %d", _fd ) ; _init = FALSE ; } else { rc = getpeername ( _fd, (sockaddr*)&_peerAddress, &_peerAddressLen ) ; if ( rc ) { PD_LOG ( PDERROR, "Failed to getpeername from socket %d", _fd ) ; } } setTimeout ( _timeout ) ; PD_TRACE_EXIT ( SDB__OSSSK__OSSSK3 ); }
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSYMINIT, "ossSymInitialize" ) UINT32 ossSymInitialize( HANDLE phProcess, CHAR * pUserSearchPath, BOOLEAN bInvadeProcess ) { PD_TRACE_ENTRY ( SDB_OSSSYMINIT ); static BOOLEAN s_bSymInitialized = false ; UINT32 rc = ERROR_SUCCESS ; WaitForSingleObject( ossGetSysMutexHandle( _SymInitialize ), INFINITE ) ; if ( ! s_bSymInitialized ) { if ( SymInitialize( phProcess, pUserSearchPath, bInvadeProcess ) ) { s_bSymInitialized = TRUE ; } else { rc = GetLastError() ; } } ReleaseMutex ( ossGetSysMutexHandle( _SymInitialize ) ) ; if ( ERROR_SUCCESS != rc ) { SetLastError( rc ) ; } PD_TRACE1 ( SDB_OSSSYMINIT, PD_PACK_UINT(rc) ); PD_TRACE_EXIT ( SDB_OSSSYMINIT ); return rc ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSDMPSYSTM, "ossDumpSystemTime" ) void ossDumpSystemTime( ossPrimitiveFileOp * trapFile ) { PD_TRACE_ENTRY ( SDB_OSSDMPSYSTM ); struct tm otm ; struct timeval tv ; struct timezone tz ; time_t tt ; gettimeofday ( &tv, &tz ) ; tt = tv.tv_sec ; localtime_s ( &otm, &tt ) ; if ( ( NULL != trapFile ) && trapFile->isValid() ) { trapFile->fWrite ( "Timestamp: %04d-%02d-%02d-%02d.%02d.%02d.%06d" OSS_NEWLINE, otm.tm_year+1900, // 1) Year (UINT32) otm.tm_mon+1, // 2) Month (UINT32) otm.tm_mday, // 3) Day (UINT32) otm.tm_hour, // 4) Hour (UINT32) otm.tm_min, // 5) Minute (UINT32) otm.tm_sec, // 6) Second (UINT32) tv.tv_usec // 7) Microsecond (UINT32) ); } PD_TRACE_EXIT ( SDB_OSSDMPSYSTM ); }
const MsgRouteID &_clsSrcSelector::selected( BOOLEAN isFullSync ) { PD_TRACE_ENTRY ( SDB__CLSSRCSL_SLTED ) ; MsgRouteID &id = _src ; if ( _noRes > CLS_FS_NORES_TIMEOUT ) { _src.value = MSG_INVALID_ROUTEID ; } if ( MSG_INVALID_ROUTEID != _src.value ) { goto done ; } _noRes = 0 ; if ( isFullSync ) { id = getFullSyncSrc() ; goto done ; } else { id = getSyncSrc() ; goto done ; } done : PD_TRACE_EXIT ( SDB__CLSSRCSL_SLTED ) ; return id ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_GETSTATINFO, "_dmsStorageUnit::getStatInfo" ) void _dmsStorageUnit::getStatInfo( dmsStorageUnitStat & statInfo ) { PD_TRACE_ENTRY ( SDB__DMSSU_GETSTATINFO ) ; ossMemset( &statInfo, 0, sizeof( dmsStorageUnitStat ) ) ; dmsMBStatInfo *mbStat = NULL ; _pDataSu->_metadataLatch.get_shared() ; dmsStorageData::COLNAME_MAP_IT it = _pDataSu->_collectionNameMap.begin() ; while ( it != _pDataSu->_collectionNameMap.end() ) { mbStat = &_pDataSu->_mbStatInfo[it->second] ; ++statInfo._clNum ; statInfo._totalCount += mbStat->_totalRecords ; statInfo._totalDataPages += mbStat->_totalDataPages ; statInfo._totalIndexPages += mbStat->_totalIndexPages ; statInfo._totalLobPages += mbStat->_totalLobPages ; statInfo._totalDataFreeSpace += mbStat->_totalDataFreeSpace ; statInfo._totalIndexFreeSpace += mbStat->_totalIndexFreeSpace ; ++it ; } _pDataSu->_metadataLatch.release_shared() ; PD_TRACE_EXIT ( SDB__DMSSU_GETSTATINFO ) ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__OPTAPHELP__EVALEST, "_optAccessPlanHelper::_evalEstimation" ) void _optAccessPlanHelper::_evalEstimation ( optCollectionStat *pCollectionStat ) { PD_TRACE_ENTRY( SDB__OPTAPHELP__EVALEST ) ; double predSelectivity = OPT_MTH_DEFAULT_SELECTIVITY ; double scanSelectivity = OPT_MTH_DEFAULT_SELECTIVITY ; double tmpSelectivity = OPT_MTH_DEFAULT_SELECTIVITY ; UINT32 tmpCPUCost = OPT_MTH_DEFAULT_CPU_COST ; if ( getMatchTree() != NULL ) { if ( pCollectionStat ) { predSelectivity = pCollectionStat->evalPredicateSet( _predicateSet, mthEnabledMixCmp(), scanSelectivity ) ; } getMatchTree()->evalEstimation( pCollectionStat, tmpSelectivity, tmpCPUCost ) ; tmpSelectivity *= predSelectivity ; } _estSelectivity = OPT_ROUND_SELECTIVITY( tmpSelectivity ) ; _predSelectivity = OPT_ROUND_SELECTIVITY( predSelectivity ) ; _scanSelectivity = OPT_ROUND_SELECTIVITY( scanSelectivity ) ; _estCPUCost = tmpCPUCost ; _isEstimated = TRUE ; PD_TRACE_EXIT( SDB__OPTAPHELP__EVALEST ) ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_NOTIFY, "_clsSyncManager::notify" ) void _clsSyncManager::notify( const DPS_LSN_OFFSET &offset ) { PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_NOTIFY ) ; SDB_ASSERT( DPS_INVALID_LSN_OFFSET != offset, "offset should not be invalid" ) ; _MsgSyncNotify msg ; msg.header.TID = CLS_TID_REPL_SYC ; _info->mtx.lock_r() ; for ( UINT32 i = 0; i < _validSync ; i++ ) { if ( 0 == _notifyList[i].id.value ) { SDB_ASSERT( FALSE, "impossible" ) ; } else if ( offset == _notifyList[i].offset ) { msg.header.routeID = _notifyList[i].id ; _agent->syncSend( _notifyList[i].id, &msg ) ; } else { } } _info->mtx.release_r() ; PD_TRACE_EXIT ( SDB__CLSSYNCMAG_NOTIFY ) ; return ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__GETSTARTLSN, "_dpsReplicaLogMgr::_getStartLsn" ) DPS_LSN _dpsReplicaLogMgr::_getStartLsn () { PD_TRACE_ENTRY ( SDB__DPSRPCMGR__GETSTARTLSN ); UINT32 begin = _begin ; DPS_LSN lsn ; for ( UINT32 count = 0 ; count < _pageNum; count++ ) { lsn = PAGE(begin)->getBeginLSN () ; if ( !lsn.invalid() ) { goto done ; } if ( begin == _work ) { break ; } begin = _incPageID ( begin ) ; } done : PD_TRACE_EXIT ( SDB__DPSRPCMGR__GETSTARTLSN ); return lsn ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_GETSYNCSRC, "_clsSyncManager::getSyncSrc" ) MsgRouteID _clsSyncManager::getSyncSrc( const set<UINT64> &blacklist ) { PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_GETSYNCSRC ) ; MsgRouteID res ; res.value = MSG_INVALID_ROUTEID ; _info->mtx.lock_r() ; map<UINT64, _clsSharingStatus *>::iterator itr = _info->alives.find( _info->primary.value ) ; if ( _info->alives.end() != itr && CLS_SYNC_STATUS_PEER == itr->second->beat.syncStatus ) { res.value = itr->first ; goto done ; } else { MsgRouteID ids[CLS_SYNC_SET_NUM] ; UINT32 validNum = 0 ; itr = _info->alives.begin() ; for ( ; itr != _info->alives.end(); itr++ ) { if ( CLS_SYNC_STATUS_PEER == itr->second->beat.syncStatus && 0 == blacklist.count( itr->first ) ) { ids[validNum++].value = itr->first ; } } if ( 0 == validNum ) { itr = _info->alives.begin() ; for ( ; itr != _info->alives.end(); itr++ ) { if ( CLS_SYNC_STATUS_RC == itr->second->beat.syncStatus && itr->first != _info->primary.value && 0 == blacklist.count( itr->first )) { ids[validNum++].value = itr->first ; } } if ( 0 != validNum ) { res.value = ids[ossRand() % validNum].value ; } else { res.value = _info->primary.value ; } } else { res.value = ids[ossRand() % validNum].value ; } } done: _info->mtx.release_r() ; PD_TRACE_EXIT ( SDB__CLSSYNCMAG_GETSYNCSRC ) ; return res ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__MRGPAGE, "_dpsReplicaLogMgr::_mergePage" ) void _dpsReplicaLogMgr::_mergePage( const CHAR *src, UINT32 len, UINT32 &workSub, UINT32 &offset ) { PD_TRACE_ENTRY ( SDB__DPSRPCMGR__MRGPAGE ) ; UINT32 needcpy = len ; UINT32 srcOffset = 0 ; UINT32 pageIdle = 0 ; UINT32 cpylen = 0 ; while ( needcpy > 0 ) { dpsLogPage *page = PAGE(workSub) ; pageIdle = page->getBufSize() - offset ; cpylen = pageIdle < needcpy ? pageIdle : needcpy ; page->fill( offset, src + srcOffset, cpylen ) ; needcpy -= cpylen ; srcOffset += cpylen ; offset += cpylen ; if ( offset == page->getBufSize() ) { workSub++ ; offset = 0 ; } } PD_TRACE_EXIT ( SDB__DPSRPCMGR__MRGPAGE ) ; return; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_CUT, "_clsSyncManager::cut" ) void _clsSyncManager::cut( UINT32 alives ) { PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_CUT ) ; SDB_ASSERT( alives <= _validSync, "impossible" ) ; if ( _validSync < alives ) { PD_LOG( PDWARNING, "sync: alives is bigger than valid sync." "[alives:%d][valid:%d]", alives, _validSync ) ; goto done ; } { _clsSyncSession session ; for ( SINT32 i = (SINT32)_validSync - 1 ; i > (SINT32)alives - 1 ; --i ) { _mtxs[i].get() ; while ( SDB_OK == _syncList[i].pop( session ) ) { session.eduCB->getEvent().signal ( SDB_CLS_WAIT_SYNC_FAILED ) ; } _mtxs[i].release() ; } } done: PD_TRACE_EXIT ( SDB__CLSSYNCMAG_CUT ) ; return ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB_CLSCATAMATCHER_ISOPOBJ, "clsCatalogMatcher::isOpObj" ) BOOLEAN clsCatalogMatcher::isOpObj( const bson::BSONObj obj ) { BOOLEAN result = FALSE; PD_TRACE_ENTRY ( SDB_CLSCATAMATCHER_ISOPOBJ ) ; try { BSONObjIterator iter( obj ); while ( iter.more() ) { BSONElement beTmp = iter.next(); const CHAR *pFieldName = beTmp.fieldName(); if ( MTH_OPERATOR_EYECATCHER == pFieldName[0]) { result = TRUE; break; } } } catch ( std::exception &e ) { PD_LOG( PDERROR, "failed to check the obj occured unexpected " "error:%s", e.what() ) ; } PD_TRACE_EXIT ( SDB_CLSCATAMATCHER_ISOPOBJ ) ; return result; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG__WAKE, "_clsSyncManager::_wake" ) void _clsSyncManager::_wake( CLS_WAKE_PLAN &plan ) { PD_TRACE_ENTRY ( SDB__CLSSYNCMAG__WAKE ) ; SDB_ASSERT( plan.size() <= CLS_REPLSET_MAX_NODE_SIZE - 1, "plan size should <= CLS_REPLSET_MAX_NODE_SIZE - 1" ) ; _clsSyncSession session ; UINT32 sub = 0 ; CLS_WAKE_PLAN::reverse_iterator ritr = plan.rbegin(); while ( ritr != plan.rend() ) { DPS_LSN lsn ; lsn.offset = *ritr ; _mtxs[sub].get() ; _checkList[sub] = lsn.offset ; while ( SDB_OK == _syncList[sub].root( session ) ) { if ( 0 < lsn.compareOffset( session.endLsn ) ) { session.eduCB->getEvent().signal ( SDB_OK ) ; _syncList[sub].pop( session ) ; } else { break ; } } _mtxs[sub].release() ; ++ritr ; ++sub ; } PD_TRACE_EXIT ( SDB__CLSSYNCMAG__WAKE ) ; }
BSONObj qgmMerge( const BSONObj &left, const BSONObj &right ) { PD_TRACE_ENTRY( SDB__QGMMERGE ) ; BSONObj obj ; BSONObjBuilder builder ; try { BSONObjIterator itr1( left ) ; while ( itr1.more() ) { builder.append( itr1.next() ) ; } BSONObjIterator itr2( right ) ; while ( itr2.more() ) { builder.append( itr2.next() ) ; } obj = builder.obj() ; } catch ( std::exception &e ) { PD_LOG( PDERROR, "unexpected err happened:%s", e.what() ) ; } PD_TRACE_EXIT( SDB__QGMMERGE ) ; return obj ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_TOTALDATAPAGES, "_dmsStorageUnit::totalDataPages" ) INT64 _dmsStorageUnit::totalDataPages( UINT32 type ) const { INT64 totalDataPages = 0 ; const dmsStorageUnitHeader *dataHeader = NULL ; PD_TRACE_ENTRY ( SDB__DMSSU_TOTALDATAPAGES ) ; if ( !_pDataSu || !_pIndexSu || !_pLobSu ) { goto done ; } if ( type & DMS_SU_DATA ) { dataHeader = _pDataSu->getHeader() ; totalDataPages += dataHeader->_pageNum ; } if ( type & DMS_SU_INDEX ) { dataHeader = _pIndexSu->getHeader() ; totalDataPages += dataHeader->_pageNum ; } if ( ( type & DMS_SU_LOB ) && _pLobSu->isOpened() ) { totalDataPages += _pLobSu->getHeader()->_pageNum ; } done: PD_TRACE1 ( SDB__DMSSU_TOTALDATAPAGES, PD_PACK_LONG ( totalDataPages ) ) ; PD_TRACE_EXIT ( SDB__DMSSU_TOTALDATAPAGES ) ; return totalDataPages ; }