自学教程：C++ BegLogLine函数代码示例

    inline iWARPEM_Status_t FlushSendBuffer()    {        int wlen = 0;        mNeedsBufferFlush = false;        pthread_spin_lock( &mAccessLock );        size_t DataLen = mSendBuffer->GetDataLen();        if( DataLen == 0)        {            BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                    << "Buffer is empty. Nothing to send."                    << EndLogLine;            pthread_spin_unlock( &mAccessLock );            return IWARPEM_SUCCESS;        }        iWARPEM_Status_t status = mSendBuffer->FlushToSocket( mRouterConnFd, &wlen );        BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                << "Sent " << (int)(wlen)                << " payload: " << mSendBuffer->GetDataLen()                << " socket: " << mRouterConnFd                << EndLogLine;#ifdef MULTIPLEX_STATISTICS        mFlushCount++;        mMsgAvg = (mMsgAvg * 0.9997) + (mMsgCount * 0.0003);        BegLogLine( ( (mFlushCount & 0xfff) == 0 ) )                << "average message count per send buffer:" << mMsgAvg                << EndLogLine;#endif        ResetSendBuffer();        pthread_spin_unlock( &mAccessLock );        return status;    }

    iWARPEM_Status_t RemoveClient( iWARPEM_StreamId_t aClientId )    {        if( aClientId >= mMaxClientCount )        {            BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                    << "Requested client ID out of range [ 0 < " << aClientId << " < " << mMaxClientCount << " ]."                    << EndLogLine;            return IWARPEM_ERRNO_CONNECTION_RESET;        }        if( mClientCount < 1 )        {            BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                    << "No clients in ClientEP list."                    << EndLogLine;            return IWARPEM_ERRNO_CONNECTION_RESET;        }        if( mClientEPs[ aClientId ] == NULL )        {            BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                    << "Client ID: " << aClientId                    << " is not a virtual connected ID for this RouterEP" << mRouterConnFd                    << EndLogLine;            return IWARPEM_ERRNO_CONNECTION_RESET;        }        mClientEPs[ aClientId ] = NULL;        mClientCount--;        BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                << "Removed client: " << aClientId                << EndLogLine;        return IWARPEM_SUCCESS;    }

    iWARPEM_Status_t ExtractNextMessage( iWARPEM_Message_Hdr_t **aHdr, char **aData, iWARPEM_StreamId_t *aClientId )    {        iWARPEM_Status_t status = IWARPEM_SUCCESS;        pthread_spin_lock( &mAccessLock );        if( ! RecvDataAvailable() )        {            BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                    << "No data available in ReadBuffer. Reading new set of data."                    << EndLogLine;            switch( mReceiveBuffer->FillFromSocket( mRouterConnFd ) )            {            case IWARPEM_SUCCESS:                break;            default:                status = IWARPEM_ERRNO_CONNECTION_RESET;                BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                        << "Error while reading data from router endpoint."                        << EndLogLine;                pthread_spin_unlock( &mAccessLock );                return status;            }        }        pthread_spin_unlock( &mAccessLock );        size_t rlen = sizeof( iWARPEM_Multiplexed_Msg_Hdr_t );        iWARPEM_Multiplexed_Msg_Hdr_t *MultHdr = (iWARPEM_Multiplexed_Msg_Hdr_t*)mReceiveBuffer->GetHdrPtr( &rlen );        AssertLogLine( rlen == sizeof( iWARPEM_Multiplexed_Msg_Hdr_t ) )                << "Retrieval of HdrPtr failed: len=" << rlen                << " expected=" << sizeof(iWARPEM_Multiplexed_Msg_Hdr_t)                << EndLogLine;        MultHdr->ClientID = ntohs( MultHdr->ClientID );        *aClientId = MultHdr->ClientID;        rlen = sizeof( iWARPEM_Message_Hdr_t );        *aHdr = (iWARPEM_Message_Hdr_t*)mReceiveBuffer->GetHdrPtr( &rlen );        AssertLogLine( rlen == sizeof( iWARPEM_Message_Hdr_t ) )                << "Retrieval of HdrPtr failed: len=" << rlen                << " expected=" << sizeof(iWARPEM_Multiplexed_Msg_Hdr_t)                << EndLogLine;        (*aHdr)->EndianConvert();        rlen = (*aHdr)->mTotalDataLen;        if( rlen )            rlen = mReceiveBuffer->GetData( aData, &rlen );        AssertLogLine( rlen == (*aHdr)->mTotalDataLen )                << "Retrieval of HdrPtr failed: len=" << rlen                << " expected=" << sizeof(iWARPEM_Multiplexed_Msg_Hdr_t)                << EndLogLine;        BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                << "Extracted new client message: "                << " socket: " << mRouterConnFd                << " client: " << MultHdr->ClientID                << " MsgHdrSize: " << sizeof( iWARPEM_Multiplexed_Msg_Hdr_t )                << " MsgPldSize: " << (*aHdr)->mTotalDataLen                << " Processed: " << mReceiveBuffer->GetDataLen()                << EndLogLine;        return status;    }

    ~iWARPEM_Multiplexed_Endpoint_t()    {        bzero( &mRouterInfo, sizeof( iWARPEM_Router_Info_t ));        // go over all active EPs and flush/destroy them        for( int i=0; i < mMaxClientCount; i++ )            if( IsValidClient( i ) )                RemoveClient( i );        delete mClientEPs;        delete mSendBuffer;        delete mReceiveBuffer;        pthread_spin_destroy( &mAccessLock );        BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                << "Destroyed multiplexed router endpoint."                << " socket: " << mRouterConnFd                << EndLogLine;#ifdef MULTIPLEX_STATISTICS        BegLogLine( 1 )                << "average message count per send buffer:" << mMsgAvg                << EndLogLine;#endif    }

staticintskv_bulk_insert_pack( char *aRow, char *Key, int KeyLength, char *Value, int ValueLength ){  int TotalSize = 0;  int* KeyPtr = (int *) &aRow[TotalSize];  BegLogLine(SKV_CLIENT_ENDIAN_LOG)    << "Endian-converting KeyLength from " << (void *) (intptr_t)KeyLength    << EndLogLine ;  *KeyPtr = htonl(KeyLength);  TotalSize += sizeof(int);  memcpy( &aRow[TotalSize],          Key,          KeyLength );  TotalSize += KeyLength;  int* ValuePtr = (int *) &aRow[TotalSize];  BegLogLine(SKV_CLIENT_ENDIAN_LOG)    << "Endian-converting ValueLength from " << (void *) (intptr_t)ValueLength    << EndLogLine ;  *ValuePtr = htonl(ValueLength);  TotalSize += sizeof(int);  memcpy( &aRow[TotalSize],          Value,          ValueLength );  TotalSize += ValueLength;  return TotalSize;}

  // ??? We should allow the user to set a compare function on skv_store_t  // ??? Default behaviour should be lexicographical order  bool  operator<( const skv_store_t& aStore ) const  {    BegLogLine( SKV_STORE_T_LOG )      << "skv_store_t::operator<():: Entering "      << EndLogLine;    int MinDataSize = min( mSize(), aStore.mSize() );    AssertLogLine( mData != NULL )      << "skv_store_t::operator<():: ERROR: "      << " mData != NULL "      << EndLogLine;    AssertLogLine( aStore.mData != NULL )      << "skv_store_t::operator<():: ERROR: "      << " aStore.mData != NULL "      << EndLogLine;    int rc = memcmp( mData, aStore.mData, MinDataSize );    BegLogLine( SKV_STORE_T_LOG )      << "skv_store_t::operator<():: "      << " MinDataSize: " << MinDataSize      << " mSize: " << mSize()      << " aStore.mSize: " << aStore.mSize()      << " rc: " << rc      << EndLogLine;    return ( rc < 0 );  }

/*** * skv_server_t::InitNewStateForEP:: * Desc: Initiates the state for a new EP * input: * returns: SKV_SUCCESS or SKV_ERR_NO_EVENT ***/skv_status_tskv_server_network_event_manager_if_t::FinalizeEPState( skv_server_epstate_map_t *aEPStateMap,                 it_ep_handle_t aEP,                 skv_server_ep_state_t* aStateForEP ){  AssertLogLine( aStateForEP != NULL )    << "skv_server_t::FinalizeEPState(): ERROR: "    << " aEP: " << (void *) aEP    << EndLogLine;  aStateForEP->Closing();  skv_server_finalizable_associated_ep_state_list_t::iterator iter = aStateForEP->mAssociatedStateList->begin();  skv_server_finalizable_associated_ep_state_list_t::iterator end  = aStateForEP->mAssociatedStateList->end();  for( ; iter != end; iter++ )  {    switch( iter->mStateType )    {      case SKV_SERVER_FINALIZABLE_ASSOCIATED_EP_STATE_CREATE_CURSOR_TYPE:      {        skv_server_cursor_hdl_t ServCursorHdl = (skv_server_cursor_hdl_t) iter->mState;        ServCursorHdl->Finalize();        free( ServCursorHdl );        break;      }      default:        StrongAssertLogLine( 0 )          << "FinalizeEPState(): ERROR:: "          << " iter->mStateType: " << iter->mStateType          << EndLogLine;    }  }  aEPStateMap->erase( aEP );  aStateForEP->Finalize();  BegLogLine(SKV_SERVER_CLEANUP_LOG)      << "free(aStateForEP= " << (void *) aStateForEP      << " )"      << EndLogLine ;  bzero( aStateForEP, sizeof( skv_server_ep_state_t ) );  delete aStateForEP;  it_ep_free( aEP );  BegLogLine( SKV_SERVER_CLEANUP_LOG )    << "skv_server::FinalizeEPState(): completed "    << EndLogLine;  return SKV_SUCCESS;}

    static inline    skv_status_t insert_lookup_sequence( skv_local_kv_t *aLocalKV,                                         skv_server_ccb_t *aCommand,                                         skv_cmd_RIU_req_t **aReq,                                         skv_local_kv_cookie_t *aCookie,                                         skv_lmr_triplet_t *aValueRep )    {        // we have copied all Req data into response buffer already at cmd init        skv_cmd_RIU_req_t *Req = (skv_cmd_RIU_req_t *) aCommand->GetSendBuff();        // convert only if it's the first time we arrive here...        if( aCommand->GetCommandClass() == SKV_COMMAND_CLASS_IMMEDIATE )            Req->EndianConvert() ;        *aReq = Req;        if( FlagBasedLock( aLocalKV, Req, aCommand ) != SKV_SUCCESS )        {            BegLogLine( ( SKV_SERVER_LOCK_LOG | SKV_SERVER_INSERT_LOG ) )                    << "skv_server_insert_command_sm::Execute()::"                    << " record is locked."                    << EndLogLine;            return SKV_ERRNO_RECORD_IS_LOCKED;        }        // Check if the key is in the buffer        int KeySize = Req->mKeyValue.mKeySize;        BegLogLine( SKV_SERVER_INSERT_LOG )                << "skv_server_insert_command_sm:: Lookup with flags: " << (void*)( (uintptr_t)Req->mFlags & (SKV_COMMAND_RIU_INSERT_EXPANDS_VALUE                        | SKV_COMMAND_RIU_INSERT_OVERWRITE_VALUE_ON_DUP                        | SKV_COMMAND_RIU_UPDATE                        | SKV_COMMAND_RIU_APPEND) )                << EndLogLine;        AssertLogLine( Req->mKeyValue.mKeySize >= 0 &&                       Req->mKeyValue.mKeySize < SKV_KEY_LIMIT )                << "skv_server_insert_command_sm:: Execute():: ERROR: "                << "Req->mKeyValue.mKeySize: " << Req->mKeyValue.mKeySize                << EndLogLine;        AssertLogLine( (Req->mFlags & SKV_COMMAND_RIU_INSERT_KEY_FITS_IN_CTL_MSG) ||                       (Req->mFlags & SKV_COMMAND_RIU_INSERT_KEY_VALUE_FIT_IN_CTL_MSG) )                << "skv_server_insert_command_sm:: Execute():: ERROR: "                << " Assume that key fits into the control message"                << EndLogLine;        // Check if the key exists        return aLocalKV->Lookup( Req->mPDSId,                                 Req->mKeyValue.mData,                                 KeySize,                                 Req->mFlags,                                 aValueRep,                                 aCookie );    }

    static inline    skv_status_t insert_sequence( skv_local_kv_t *aLocalKV,                                  skv_server_ep_state_t *aEPState,                                  skv_server_ccb_t *aCommand,                                  int aCommandOrdinal,                                  skv_cmd_RIU_req_t *aReq,                                  skv_status_t lookup_status,                                  int *aSeqNo,                                  int aMyRank,                                  skv_lmr_triplet_t *aValueRepInStore )    {        skv_status_t status;        skv_lmr_triplet_t ValueRepForRdmaRead;        BegLogLine( SKV_SERVER_INSERT_LOG )                << "skv_server_insert_command_sm::Execute():: Lookup returned: " << skv_status_to_string( lookup_status )                << " will go for case: " << (void*)( (uintptr_t)aReq->mFlags & (SKV_COMMAND_RIU_INSERT_EXPANDS_VALUE                        | SKV_COMMAND_RIU_INSERT_OVERWRITE_VALUE_ON_DUP                        | SKV_COMMAND_RIU_UPDATE                        | SKV_COMMAND_RIU_APPEND) )                << EndLogLine;#ifdef SKV_INSERT_DATA_LOG        if( aReq->mFlags & SKV_COMMAND_RIU_INSERT_KEY_VALUE_FIT_IN_CTL_MSG )        {            HexDump FxString( &aReq->mKeyValue.mData[ aReq->mKeyValue.mKeySize ], aReq->mKeyValue.mValueSize );            BegLogLine( 1 )                    << "skv_server_insert_command_sm::insert_sequence(): "                    << " Size: " << aReq->mKeyValue.mValueSize                    << " FxString: " << FxString                    << EndLogLine;        }        else            BegLogLine( 1 )                    << "skv_server_insert_command_sm::insert_sequence(): Data not in ctrl-msg. can't display."                    << EndLogLine;#endif        skv_local_kv_cookie_t *cookie = &aCommand->mLocalKVCookie;        cookie->Set( aCommandOrdinal, aEPState );        status = aLocalKV->Insert( aReq,                                   lookup_status,                                   aValueRepInStore,                                   &ValueRepForRdmaRead,                                   cookie );        BegLogLine( SKV_SERVER_INSERT_LOG )                << "skv_server_insert_command_sm::insert_sequence():: Insert returned: " << skv_status_to_string( status )                << EndLogLine;        aValueRepInStore->Init( ValueRepForRdmaRead );        return status;    }

    // needs to make sure to not change the status of the receive buffer    iWARPEM_Status_t GetNextMessageType( iWARPEM_Msg_Type_t *aMsgType, iWARPEM_StreamId_t *aClient )    {        iWARPEM_Status_t status = IWARPEM_SUCCESS;        pthread_spin_lock( &mAccessLock );        if( ! RecvDataAvailable() )        {            BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                    << "No data available in ReadBuffer. Reading new set of data."                    << EndLogLine;            status = mReceiveBuffer->FillFromSocket( mRouterConnFd );            switch( status )            {            case IWARPEM_SUCCESS:                break;            default:                BegLogLine( 1 )                        << "Error while reading data from router endpoint."                        << EndLogLine;                *aClient = IWARPEM_INVALID_CLIENT_ID;                *aMsgType = iWARPEM_UNKNOWN_REQ_TYPE;                pthread_spin_unlock( &mAccessLock );                return status;            }        }        pthread_spin_unlock( &mAccessLock );        size_t hdrlen = sizeof( iWARPEM_Multiplexed_Msg_Hdr_t );        iWARPEM_Multiplexed_Msg_Hdr_t *MultHdr = (iWARPEM_Multiplexed_Msg_Hdr_t*)mReceiveBuffer->GetHdrPtr( &hdrlen, 0 );        AssertLogLine( hdrlen == sizeof( iWARPEM_Multiplexed_Msg_Hdr_t ) )                << "Retrieval of HdrPtr failed: len=" << hdrlen                << " expected=" << sizeof(iWARPEM_Multiplexed_Msg_Hdr_t)                << EndLogLine;        MultHdr->ClientID = be64toh( MultHdr->ClientID );        *aClient = MultHdr->ClientID;        // advance the hdr ptr ourselves to peek into MsgType without advancing the receive buffer ptr        char *HdrData = (char*)MultHdr;        HdrData += sizeof( iWARPEM_Multiplexed_Msg_Hdr_t );        HdrData = (char*)mReceiveBuffer->AlignedHeaderPosition( HdrData );        iWARPEM_Message_Hdr_t *MsgPtr = (iWARPEM_Message_Hdr_t*)HdrData;        BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )                << "Retrieving msg_type: " << MsgPtr->mMsg_Type                << " from client: " << *aClient                << " [email
C++ Begin函数代码示例
C++ Beep函数代码示例