// PD_TRACE_DECLARE_FUNCTION( SDB__QGMPTRTABLE_GETOWNATTR, "_qgmPtrTable::getOwnAttr" )
   INT32 _qgmPtrTable::getOwnAttr( const CHAR *begin,
                                   UINT32 size,
                                   qgmDbAttr &attr )
   {
      INT32 rc = SDB_OK ;

      PD_TRACE_ENTRY( SDB__QGMPTRTABLE_GETOWNATTR ) ;

      UINT32 pos = 0 ;
      BOOLEAN hasDot = qgmUtilFirstDot( begin, size, pos ) ;
      if ( hasDot && ( 0 == pos || size - 1 == pos ) )
      {
         PD_LOG( PDERROR,
                 "the first char and the last char can not be '.'" ) ;
         rc = SDB_INVALIDARG ;
         goto error ;
      }

      if ( hasDot )
      {
         rc = getOwnField( begin, pos, attr.relegation() ) ;
         if ( SDB_OK != rc )
         {
            goto error ;
         }
         ++pos ;
      }

      rc = getOwnField( begin + pos, size - pos, attr.attr() ) ;
      if ( SDB_OK != rc )
      {
         goto error ;
      }

   done:
      PD_TRACE_EXITRC( SDB__QGMPTRTABLE_GETOWNATTR, rc ) ;
      return rc ;
   error:
      goto done ;
   }

   INT32 _qgmPlScan::_executeOnCoord( _pmdEDUCB *eduCB )
   {
      PD_TRACE_ENTRY( SDB__QGMPLSCAN__EXECONCOORD ) ;
      INT32 rc = SDB_OK ;
      INT32 bufSize = 0 ;
      CHAR *qMsg = NULL ;
      MsgOpReply dummyReply ;
      BSONObj *err = NULL ;
      BSONObj selector = _selector.selector() ;

      rc = msgBuildQueryMsg ( &qMsg, &bufSize,
                              _collection.toString().c_str(),0,
                              0, _skip, _return,
                              &_condition, &selector,
                              &_orderby, &_hint ) ;

      if ( SDB_OK != rc )
      {
         goto error ;
      }

      rc = _coordQuery.execute ( qMsg, *(SINT32*)qMsg, eduCB,
                                 dummyReply, NULL ) ;
      SDB_ASSERT( NULL == err, "impossible" ) ;
      PD_RC_CHECK ( rc, PDERROR,
                    "Failed to execute coordQuery, rc = %d", rc ) ;

      _contextID = dummyReply.contextID ;

   done:
      if ( NULL != qMsg )
      {
         SDB_OSS_FREE( qMsg ) ;
         qMsg = NULL ;
      }
      PD_TRACE_EXITRC( SDB__QGMPLSCAN__EXECONCOORD, rc ) ;
      return rc ;
   error:
      goto done ;
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB_RTNCOORDCLOSELOB_EXECUTE, "rtnCoordCloseLob::execute" )
   INT32 rtnCoordCloseLob::execute( CHAR *pReceiveBuffer, SINT32 packSize,
                                    CHAR **ppResultBuffer, pmdEDUCB *cb,
                                    MsgOpReply &replyHeader,
                                    BSONObj** ppErrorObj )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY( SDB_RTNCOORDCLOSELOB_EXECUTE ) ;
      const MsgOpLob *header = NULL ;
      const MsgHeader *baseHeader = ( const MsgHeader * )pReceiveBuffer ;

      replyHeader.header.messageLength = sizeof( MsgOpReply ) ;
      replyHeader.header.opCode = MSG_BS_LOB_CLOSE_RES ;
      replyHeader.header.requestID = baseHeader->requestID ;
      replyHeader.header.routeID.value = 0 ;
      replyHeader.header.TID = baseHeader->TID ;
      replyHeader.contextID = -1 ;
      replyHeader.flags = SDB_OK ;
      replyHeader.numReturned = 0 ;
      replyHeader.startFrom = 0 ;

      rc = msgExtractCloseLobRequest( pReceiveBuffer, &header ) ;
      if ( SDB_OK != rc )
      {
         PD_LOG( PDERROR, "failed to extract msg:%d", rc ) ;
         goto error ;
      } 

      rc = rtnCloseLob( header->contextID, cb ) ;
      if ( SDB_OK != rc )
      {
         PD_LOG( PDERROR, "failed to close lob:%d", rc ) ;
         goto error ;
      }
   done:
      PD_TRACE_EXITRC( SDB_RTNCOORDCLOSELOB_EXECUTE, rc ) ;
      return rc ;
   error:
      replyHeader.flags = rc ;
      goto done ;
   }

// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSK__GETADDR, "ossSocket::_getAddress" )
INT32 _ossSocket::_getAddress ( sockaddr_in *addr, CHAR *pAddress,
                                UINT32 length )
{
   INT32 rc = SDB_OK ;
   PD_TRACE_ENTRY ( SDB_OSSSK__GETADDR );

   length = length < NI_MAXHOST ? length : NI_MAXHOST ;
   rc = getnameinfo ( (struct sockaddr *)addr, sizeof(sockaddr), pAddress,
                      length, NULL, 0, NI_NUMERICHOST ) ;
   if ( rc )
   {
      PD_LOG ( PDERROR, "Failed to getnameinfo, rc = %d",
               SOCKET_GETLASTERROR ) ;
      rc = SDB_NETWORK ;
      goto error ;
   }
done :
   PD_TRACE_EXITRC ( SDB_OSSSK__GETADDR, rc );
   return rc ;
error :
   goto done ;
}

   // PD_TRACE_DECLARE_FUNCTION ( SDB_NETMLTRTAGT_SYNCSENDWITHOUTSESSION, "netMultiRouteAgent::syncSendWithoutSession" )
   INT32 netMultiRouteAgent::syncSendWithoutCheck( const MsgRouteID &id, void *header,
                                                   UINT64 &reqID, pmdEDUCB *pEduCB,
                                                   void *body, UINT32 bodyLen )
   {
      INT32 rc = SDB_OK;
      PD_TRACE_ENTRY ( SDB_NETMLTRTAGT_SYNCSENDWITHOUTSESSION );
      MsgHeader *pHeader = (MsgHeader *)header ;

      CoordSession *pSession = NULL;
      if ( pEduCB )
      {
         pHeader->TID = pEduCB->getTID();
         pSession = pEduCB->getCoordSession();
         SDB_ASSERT( pSession, "pSession can't be NULL!" ) ;
         pSession->addSubSessionWithoutCheck( id );
      }
      reqID = _pReqID->inc();
      pHeader->requestID = reqID;
      pHeader->routeID.value = MSG_INVALID_ROUTEID ;

      PD_LOG ( PDDEBUG, "Send request to node(opCode=%d, requestID=%llu, "
               "TID=%u, groupID=%u, nodeID=%u, serviceID=%u)",
               pHeader->opCode, pHeader->requestID, pHeader->TID,
               id.columns.groupID, id.columns.nodeID, id.columns.serviceID );
      if ( !body )
      {
         rc = _pNetWork->syncSend( id, header );
      }
      else
      {
         rc = _pNetWork->syncSend( id, pHeader, body, bodyLen ) ;
      }
      if ( SDB_OK == rc && pSession )
      {
         pSession->addRequest( reqID, id );
      }
      return rc;
      PD_TRACE_EXITRC ( SDB_NETMLTRTAGT_SYNCSENDWITHOUTSESSION, rc );
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB_RTNLOCALLOBSTREAM__ENSURELOB, "_rtnLocalLobStream::_ensureLob" )
   INT32 _rtnLocalLobStream::_ensureLob( _pmdEDUCB *cb,
                                         _dmsLobMeta &meta,
                                         BOOLEAN &isNew )
   {
      INT32 rc = SDB_OK ;
      _dmsLobMeta tmpMeta ;
      PD_TRACE_ENTRY( SDB_RTNLOCALLOBSTREAM__ENSURELOB ) ;

      rc = _su->lob()->getLobMeta( getOID(), _mbContext,
                                   cb, tmpMeta ) ;
      if ( SDB_OK == rc )
      {
         if ( !tmpMeta.isDone() )
         {
            PD_LOG( PDINFO, "Lob[%s] meta[%s] is not available",
                    getOID().str().c_str(), tmpMeta.toString().c_str() ) ;
            rc = SDB_LOB_IS_NOT_AVAILABLE ;
            goto error ;
         }
         isNew = FALSE ;
         goto done ;
      }
      else if ( SDB_FNE != rc )
      {
         PD_LOG( PDERROR, "Failed to get meta of lob, rc:%d", rc ) ;
         goto error ;
      }
      else
      {
         rc = SDB_OK ;
         isNew = TRUE ;
      }

   done:
      PD_TRACE_EXITRC( SDB_RTNLOCALLOBSTREAM__ENSURELOB, rc ) ;
      return rc ;
   error:
      goto done ;
   }

INT32 _dpsLogPage::fill( UINT32 offset, const CHAR *src, UINT32 len )
{
    INT32 rc = SDB_OK ;
    PD_TRACE_ENTRY ( SDB__DPSLGPAGE );
    if ( !_mb )
    {
        _mb = SDB_OSS_NEW _dpsMessageBlock( DPS_DEFAULT_PAGE_SIZE );
        if ( NULL == _mb )
        {
            pdLog(PDERROR, __FUNC__, __FILE__, __LINE__,
                  "new _dpsMessageBlock failed!");
            rc = SDB_OOM ;
            goto error ;
        }
    }
    ossMemcpy ( _mb->offset( offset ), src, len ) ;
done :
    PD_TRACE_EXITRC ( SDB__DPSLGPAGE, rc );
    return rc ;
error :
    goto done ;
}

 // PD_TRACE_DECLARE_FUNCTION ( SDB__DMSROUNIT_IMPMME, "_dmsReorgUnit::importMME" )
 INT32 _dmsReorgUnit::importMME ( const CHAR *pMME )
 {
    INT32 rc = SDB_OK ;
    PD_TRACE_ENTRY ( SDB__DMSROUNIT_IMPMME );
    SDB_ASSERT ( pMME, "pMME can't be NULL" ) ;
    INT32 restSize = DMS_MB_SIZE ;
    INT64 writeSize = 0 ;
    INT32 bufSize = restSize ;
    if ( _readOnly )
    {
       PD_LOG ( PDERROR, "Modify is not allowed" ) ;
       rc = SDB_DMS_REORG_FILE_READONLY ;
       goto error ;
    }
    rc = ossSeek ( &_file, _headSize, OSS_SEEK_SET ) ;
    if ( rc )
    {
       PD_LOG ( PDERROR, "Failed to seek to %d from file %s, rc = %d",
                _headSize, _fileName, rc ) ;
       goto error ;
    }
    while ( restSize != 0 )
    {
       rc = ossWrite ( &_file, &pMME[bufSize-restSize], restSize, &writeSize ) ;
       if ( rc && SDB_INTERRUPT != rc )
       {
          PD_LOG ( PDERROR, "Failed to write MME into file: %s, rc = %d",
                   _fileName, rc ) ;
          goto error ;
       }
       restSize -= (INT32)writeSize ;
       rc = SDB_OK ;
    }
 done :
    PD_TRACE_EXITRC ( SDB__DMSROUNIT_IMPMME, rc );
    return rc ;
 error :
    goto done ;
 }

   INT32 _qgmPlNLJoin::_init()
   {
      PD_TRACE_ENTRY( SDB__QGMPLNLJOIN__INIT ) ;
      INT32 rc = SDB_OK ;

      SDB_ASSERT( SQL_GRAMMAR::SQLMAX != _joinType,
                  "impossible" ) ;
      SDB_ASSERT( 2 == inputSize(), "impossible" ) ;
      if ( SQL_GRAMMAR::R_OUTERJOIN == _joinType )
      {
         _joinType = SQL_GRAMMAR::L_OUTERJOIN ;
         _outerAlias = &(input( 1 )->alias()) ;
         _outer = input( 1 ) ;
         _innerAlias = &(input( 0 )->alias()) ;
         _inner = input( 0 ) ;
      }
      else
      {
         _outerAlias = &(input( 0 )->alias()) ;
         _outer = input( 0 ) ;
         _innerAlias = &(input( 1 )->alias()) ;
         _inner = input( 1 ) ;
      }

      _innerF = SDB_OSS_NEW qgmFetchOut() ;
      if ( NULL == _innerF )
      {
         PD_LOG( PDERROR, "failed to allocate mem." ) ;
         rc = SDB_OOM ;
         goto error ;
      }

      _makeOuterInner = TRUE ;
   done:
      PD_TRACE_EXITRC( SDB__QGMPLNLJOIN__INIT, rc ) ;
      return rc ;
   error:
      goto done ;
   }

// PD_TRACE_DECLARE_FUNCTION ( SDB_GETEXECNM, "getExecutableName" )
static INT32 getExecutableName ( const CHAR * exeName ,
                                 CHAR * buf ,
                                 UINT32 bufSize )
{
   INT32 rc = SDB_OK ;
   PD_TRACE_ENTRY ( SDB_GETEXECNM );

   SDB_ASSERT ( exeName && buf && bufSize > 0 , "invalid argument" ) ;

   try
   {
      string strName = exeName ;
      string strEnd  = ".exe" ;
      if ( strName.length() <= strEnd.length() ||
           0 != strName.compare ( strName.length() - strEnd.length() ,
                                  strEnd.length() , strEnd ) )
      {
         strName += strEnd ;
      }

      if ( strName.length() >= bufSize )
      {
         rc = SDB_INVALIDSIZE ;
         goto error ;
      }
      ossStrcpy ( buf , strName.c_str() ) ;
   }
   catch ( std::bad_alloc & )
   {
      rc = SDB_OOM ;
      goto error ;
   }

done :
   PD_TRACE_EXITRC ( SDB_GETEXECNM, rc );
   return rc ;
error :
   goto done ;
}

   // PD_TRACE_DECLARE_FUNCTION( SDB__UTILCOMPRESSORSNAPPY_COMPRESS, "_utilCompressorSnappy::compress")
   INT32 _utilCompressorSnappy::compress( const CHAR *source, UINT32 sourceLen,
                                          CHAR *dest, UINT32 &destLen,
                                          const utilDictHandle dictionary,
                                          const utilCompressStrategy *strategy )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY( SDB__UTILCOMPRESSORSNAPPY_COMPRESS ) ;
      size_t resultLen = 0 ;
      (void)dictionary ;
      (void)strategy ;

      SDB_ASSERT( UTIL_INVALID_DICT == dictionary,
                  "snappy does not use any dictionary" ) ;
      SDB_ASSERT( destLen >= (UINT32)snappy::MaxCompressedLength( sourceLen ),
                  "Buffer for decompressed data is not big enough" ) ;

      snappy::RawCompress ( source, (size_t)sourceLen, dest, &resultLen ) ;
      destLen = ( UINT32 )resultLen ;

      PD_TRACE_EXITRC( SDB__UTILCOMPRESSORSNAPPY_COMPRESS, rc ) ;
      return rc ;
   }

   INT32 restAdaptor::init( INT32 maxHttpHeaderSize,
                            INT32 maxHttpBodySize,
                            INT32 timeout )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY( SDB__RESTADP_INIT );

      http_parser_settings *pSettings = NULL ;

      pSettings = (http_parser_settings *)SDB_OSS_MALLOC(
            sizeof( http_parser_settings ) ) ;
      if ( !pSettings )
      {
         rc = SDB_OOM ;
         PD_LOG ( PDERROR, "Unable to allocate %d bytes memory",
                  sizeof( http_parser_settings ) ) ;
         goto error ;
      }

      ossMemset( pSettings, 0, sizeof( http_parser_settings ) ) ;
      pSettings->on_message_begin    = restAdaptor::on_message_begin ;
      pSettings->on_url              = restAdaptor::on_url ;
      pSettings->on_header_field     = restAdaptor::on_header_field ;
      pSettings->on_header_value     = restAdaptor::on_header_value ;
      pSettings->on_headers_complete = restAdaptor::on_headers_complete ;
      pSettings->on_body             = restAdaptor::on_body ;
      pSettings->on_message_complete = restAdaptor::on_message_complete ;

      _maxHttpHeaderSize = maxHttpHeaderSize ;
      _maxHttpBodySize = maxHttpBodySize ;
      _timeout = timeout ;
      _pSettings = pSettings ;

   done:
      PD_TRACE_EXITRC ( SDB__RESTADP_INIT, rc ) ;
      return rc ;
   error:
      goto done ;
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_COMPLETEOPR, "_dpsLogWrapper::completeOpr" )
   INT32 _dpsLogWrapper::completeOpr( _pmdEDUCB * cb, INT32 w )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_COMPLETEOPR ) ;

      if ( w > 1 && cb && 0 != cb->getLsnCount() &&
           _vecEventHandler.size() > 0 )
      {
         for( UINT32 i = 0 ; i < _vecEventHandler.size() ; ++i )
         {
            rc = _vecEventHandler[i]->onCompleteOpr( cb, w ) ;
            if ( rc )
            {
               break ;
            }
         }
         cb->resetLsn() ;
      }

      PD_TRACE_EXITRC ( SDB__DPSLGWRAPP_COMPLETEOPR, rc ) ;
      return rc ;
   }

   // PD_TRACE_DECLARE_FUNCTION( SDB__QGMPLCOMMAND__FETCHNEXT, "_qgmPlCommand::_fetchNext" )
   INT32 _qgmPlCommand::_fetchNext( qgmFetchOut &next )
   {
      PD_TRACE_ENTRY( SDB__QGMPLCOMMAND__FETCHNEXT ) ;
      INT32 rc = SDB_OK ;

      rtnContextBuf buffObj ;
      SDB_RTNCB *rtnCB = pmdGetKRCB()->getRTNCB() ;

      rc = rtnGetMore( _contextID, 1, buffObj, _eduCB, rtnCB ) ;
      if ( SDB_OK != rc )
      {
         if ( SDB_DMS_EOC != rc )
         {
            PD_LOG( PDERROR, "Failed to getmore from non-coord, rc = %d",
                    rc) ;
         }
         goto error ;
      }

      try
      {
         next.obj = BSONObj( buffObj.data() ) ;
      }
      catch ( std::exception &e )
      {
         PD_LOG( PDERROR, "unexcepted err happened:%s", e.what() ) ;
         rc = SDB_SYS ;
         goto error ;
      }

   done:
      PD_TRACE_EXITRC( SDB__QGMPLCOMMAND__FETCHNEXT, rc ) ;
      return rc ;
   error:
      if ( SDB_DMS_EOC == rc )
         _contextID = -1 ;
      goto done ;
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB__SDB_DMSCB_DROPCSP1, "_SDB_DMSCB::dropCollectionSpaceP1" )
   INT32 _SDB_DMSCB::dropCollectionSpaceP1 ( const CHAR *pName, _pmdEDUCB *cb,
                                             SDB_DPSCB *dpsCB )
   {
      INT32 rc = SDB_OK ;

      PD_TRACE_ENTRY ( SDB__SDB_DMSCB_DROPCSP1 ) ;
      if ( !pName )
      {
         rc = SDB_INVALIDARG ;
         goto error ;
      }
      {
         _mutex.get_shared() ;
         SDB_DMS_CSCB *cscb = NULL;
         rc = _CSCBNameLookup( pName, &cscb ) ;
         if ( rc )
         {
            _mutex.release_shared() ;
            goto error ;
         }
         dmsStorageUnit *su = cscb->_su ;
         SDB_ASSERT ( su, "storage unit pointer can't be NULL" ) ;

         _mutex.release_shared() ;
         rc = _CSCBNameRemoveP1( pName, cb, dpsCB ) ;
         if ( rc )
         {
            PD_LOG( PDERROR, "Failed to drop cs[%s], rc: %d",
                    pName, rc ) ;
            goto error ;
         }
      }
   done :
      PD_TRACE_EXITRC ( SDB__SDB_DMSCB_DROPCSP1, rc );
      return rc ;
   error :
      goto done ;
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_INSERTRECORD, "_dmsStorageUnit::insertRecord" )
   INT32 _dmsStorageUnit::insertRecord ( const CHAR *pName,
                                         BSONObj &record,
                                         pmdEDUCB *cb,
                                         SDB_DPSCB *dpscb,
                                         BOOLEAN mustOID,
                                         BOOLEAN canUnLock,
                                         dmsMBContext *context )
   {
      INT32 rc                     = SDB_OK ;
      BOOLEAN getContext           = FALSE ;
      PD_TRACE_ENTRY ( SDB__DMSSU_INSERTRECORD ) ;
      if ( NULL == context )
      {
         SDB_ASSERT( pName, "Collection name can't be NULL" ) ;

         rc = _pDataSu->getMBContext( &context, pName, -1 ) ;
         PD_RC_CHECK( rc, PDERROR, "Get collection[%s] mb context failed, "
                      "rc: %d", pName, rc ) ;
         getContext = TRUE ;
      }

      rc = _pDataSu->insertRecord( context, record, cb, dpscb, mustOID,
                                   canUnLock ) ;
      if ( rc )
      {
         goto error ;
      }

   done :
      if ( getContext && context )
      {
         _pDataSu->releaseMBContext( context ) ;
      }
      PD_TRACE_EXITRC ( SDB__DMSSU_INSERTRECORD, rc ) ;
      return rc ;
   error :
      goto done ;
   }

   ///PD_TRACE_DECLARE_FUNCTION ( SDB__MTHSACTIONPARSER_GETACTION, "_mthSActionParser::getAction" )
   INT32 _mthSActionParser::parse( const bson::BSONElement &e,
                                   _mthSAction &action ) const
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY( SDB__MTHSACTIONPARSER_GETACTION ) ;
      SDB_ASSERT( !e.eoo(), "can not be invalid" ) ;
      const CHAR *fieldName = e.fieldName() ;
      action.clear() ;

      if ( '$' != *fieldName )
      {
         goto done ;
      }

      {
      PARSERS::const_iterator itr = _parsers.find( fieldName ) ;
      if ( _parsers.end() == itr )
      {
         PD_LOG( PDERROR, "can not find the parser of action[%s]",
                 fieldName ) ;
         rc = SDB_INVALIDARG ;
         goto error ;
      }

      rc = itr->second->parse( e, action ) ;
      if ( SDB_OK != rc )
      {
         PD_LOG( PDERROR, "failed to parse action:%d", rc ) ;
         goto error ;
      } 
      }

   done:
      PD_TRACE_EXITRC( SDB__MTHSACTIONPARSER_GETACTION, rc ) ;
      return rc ;
   error:
      goto done ;
   }

   INT32 _qgmMatcher::match( const qgmFetchOut &fetch, BOOLEAN &r )
   {
      PD_TRACE_ENTRY( SDB__QGMMATCHER_MATCH ) ;
      INT32 rc = SDB_OK ;

      if ( !ready() )
      {
         PD_LOG( PDERROR, "matcher is not ready yet" ) ;
         rc = SDB_SYS ;
         goto error ;
      }

      rc = _match( _condition, fetch, r ) ;
      if ( SDB_OK != rc )
      {
         goto error ;
      }
   done:
      PD_TRACE_EXITRC( SDB__QGMMATCHER_MATCH, rc ) ;
      return rc ;
   error:
      goto done ;
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLOGFILE_RESET, "_dpsLogFile::reset" )
   INT32 _dpsLogFile::reset ( UINT32 logID, const DPS_LSN_OFFSET &offset,
                              const DPS_LSN_VER &version )
   {
      PD_TRACE_ENTRY ( SDB__DPSLOGFILE_RESET );
      if ( DPS_INVALID_LOG_FILE_ID != logID )
      {
         SDB_ASSERT ( offset/_fileSize == logID , "logical log file id error" ) ;
         _logHeader._firstLSN.offset= offset ;
         _logHeader._firstLSN.version = version ;
      }
      else
      {
         _logHeader._firstLSN.version = DPS_INVALID_LSN_VERSION ;
         _logHeader._firstLSN.offset = DPS_INVALID_LSN_OFFSET ;
      }
      _logHeader._logID = logID ;
      _idleSize = _fileSize ;
      _dirty = FALSE ;

      INT32 rc = _flushHeader () ;
      PD_TRACE_EXITRC ( SDB__DPSLOGFILE_RESET, rc );
      return rc ;
   }

   // PD_TRACE_DECLARE_FUNCTION (SDB__CLSREELECTION__WAIT4ALLWRITEDONE, "_clsReelection::_wait4AllWriteDone" )
   INT32 _clsReelection::_wait4AllWriteDone( UINT32 &timePassed,
                                             UINT32 timeout,
                                             pmdEDUCB *cb )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY( SDB__CLSREELECTION__WAIT4ALLWRITEDONE ) ;
      pmdEDUMgr *eduMgr = pmdGetKRCB()->getEDUMgr() ;
      UINT32 writingCount = 0 ;
      while ( timePassed < timeout )
      {
         if ( cb->isInterrupted() )
         {
            rc = SDB_APP_INTERRUPT ;
            goto error ;
         }

         writingCount = eduMgr->getWritingEDUCount() ;
         if ( 0 == writingCount )
         {
            break ;
         }

         ossSleepsecs( 1 ) ;
         ++timePassed ;
      }

      if ( 0 < writingCount )
      {
         rc = SDB_TIMEOUT ;
         goto error ;
      }
   done:
      PD_TRACE_EXITRC( SDB__CLSREELECTION__WAIT4ALLWRITEDONE, rc ) ;
      return rc ;
   error:
      goto done ;
   }