// 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__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 );
 }

   // 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_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;
 }

   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 ;
   }