jnet::JNetCore 클래스 참조

클라이언트 TCP 세션의 생명 주기를 'JNetSession'을 통해 관리하며, 하위 클래스 객체의 세션 접근(송신, 수신 처리 및 연결 종료)에 대한 thread-safe 성을 보장함
등록된 세션의 소켓 장치를 IOCP 객체에 등록되면, 비동기 I/O 완료 처리를 IOCP 작업자 스레드를 통해 수행
클라이언트로부터의 패킷 수신 완료 및 연결 종료를 이벤트 함수(OnRecvCompletion, OnSessionLeave)를 통해 콜백하며, 패킷 송신 및 연결 종료 기능 함수(SendPacket, Disconnect)를 제공함
더 자세히 ...

#include <JNetCore.h>

jnet::JNetCore에 대한 상속 다이어그램 :

클래스
struct	JNetSession
	JNetCore에서 관리되는 세션 구조체 세션의 연결 소켓 및 수신 링-버퍼와 송신 락-프리 큐 버퍼를 멤버로 갖으며, 세션 ID와 참조 카운트 필드를 바탕으로 thread-safe한 세션 초기화 및 해제 기능을 제공 더 자세히 ...

Public 멤버 함수
	JNetCore (uint16 maximumOfSessions, uint32 numOfIocpConcurrentThrd, uint16 numOfIocpWorkerThrd, size_t tlsMemPoolUnitCnt, size_t tlsMemPoolUnitCapacity, uint32 memPoolBuffAllocSize, uint32 sessionRecvBuffSize, bool calcTpsThread)
	~JNetCore ()
bool	Start ()
void	Stop ()
uint16	GetCurrentSessions ()
int64	GetCurrentAllocatedMemUnitCnt ()
int	GetSessionCount ()
UINT	GetAcceptTPS ()
UINT	GetRecvTPS ()
UINT	GetSendTPS ()
UINT64	GetTotalAcceptTransaction ()
UINT64	GetTotalRecvTransaction ()
UINT64	GetTotalSendTransaction ()
void	IncrementRecvTransactions (bool threadSafe, UINT incre)
void	IncrementSendTransactions (bool threadSafe, UINT incre)
void	IncrementAcceptTransactions (bool threadSafe=false, UINT incre=1)

Protected 멤버 함수
void	PrintLibraryInfoOnConsole ()
JNetSession *	CreateNewSession (SOCKET sock)
	하위 클래스에서 세션 객체 생성 요청을 위해 호출하는 함수
bool	RegistSessionToIOCP (JNetSession *session)
	하위 클래스에서 세션 객체를 IOCP 등록을 위해 호출하는 함수
bool	DeleteSession (SessionID64 sessionID)
	세션 제거 요청 함수
void	Disconnect (SessionID64 sessionID)
bool	SendPacket (SessionID64 sessionID, JBuffer *sendPktPtr, bool postToWorker=false)
	패킷 송신 요청 함수
bool	SendPacketBlocking (SessionID64 sessionID, JBuffer *sendPktPtr)
	동기식 송신 요청 함수
bool	BufferSendPacket (SessionID64 sessionID, JBuffer *sendPktPtr)
	세션 송신 버퍼 큐에 버퍼링(삽입만 진행)
bool	SendBufferedPacket (SessionID64 sessionID, bool postToWorker=false)
	세션 송신 버퍼 큐 내 송신 패킷 직렬화 버퍼에 대한 일괄 송신 작업 수행
DWORD	AllocTlsMemPool ()
	직렬화 패킷 버퍼 Tls 풀 할당 함수
JBuffer *	AllocSerialBuff ()
	직렬화 패킷 버퍼 할당 요청 wrapper
void	FreeSerialBuff (JBuffer *buff)
	직렬화 패킷 버퍼 반환 wrapper
void	AddRefSerialBuff (JBuffer *buff)
	직렬화 패킷 버퍼 참조 카운트 증가 wrapper
virtual bool	OnWorkerThreadCreate (HANDLE thHnd)
	Start() 함수 내 IOCP 작업자 스레드 생성(CREATE_SUSPENDED) 후 호출되는 이벤트 함수
virtual void	OnAllWorkerThreadCreate ()
	Start() 함수 내 요청된 수 만큼 IOCP 작업자 스레드를 생성한 후 함수를 빠져나오기 전 호출되는 이벤트 함수
virtual void	OnWorkerThreadStart ()
	개별 IOCP 작업자 스레드의 수행 흐름 초입부(WorkerThreadFunc 함수 초입부)에 호출되는 이벤트 함수, 개별 작업자 스레드의 초기화를 독립적으로 수행하도록 재정의 가능
virtual void	OnWorkerThreadEnd ()
	개별 IOCP 작업자 스레드가 종료(작업자 함수 return) 전 호출되는 이벤트 함수
virtual void	OnRecvCompletion (SessionID64 sessionID, JBuffer &recvRingBuffer)=0
	IOCP 작업자 스레드의 수신 완료 시 대상 세션의 수신 버퍼의 enqueue 오프셋 제어 후 호출되는 이벤트 함수
virtual void	OnSessionLeave (SessionID64 sessionID)
	JNetCore 단 세션이 제거된 후 호출되는 이벤트 함수
virtual void	OnError ()

Protected 속성
bool	m_CalcTpsFlag

Private 타입
enum	enTransaction { ACCEPT_TRANSACTION , RECV_TRANSACTION , SEND_TRANSACTION , SEND_REQ_TRANSACTION }

Private 멤버 함수
JNetSession *	AcquireSession (SessionID64 sessionID)
	Multi IOCP 작업자 스레드 간 thread-safe 하지 않은 세션에 대해 세션 접근 전 호출하는 함수
void	ReturnSession (JNetSession *session)
	AcquireSession을 통해 획득한 세션 객체 소유권 반납
void	SendPost (SessionID64 sessionID, bool onSendFlag=false)
	SendPacket 계열 함수 내부에서 호출되는 실질적 송신 요청 함수
void	SendPostRequest (SessionID64 sessionID)
	SendPost() 함수의 작업을 IOCP 작업자 스레드의 흐름에서 수행되도록 강제화를 요청하는 함수
void	FreeBufferedSendPacket (LockFreeQueue< JBuffer * > &sendBufferQueue, queue< JBuffer * > &sendPostedQueue)
	세션 제거 시 송신 버퍼 정리
void	Proc_DeleteSession (JNetSession *session)
	IOCP 작업자 스레드의 세션 삭제 요청 처리 함수
void	Proc_SendPostRequest (JNetSession *session)
	IOCP 작업자 스레드의 송신 요청 시 처리 함수(SendPacket 계열 함수의 postToWorker 요청)
void	Proc_RecvCompletion (JNetSession *session, DWORD transferred)
	IOCP 작업자 스레드의 수신 완료 통지 시 처리 함수
void	Proc_SendCompletion (JNetSession *session)
	IOCP 작업자 스레드의 송신 완료 통지 시 처리 함수
void	IncrementTransactions (BYTE type, bool threadSafe=false, UINT incre=1)
LONG	GetTransactionsPerSecond (BYTE type)
UINT64	GetTotalTransactions (BYTE type)

정적 Private 멤버 함수
static UINT __stdcall	WorkerThreadFunc (void *arg)
	IOCP 작업자 스레드의 수행 함수
static UINT __stdcall	CalcTpsThreadFunc (void *arg)

Private 속성
std::vector< JNetSession * >	m_Sessions
	세션 관리 벡터
uint16	m_MaximumOfSessions
	수용 가능한 최대 세션 수
LockFreeQueue< uint16 >	m_SessionIndexQueue
	세션 인덱스 할당 큐 (SessionID's index part)
uint64	m_SessionIncrement
	세션 증분 (SessionID's increment part)
HANDLE	m_IOCP
	JNetCore's IOCP 객체
uint16	m_NumOfIocpWorkerThrd
	IOCP 작업자 스레드 갯수
std::vector< HANDLE >	m_IocpWorkerThrdHnds
	IOCP 작업자 스레드 핸들 벡터
std::vector< uint32 >	m_IocpWorkerThrdIDs
	IOCP 작업자 스레드's ID 벡터
TlsMemPoolManager< JBuffer, true, false >	m_TlsMemPoolMgr
	Tls 메모리 풀 관리 (직렬화 패킷 버퍼 풀 할당 및 관리자)
size_t	m_TlsMemPoolUnitCnt
size_t	m_TlsMemPoolUnitCapacity
uint32	m_MemPoolBuffAllocSize
HANDLE	m_CalcTpsThread
UINT	m_Transactions [NUM_OF_TPS_ITEM]
UINT	m_TransactionsPerSecond [NUM_OF_TPS_ITEM]
UINT64	m_TotalTransaction [NUM_OF_TPS_ITEM]

정적 Private 속성
static const int	NUM_OF_TPS_ITEM = 4

상세한 설명

클라이언트 TCP 세션의 생명 주기를 'JNetSession'을 통해 관리하며, 하위 클래스 객체의 세션 접근(송신, 수신 처리 및 연결 종료)에 대한 thread-safe 성을 보장함
등록된 세션의 소켓 장치를 IOCP 객체에 등록되면, 비동기 I/O 완료 처리를 IOCP 작업자 스레드를 통해 수행
클라이언트로부터의 패킷 수신 완료 및 연결 종료를 이벤트 함수(OnRecvCompletion, OnSessionLeave)를 통해 콜백하며, 패킷 송신 및 연결 종료 기능 함수(SendPacket, Disconnect)를 제공함

멤버 열거형 문서화

enTransaction

enum jnet::JNetCore::enTransaction

private

열거형 멤버
ACCEPT_TRANSACTION
RECV_TRANSACTION
SEND_TRANSACTION
SEND_REQ_TRANSACTION

                              {
        ACCEPT_TRANSACTION,
        RECV_TRANSACTION,
        SEND_TRANSACTION,
        SEND_REQ_TRANSACTION
    };

생성자 & 소멸자 문서화

JNetCore()

JNetCore::JNetCore	(	uint16	maximumOfSessions,
		uint32	numOfIocpConcurrentThrd,
		uint16	numOfIocpWorkerThrd,
		size_t	tlsMemPoolUnitCnt,
		size_t	tlsMemPoolUnitCapacity,
		uint32	memPoolBuffAllocSize,
		uint32	sessionRecvBuffSize,
		bool	calcTpsThread )

매개변수

maximumOfSessions	수용 가능 최대 세션 수 설정
numOfIocpConcurrentThrd	IOCP 'concurrent threads' 설정
numOfIocpWorkerThrd	IOCP 작업자 스레드 수 설정
tlsMemPoolUnitCnt	Tls 메모리 풀 객체 초기 할당량 결정(직렬화 패킷 버퍼 수)
tlsMemPoolUnitCapacity	Tls 메모리 풀 객체 수용량 결정(직렬화 패킷 버퍼 최대 용량)
memPoolBuffAllocSize
sessionRecvBuffSize
calcTpsThread

    : m_MaximumOfSessions(maximumOfSessions), m_SessionIncrement(0),
    m_NumOfIocpWorkerThrd(numOfIocpWorkerThrd),
    m_TlsMemPoolMgr(tlsMemPoolUnitCnt, tlsMemPoolUnitCapacity),
    m_TlsMemPoolUnitCnt(tlsMemPoolUnitCnt), m_TlsMemPoolUnitCapacity(tlsMemPoolUnitCapacity),
    m_MemPoolBuffAllocSize(memPoolBuffAllocSize),
    m_CalcTpsFlag(calcTpsThread)
{
    // 1. 윈도우 네트워크 라이브러리 초기화
    WSAData wsadata;
    if (InitWindowSocketLib(&wsadata) != 0) {
        DebugBreak();
    }
    cout << "JNetCore::JNetCore(..), Window Network Library Init Done.." << endl;
 
    // 2. 세션 관리 초기화
    for (uint16 idx = 1; idx <= m_MaximumOfSessions; idx++) {
        m_SessionIndexQueue.Enqueue(idx);
    }
    m_Sessions.resize(m_MaximumOfSessions + 1, NULL);
    for (uint16 idx = 1; idx <= m_MaximumOfSessions; idx++) {
        m_Sessions[idx] = new JNetSession{sessionRecvBuffSize};
    }
    cout << "JNetCore::JNetCore(..), Session's Structs Init Done.." << endl;
 
    // 3. IOCP 객체 초기화
    m_IOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, numOfIocpConcurrentThrd);
#if defined(ASSERT)
    if (m_IOCP == NULL) {
        DebugBreak();
    }
#endif
    cout << "JNetCore::JNetCore(..), CreateIoCompletionPort Done.." << endl;
 
    // 4. IOCP 작업자 스레드 관리 초기화
    if (m_NumOfIocpWorkerThrd == 0) {
        SYSTEM_INFO si;
        GetSystemInfo(&si);
        m_NumOfIocpWorkerThrd = si.dwNumberOfProcessors;
    }
    m_IocpWorkerThrdHnds.resize(m_NumOfIocpWorkerThrd, NULL);
    m_IocpWorkerThrdIDs.resize(m_NumOfIocpWorkerThrd, NULL);
    cout << "JNetCore::JNetCore(..), IOCP Worker Threads Init Done.." << endl;
}

~JNetCore()

JNetCore::~JNetCore

(

)

{
    Stop();
    CloseHandle(m_IOCP);
    WSACleanup();
}

멤버 함수 문서화

Start()

bool JNetCore::Start

(

)

{
    // IOCP 작업자 스레드 생성
    for (uint16 idx = 0; idx < m_NumOfIocpWorkerThrd; idx++) {
        uintptr_t ret = _beginthreadex(NULL, 0, JNetCore::WorkerThreadFunc, this, CREATE_SUSPENDED, NULL);
        m_IocpWorkerThrdHnds[idx] = (HANDLE)ret;
        if (m_IocpWorkerThrdHnds[idx] == INVALID_HANDLE_VALUE) {
            DebugBreak();
        }
        DWORD thID = GetThreadId(m_IocpWorkerThrdHnds[idx]);
        m_IocpWorkerThrdIDs[idx] = thID;
 
        if (!OnWorkerThreadCreate(m_IocpWorkerThrdHnds[idx])) {
            cout << "[Cant't Start Thread] Worker Thread (thID: " << GetThreadId(m_IocpWorkerThrdHnds[idx]) << ")" << endl;
            TerminateThread(m_IocpWorkerThrdHnds[idx], 0);
        }
        else {
            cout << "[Start Thread] Worker Thread (thID: " << GetThreadId(m_IocpWorkerThrdHnds[idx]) << ")" << endl;
            ResumeThread(m_IocpWorkerThrdHnds[idx]);
        }
    }
 
    if (m_CalcTpsFlag) {
        m_CalcTpsThread = (HANDLE)_beginthreadex(NULL, 0, JNetCore::CalcTpsThreadFunc, this, 0, NULL);
    }
    cout << "JNetCore::Start(), Create IOCP Worker Threads Done.." << endl;
 
    // 모든 스레드가 생성된 후 호출, 생성된 스레드는 작업 중...
    OnAllWorkerThreadCreate();
 
    return true;
}

Stop()

void JNetCore::Stop

(

)

{
    static bool stopped = false;
 
    if (!stopped) {
        if (m_CalcTpsFlag) { TerminateThread(m_CalcTpsThread, 0); }
 
        // IOCP 작업자 스레드가 스스로 작업 함수에서 반환하도록 종료 메시지를 IOCP 큐에 post
        for (uint16 i = 0; i < m_NumOfIocpWorkerThrd; i++) {
            PostQueuedCompletionStatus(m_IOCP, 0, 0, NULL);
        }
 
        stopped = true;
    }
}

GetCurrentSessions()

uint16 jnet::JNetCore::GetCurrentSessions ( )

inline

        {
            return m_MaximumOfSessions - m_SessionIndexQueue.GetSize();
        }

PrintLibraryInfoOnConsole()

void jnet::JNetCore::PrintLibraryInfoOnConsole ( )

protected

{
    cout << "======================== JNetCore ========================" << endl;
    cout << "JNetCore::Maximum Of Sessions               : " << m_MaximumOfSessions << endl;
    cout << "JNetCore::Current Allive Sessions Count     : " << GetCurrentSessions() << endl;
    cout << "JNetCore::TLS Memory Pool Unit Count(set)   : " << m_TlsMemPoolUnitCnt << endl;
    cout << "JNetCore::TLS Memory Pool Unit Capacity(set): " << m_TlsMemPoolUnitCapacity << endl;
    cout << "JNetCore::TLS Memory Pool Buffer Alloc Size : " << m_MemPoolBuffAllocSize << endl;
 
    cout << "TlsMemPool::Total Memory Alloc Count        : " << m_TlsMemPoolMgr.GetTotalAllocMemCnt() << endl;
    cout << "TlsMemPool::Total Memory Free Count         : " << m_TlsMemPoolMgr.GetTotalFreeMemCnt() << endl;
    cout << "TlsMemPool::Current Memory Allocated Count  : " << m_TlsMemPoolMgr.GetAllocatedMemUnitCnt() << endl;
    cout << "TlsMemPool::Memory Malloc Count             : " << m_TlsMemPoolMgr.GetMallocCount() << endl;
 
    std::cout << "----------------------------------------------------------" << std::endl;
    std::cout << "[Accept] Total Accept Count     : " << GetTotalAcceptTransaction() << std::endl;
    std::cout << "[Accept] Accept TPS             : " << GetAcceptTPS() << std::endl;
    std::cout << "----------------------------------------------------------" << std::endl;
    std::cout << "[Recv]   Total Recv Packet Size : " << GetTotalRecvTransaction() << std::endl;
    std::cout << "[Recv]   Total Recv TPS         : " << GetRecvTPS() << std::endl;
    std::cout << "----------------------------------------------------------" << std::endl;
    std::cout << "[Send]   Total Send Packet Size : " << GetTotalSendTransaction() << std::endl;
    std::cout << "[Send]   Total Send TPS         : " << GetSendTPS() << std::endl;
    std::cout << "----------------------------------------------------------" << std::endl;
    std::cout << "[Session] Session acceptance limit               : " << m_MaximumOfSessions << std::endl;
    std::cout << "[Session] Current number of sessions             : " << GetSessionCount() << std::endl;
    std::cout << "[Session] Number of Acceptances Available        : " << m_SessionIndexQueue.GetSize() << std::endl;
    std::cout << "----------------------------------------------------------" << std::endl;
}

CreateNewSession()

JNetCore::JNetSession * JNetCore::CreateNewSession ( SOCKET sock )

protected

하위 클래스에서 세션 객체 생성 요청을 위해 호출하는 함수

매개변수

sock	세션과 대응되는 유효한 소켓 핸들

반환값

새로 생성 및 초기화된 세션 객체의 포인터

{
    JNetSession* newSession = nullptr;
 
    uint16 allocIdx;
    if (m_SessionIndexQueue.Dequeue(allocIdx)) {
        newSession = m_Sessions[allocIdx];
        JNetSession::SessionID newSessionID(allocIdx, InterlockedIncrement64(reinterpret_cast<long long*>(&m_SessionIncrement)));
        newSession->Init(newSessionID, sock);
    }
    return newSession;
}

RegistSessionToIOCP()

bool JNetCore::RegistSessionToIOCP ( JNetSession * session )

protected

하위 클래스에서 세션 객체를 IOCP 등록을 위해 호출하는 함수

매개변수

session

등록하고자 하는 세션 객체 포인터

반환값

등록 성공 여부

{
    bool ret = true;
    if (CreateIoCompletionPort((HANDLE)session->m_Sock, m_IOCP, (ULONG_PTR)session, 0) == NULL) {
#if defined(ASSERT)
        DebugBreak();
#else
        ret = false;
#endif
    }
    else {
        // IOCP 등록 성공 시 초기 수신 대기 설정
        // WSARecv 
        WSABUF wsabuf;
        wsabuf.buf = reinterpret_cast<char*>(session->m_RecvRingBuffer.GetEnqueueBufferPtr());
        wsabuf.len = session->m_RecvRingBuffer.GetFreeSize();
 
        DWORD dwFlag = 0;
        //newSession->ioCnt = 1;
        // => 세션 Release 관련 수업(24.04.08) 참고
        // 세션 Init 함수에서 IOCnt를 1로 초기화하는 것이 맞는듯..
        if (WSARecv(session->m_Sock, &wsabuf, 1, NULL, &dwFlag, &session->m_RecvOverlapped, NULL) == SOCKET_ERROR) {
            int errcode = WSAGetLastError();
            if (errcode != WSA_IO_PENDING) {
                ret = false;
            }
        }
    }
 
    return ret;
}

DeleteSession()

bool JNetCore::DeleteSession ( SessionID64 sessionID )

protected

세션 제거 요청 함수

매개변수

sessionID

제거하고자하는 세션 아이디

반환값

true 반환 시 세션 제거, false 반환 시 이미 제거되었거나 제거 로직이 다른 스레드를 통해 수행중인 상황을 암시

{
    bool ret = false;
    uint16 idx = (uint16)sessionID;
    JNetSession* delSession = m_Sessions[idx];
 
    if (delSession == nullptr) {
#if defined(ASSERT)
        DebugBreak();
#endif
        return false;
    }
 
    if (delSession->TryRelease()) {
        ret = true;
#if defined(ASSERT)
        if (delSession->m_ID != sessionID) {
            DebugBreak();
        }
#endif
 
        // 세션 삭제
        uint16 allocatedIdx = delSession->m_ID.idx;
        SOCKET delSock = m_Sessions[allocatedIdx]->m_Sock;
        shutdown(delSock, SD_BOTH);
        closesocket(delSock);
 
        FreeBufferedSendPacket(delSession->m_SendBufferQueue, delSession->m_SendPostedQueue);
 
        // 세션 ID 인덱스 반환
        m_SessionIndexQueue.Enqueue(allocatedIdx);
    }
 
    return ret;
}

Disconnect()

void jnet::JNetCore::Disconnect ( SessionID64 sessionID )

protected

{
    // refCnt > 0 임을 보장한 상태에서 호출되는 함수이기에 AcquireSession이 필요없음
    JNetSession::SessionID sessionID(sessionID64);
    JNetSession* delSession = m_Sessions[sessionID.idx];
#if defined(ASSERT)
    if (delSession->m_SessionRef.refCnt < 1) {
        DebugBreak();
    }
#endif
    PostQueuedCompletionStatus(m_IOCP, 0, (ULONG_PTR)delSession, (LPOVERLAPPED)IOCP_COMPLTED_LPOVERLAPPED_DISCONNECT);
}

SendPacket()

bool JNetCore::SendPacket ( SessionID64 sessionID, JBuffer * sendPktPtr, bool postToWorker = false )

protected

패킷 송신 요청 함수

매개변수

sessionID	송신 대상 세션 아이디
송신	직렬화 패킷 버퍼 @postToWorker IOCP 작업자 스레드에 실질적 송신 작업(SendPost) 책임 전가(WSASend 호출 및 커널 모드 전환 처리 전가)

{
    bool ret = false;
    JNetSession* session = AcquireSession(sessionID);
    if (session != nullptr) {
 
        session->m_SendBufferQueue.Enqueue(sendPktPtr);
 
        if (postToWorker) {
            SendPostRequest(sessionID);
        }
        else {
            SendPost(sessionID);
        }
 
        ReturnSession(session);
        ret = true;
    }
    
    return ret;
}

SendPacketBlocking()

bool JNetCore::SendPacketBlocking ( SessionID64 sessionID, JBuffer * sendPktPtr )

protected

동기식 송신 요청 함수

매개변수

sessionID	송신 대상 세션 아이디
송신	직렬화 패킷 버퍼

{
    bool ret = false;
    JNetSession* session = AcquireSession(sessionID);
    if (session != nullptr) {
 
        session->m_SendBufferQueue.Enqueue(sendPktPtr);
 
        int sendDataLen = sendPktPtr->GetUseSize();
        if (sendDataLen != ::send(session->m_Sock, (const char*)sendPktPtr->GetBeginBufferPtr(), sendDataLen, 0)) {
#if defined(ASSERT)
            DebugBreak();
#else
            ret = false;
#endif
        }
        FreeSerialBuff(sendPktPtr);
 
        ReturnSession(session);
        ret = true;
    }
 
    return ret;
}

BufferSendPacket()

bool JNetCore::BufferSendPacket ( SessionID64 sessionID, JBuffer * sendPktPtr )

protected

세션 송신 버퍼 큐에 버퍼링(삽입만 진행)

매개변수

sessionID	송신 대상 세션 아이디
송신	직렬화 패킷 버퍼

{
    bool ret = false;
    JNetSession* session = AcquireSession(sessionID);
    if (session != nullptr) {
 
        session->m_SendBufferQueue.Enqueue(sendPktPtr);
 
        ReturnSession(session);
        ret = true;
    }
 
    return ret;
}

SendBufferedPacket()

bool JNetCore::SendBufferedPacket ( SessionID64 sessionID, bool postToWorker = false )

protected

세션 송신 버퍼 큐 내 송신 패킷 직렬화 버퍼에 대한 일괄 송신 작업 수행

매개변수

sessionID

송신 대상 세션 아이디 @postToWorker IOCP 작업자 스레드에 실질적 송신 작업(SendPost) 책임 전가

{
    bool ret = false;
    JNetSession* session = AcquireSession(sessionID);
    if (session != NULL) {
        if (postToWorker) {
            SendPostRequest(sessionID);
        }
        else {
            SendPost(sessionID);
        }
        ReturnSession(session);
        ret = true;
    }
    return ret;
}

AllocTlsMemPool()

DWORD jnet::JNetCore::AllocTlsMemPool ( )

inlineprotected

직렬화 패킷 버퍼 Tls 풀 할당 함수

                                       {
            return m_TlsMemPoolMgr.AllocTlsMemPool(m_TlsMemPoolUnitCnt, m_TlsMemPoolUnitCapacity, m_MemPoolBuffAllocSize);
        }

AllocSerialBuff()

JBuffer * jnet::JNetCore::AllocSerialBuff ( )

inlineprotected

직렬화 패킷 버퍼 할당 요청 wrapper

                                          {
            JBuffer* msg = m_TlsMemPoolMgr.GetTlsMemPool().AllocMem(1, m_MemPoolBuffAllocSize);
            msg->ClearBuffer();
            return msg;
        }

FreeSerialBuff()

void jnet::JNetCore::FreeSerialBuff ( JBuffer * buff )

inlineprotected

직렬화 패킷 버퍼 반환 wrapper

                                                  {
            m_TlsMemPoolMgr.GetTlsMemPool().FreeMem(buff);
        }

AddRefSerialBuff()

void jnet::JNetCore::AddRefSerialBuff ( JBuffer * buff )

inlineprotected

직렬화 패킷 버퍼 참조 카운트 증가 wrapper

                                                    {
            m_TlsMemPoolMgr.GetTlsMemPool().IncrementRefCnt(buff, 1);
        }

GetCurrentAllocatedMemUnitCnt()

int64 jnet::JNetCore::GetCurrentAllocatedMemUnitCnt ( )

inline

                                                     {
            return m_TlsMemPoolMgr.GetAllocatedMemUnitCnt();;
        }

GetSessionCount()

int jnet::JNetCore::GetSessionCount ( )

inline

                                     {
            return m_MaximumOfSessions - m_SessionIndexQueue.GetSize();
        }

OnWorkerThreadCreate()

bool JNetCore::OnWorkerThreadCreate ( HANDLE thHnd )

protectedvirtual

Start() 함수 내 IOCP 작업자 스레드 생성(CREATE_SUSPENDED) 후 호출되는 이벤트 함수

매개변수

thHnd

생성된 IOCP 작업자 스레드 핸들

반환값

생성된 IOCP 작업자 스레드 수행 여부

재정의를 통해 생성과 동시에 중지 상태인 IOCP 작업자 스레드의 핸들 인수를 통해 필요한 초기화 작업을 수행할 수 있다.
JNetCore에 설정된 IOCP 작업자 스레드 생성 갯수와 별개로 수행되는 작업자 스레드 갯수를 제어할 수 있다.
true 반환 시 중지된 작업자 스레드의 수행이 시작되고, false 반환 시 스레드는 강제 종료된다.

{ return true; }

OnAllWorkerThreadCreate()

void JNetCore::OnAllWorkerThreadCreate ( )

protectedvirtual

Start() 함수 내 요청된 수 만큼 IOCP 작업자 스레드를 생성한 후 함수를 빠져나오기 전 호출되는 이벤트 함수

{}

OnWorkerThreadStart()

void JNetCore::OnWorkerThreadStart ( )

protectedvirtual

개별 IOCP 작업자 스레드의 수행 흐름 초입부(WorkerThreadFunc 함수 초입부)에 호출되는 이벤트 함수, 개별 작업자 스레드의 초기화를 독립적으로 수행하도록 재정의 가능

IOCP 작업자 스레드 개별 수행 흐름의 초입에 호출되는 함수로 GetQueuedCompletionStatus 함수가 포함된 작업 루프 이전에 호출된다. 주로 JNetCore 단에서 관리되는 TLS 기반의 메모리 풀을 할당받고, 초기화하는 작업을 수행한다.

{}

OnWorkerThreadEnd()

void JNetCore::OnWorkerThreadEnd ( )

protectedvirtual

개별 IOCP 작업자 스레드가 종료(작업자 함수 return) 전 호출되는 이벤트 함수

{ std::cout << "IOCP Worker Thread Exits.."; }

OnRecvCompletion()

virtual void jnet::JNetCore::OnRecvCompletion ( SessionID64 sessionID, JBuffer & recvRingBuffer )

protectedpure virtual

IOCP 작업자 스레드의 수신 완료 시 대상 세션의 수신 버퍼의 enqueue 오프셋 제어 후 호출되는 이벤트 함수

IOCP 작업자 스레드의 수신 완료 시 대상 세션의 수신 버퍼의 enqueue 오프셋 제어 후 호출되는 함수이다. JNetCore는 순전히 IOCP 작업자 스레드와 세션 관리 및 송수신의 책임만을 제공하기에 수신 이후의 작업을 하위 클래스에서 정의하도록 순수 가상 함수로써 강제하였다. OnRecvCompletion 함수의 반환 이후 해당 세션의 수신 버퍼가 수신 요청되기에 OnRecvCompletion 함수에서는 수신 버퍼에 대한 작업자 스레드 간의 경쟁은 없다. 따라서 단지 수신 버퍼의 참조만을 전달하여 복사 비용 발생을 방지하였다.

매개변수

sessionID	세션 아이디(uint64)
recvRingBuffer	세션의 수신 버퍼 참조

jnet::JNetClient, jnet::JNetServer에서 구현되었습니다.

OnSessionLeave()

void JNetCore::OnSessionLeave ( SessionID64 sessionID )

protectedvirtual

JNetCore 단 세션이 제거된 후 호출되는 이벤트 함수

매개변수

sessionID

세션 아이디(uint64)

관리되는 세션이 제거된 후 호출되는 함수이다. 호출 시점에서 sessionID는 이미 제거된 세션 ID이며, 유효하지 않다. 콘텐츠 서버와 같은 하위 클래스에서 sessionID를 기반으로 한 데이터를 해당 함수 재정의에서 제거하는 등 정리 작업을 수행할 수 있다.

jnet::JNetClient, jnet::JNetServer에서 재구현되었습니다.

{}

OnError()

void JNetCore::OnError ( )

protectedvirtual

{};

AcquireSession()

JNetCore::JNetSession * JNetCore::AcquireSession ( SessionID64 sessionID )

private

Multi IOCP 작업자 스레드 간 thread-safe 하지 않은 세션에 대해 세션 접근 전 호출하는 함수

매개변수

접근

대상 세션 아이디

반환값

해당 세션 객체 포인터

특정 세션에 대한 접근에 있어 thread-safe를 보장할 수 없다. 따라서 주로 컨텐츠 코드에서 호출되는 SendPacket 계열의 요청 함수에서는 세션 독점 점유가 필요하다.
AcquireSession 함수는 독점적인 점유를 보장한다. 독점적인 점유에 성공한다면 해당 세션 객체의 포인터를 반환하며, 실패 시 nullptr을 반환한다.
하위 클래스에 이벤트 함수 등으로 전달되는 세션 아이디(uin64)는 64비트열을 하나의 정수로 전달하는 간단한 추상화이며, JNetCore 단에서는 16비트의 인덱스 번호와 48비트의 증분 값으로 관리된다.
세션 객체의 참조 카운트와 단일 플래그로 구성된 참조 구조체 멤버를 원자적 연산으로 제어하여 세션 객체에 대한 동기화를 내부적으로 수행한다.

{
    uint16 idx = (uint16)sessionID;
    JNetSession* session = m_Sessions[idx]; // 세션 ID의 인덱스 파트를 통해 세션 획득
                                                // AcquireSession을 호출하는 시점에서 찾고자 하였던 세션을 획득하였다는 보장은 할 수 없음  
    if (session == nullptr) {                   
        return nullptr;
    }
    else {
        // 세션 참조 카운트(ioCnt) 증가!
        long ref32 = InterlockedIncrement(reinterpret_cast<long*>(&session->m_SessionRef));
 
        // 세션 IOCnt를 증가한 시점 이후,
        // 참조하고자 하였던 본래 세션이든, 또는 같은 인덱스 자리에 재활용된 세션이든 삭제되지 않는 보장을 할 수 있음
 
        // (1) if(session->sessionRef.releaseFlag == 1)
        //      => 본래 참조하고자 하였던 세션 또는 새로운 세션이 삭제(중)
        // (2) if(session->sessionRef.releaseFlag == 0 && sessionID != session->uiId)
        //      => 참조하고자 하였던 세션은 이미 삭제되고, 새로운 세션이 동일 인덱스에 생성
        if (session->m_SessionRef.releaseFlag == 1 || sessionID != session->m_ID) {
            // 세션 참조 카운트(ioCnt) 감소
            InterlockedDecrement(reinterpret_cast<long*>(&session->m_SessionRef));
 
            // 세션 삭제 및 변경 가능 구역
            // ....
 
            // case0) ioCnt >= 1, 세션 유효
            // case1) releaseFlag == 1 유지, 세션 삭제(중)
            // caas2) releaseFlag == 0, ioCnt == 0
            //          => Disconnect 책임
 
            JNetSession::SessionRef exgRef(1, 0);
            int32 orgRef32 = InterlockedCompareExchange(reinterpret_cast<long*>(&session->m_SessionRef), exgRef, 0);
            JNetSession::SessionRef orgRef = orgRef32;
 
            // releaseFlag == 0이 된 상태에서 ioCnt == 0이 된 상황
            // => Disconnect 호출 책임
            // CAS를 진행하였기에 CAS 이 후부터 세션 삭제는 없음이 보장됨
            if (orgRef.refCnt == 0 && orgRef.releaseFlag == 0) {
                Disconnect(session->m_ID);
            }
            else if (orgRef.refCnt == 0 && orgRef.releaseFlag == 1) {
                // 새로운 세션 생성 전
                // nothing to do..
            }
#if defined(ASSERT)
            else if (orgRef.refCnt < 0) {
                DebugBreak();
            }
#endif
            return nullptr;
        }
        else {
            // 기존 세션 확정 -> 반환 (ioCnt == 1이라면 ReturnSession에서 처리할 것)
            return session;
        }
    }
}

ReturnSession()

void JNetCore::ReturnSession ( JNetSession * session )

private

AcquireSession을 통해 획득한 세션 객체 소유권 반납

매개변수

세션

객체 포인터

{
    if (session->m_SessionRef.refCnt < 1) {
#if defined(ASSERT)
        DebugBreak();
#endif
        return;
    }
 
    uint64 savedSessionID = session->m_ID;      // ioCnt와 r
 
    int32 ref32 = InterlockedDecrement(reinterpret_cast<long*>(&session->m_SessionRef));
 
    JNetSession::SessionRef exgRef(1, 0);
    int32 orgRef32 = InterlockedCompareExchange(reinterpret_cast<long*>(&session->m_SessionRef), exgRef, 0);
    JNetSession::SessionRef orgRef = orgRef32;
    if (orgRef.refCnt == 0 && orgRef.releaseFlag == 0) {
        Disconnect(savedSessionID);
    }
    else if (orgRef.refCnt == 0 && orgRef.releaseFlag == 1) {
        // 새로운 세션 생성 전
        // nothing to do..
    }
#if defined(ASSERT)
    else if (orgRef.refCnt < 0) {
        DebugBreak();
    }
#endif
}

SendPost()

void JNetCore::SendPost ( SessionID64 sessionID, bool onSendFlag = false )

private

SendPacket 계열 함수 내부에서 호출되는 실질적 송신 요청 함수

매개변수

sessionID	송신 대상 세션 아이디
onSendFlag

{
    uint16 idx = (uint16)sessionID;
    JNetSession* session = m_Sessions[idx];
 
    if (session == nullptr) {
        return;
    }
 
    if (onSendFlag || InterlockedExchange(reinterpret_cast<long*>(&session->m_SendFlag), 1) == 0) {
        memset(&session->m_SendOverlapped, 0, sizeof(WSAOVERLAPPED));
 
 
        int32 numOfMessages = session->m_SendBufferQueue.GetSize();
        //WSABUF wsabuffs[WSABUF_ARRAY_DEFAULT_SIZE];
        vector<WSABUF> wsaBuffVec(numOfMessages);
 
        if (numOfMessages > 0) {
            InterlockedIncrement(reinterpret_cast<long*>(&session->m_SessionRef));
            for (int32 idx = 0; idx < numOfMessages; idx++) {
                JBuffer* msgPtr;
                //session->sendBufferQueue.Dequeue(msgPtr);
                // => single reader 보장
                if (!session->m_SendBufferQueue.Dequeue(msgPtr, true)) {
                    DebugBreak();
                }
 
                //session->sendPostedQueue.push(msgPtr);
                // => push 오버헤드 제거
                session->m_SendPostedQueue.push(msgPtr);
 
                wsaBuffVec[idx].buf = reinterpret_cast<char*>(msgPtr->GetBeginBufferPtr());
                wsaBuffVec[idx].len = msgPtr->GetUseSize();
 
                if (wsaBuffVec[idx].buf == NULL || wsaBuffVec[idx].len == 0) {
#if defined(ASSERT)
                    DebugBreak();
#endif
                    return;
                }
 
            }
            session->m_SendOverlapped.Offset = numOfMessages;       // Offset 멤버를 활용하여 송신한 메시지 갯수를 담도록 한다.
 
            if (WSASend(session->m_Sock, wsaBuffVec.data(), numOfMessages, NULL, 0, &session->m_SendOverlapped, NULL) == SOCKET_ERROR) {
                int errcode = WSAGetLastError();
                if (errcode != WSA_IO_PENDING) {
                    int32 ref32 = InterlockedDecrement(reinterpret_cast<long*>(&session->m_SessionRef));
                    JNetSession::SessionRef ref(ref32);
#if defined(ASSERT)
                    if (ref.refCnt < 0) {
                        DebugBreak();
                    }
#endif
 
                    // SendPost는 iocp 워커 스레드에서도 다른 스레드에서도 호출 가능
                    // 따라서 Disconnect 호출 방식으로 세션 삭제 처리
                    JNetSession::SessionRef exgRef(1, 0);
                    int32 orgRef32 = InterlockedCompareExchange(reinterpret_cast<long*>(&session->m_SessionRef), exgRef, 0);
                    JNetSession::SessionRef orgRef = orgRef32;
                    if (orgRef.refCnt == 0 && orgRef.releaseFlag == 0) {
                        Disconnect(session->m_ID);
                    }
                }
            }
        }
        else {
            InterlockedExchange(reinterpret_cast<long*>(&session->m_SendFlag), 0);
        }
    }
}

SendPostRequest()

void JNetCore::SendPostRequest ( SessionID64 sessionID )

private

SendPost() 함수의 작업을 IOCP 작업자 스레드의 흐름에서 수행되도록 강제화를 요청하는 함수

매개변수

sessionID

송신 대상 세션 아이디

{
    uint16 idx = (uint16)sessionID;
    JNetSession* session = m_Sessions[idx];
 
    if (InterlockedCompareExchange(reinterpret_cast<long*>(&session->m_SendFlag), 1, 0) == 0) {
        InterlockedIncrement(reinterpret_cast<long*>(&session->m_SessionRef));
        PostQueuedCompletionStatus(m_IOCP, 0, (ULONG_PTR)session, (LPOVERLAPPED)IOCP_COMPLTED_LPOVERLAPPED_SENDPOST_REQ);
    }
}

FreeBufferedSendPacket()

void JNetCore::FreeBufferedSendPacket ( LockFreeQueue< JBuffer * > & sendBufferQueue, queue< JBuffer * > & sendPostedQueue )

private

세션 제거 시 송신 버퍼 정리

{
    while (sendBufferQueue.GetSize() > 0) {
        JBuffer* sendPacket;
        if (!sendBufferQueue.Dequeue(sendPacket)) {
            DebugBreak();
        }
        FreeSerialBuff(sendPacket);
    }
    while (!sendPostedQueue.empty()) {
        FreeSerialBuff(sendPostedQueue.front());
        sendPostedQueue.pop();
    }
}

WorkerThreadFunc()

UINT __stdcall JNetCore::WorkerThreadFunc ( void * arg )

staticprivate

IOCP 작업자 스레드의 수행 함수

{
    JNetCore* jnetcore = reinterpret_cast<JNetCore*>(arg);
 
    jnetcore->OnWorkerThreadStart();
    jnetcore->AllocTlsMemPool();
 
    while (true) {
        DWORD transferred = 0;
        ULONG_PTR completionKey;
        WSAOVERLAPPED* overlappedPtr;
 
        // I/O Completion Queue's record
        //  - (1) 송수신된 바이트 수
        //  - (2) 장치와 IOCP 연계 시 지정한 '컴플리션 큐' 
        //      => '세션' 식별
        //  - (3) 비동기 I/O 작업 요청 시 사용한 OVERLAPPED 구조체 포인터
        //      => 세션's 수신 OVERELAPPED 구조체 포인터, "수신 완료"
        //      => 세션's 송신 OVERLAPPED 구조체 포인터, "송신 완료"
        //      => IOCP_COMPLTED_LPOVERLAPPED_DISCONNECT / IOCP_COMPLTED_LPOVERLAPPED_SENDPOST_REQ 상수, "Disconnect 요청" / "SendPost" 요청
        GetQueuedCompletionStatus(jnetcore->m_IOCP, &transferred, (PULONG_PTR)&completionKey, &overlappedPtr, INFINITE);
        if (overlappedPtr != NULL) {
 
            JNetSession* session = reinterpret_cast<JNetSession*>(completionKey);
 
            if (overlappedPtr == (LPOVERLAPPED)IOCP_COMPLTED_LPOVERLAPPED_DISCONNECT) {
                // Disconnect 요청
                jnetcore->Proc_DeleteSession(session);
            }
            else if (overlappedPtr == (LPOVERLAPPED)IOCP_COMPLTED_LPOVERLAPPED_SENDPOST_REQ) {
                // SendPost 요청
                jnetcore->Proc_SendPostRequest(session);
            }
            else if (transferred == 0) {
                // 연결 종료
                jnetcore->Proc_DeleteSession(session);
            }
            else {
                if (overlappedPtr == &session->m_RecvOverlapped) {
                    // 수신 완료
                    jnetcore->Proc_RecvCompletion(session, transferred);
                }
                else if(overlappedPtr == &session->m_SendOverlapped){
                    // 송신 완료
                    jnetcore->Proc_SendCompletion(session);
                }
                else {
                    DebugBreak();
                    break;
                }
            }
        }
        else {
            //DebugBreak();
            // => Stop 호출 시 PostQueuedCompletionStatus(m_IOCP, 0, 0, NULL); 를 통해 종료
            break;
        }
    }
 
    jnetcore->OnWorkerThreadEnd();
 
    return 0;
}

Proc_DeleteSession()

void jnet::JNetCore::Proc_DeleteSession ( JNetSession * session )

private

IOCP 작업자 스레드의 세션 삭제 요청 처리 함수

{
    // 연결 종료 판단
    int32 ref32 = InterlockedDecrement(reinterpret_cast<long*>(&session->m_SessionRef));
    JNetSession::SessionRef ref(ref32);
    if (ref.refCnt < 0) {
#if defined(ASSERT)
        DebugBreak();
#else
        InterlockedIncrement(reinterpret_cast<long*>(&session->m_SessionRef));
#endif
    }
    else if (ref.refCnt == 0) {
        // 세션 제거...
        SessionID64 sessionID = session->m_ID;
        if (DeleteSession(sessionID)) {
            OnSessionLeave(sessionID);
        }
    }
}

Proc_SendPostRequest()

void jnet::JNetCore::Proc_SendPostRequest ( JNetSession * session )

private

IOCP 작업자 스레드의 송신 요청 시 처리 함수(SendPacket 계열 함수의 postToWorker 요청)

{
    // IOCP 작업자 스레드 측에서 SendPost 호출
    SendPost(session->m_ID, true);
    int32 ref32 = InterlockedDecrement((uint32*)&session->m_SessionRef);
    JNetSession::SessionRef ref(ref32);
    if (ref.refCnt < 0) {
#if defined(ASSERT)
        DebugBreak();
#else
        InterlockedIncrement(reinterpret_cast<long*>(&session->m_SessionRef));
#endif
    }
    else if(ref.refCnt == 0) {
        // 세션 제거...
        SessionID64 sessionID = session->m_ID;
        if (DeleteSession(sessionID)) {
            OnSessionLeave(sessionID);
        }
    }
}

Proc_RecvCompletion()

void jnet::JNetCore::Proc_RecvCompletion ( JNetSession * session, DWORD transferred )

private

IOCP 작업자 스레드의 수신 완료 통지 시 처리 함수

{
    session->m_RecvRingBuffer.DirectMoveEnqueueOffset(transferred);
    UINT recvBuffSize = session->m_RecvRingBuffer.GetUseSize();
    //if (recvBuffSize > m_MaxOfRecvBufferSize) {
    //  m_MaxOfRecvBufferSize = recvBuffSize;
    //}
 
    OnRecvCompletion(session->m_ID, session->m_RecvRingBuffer);
 
    memset(&session->m_RecvOverlapped, 0, sizeof(session->m_RecvOverlapped));
    WSABUF wsabuf;
    wsabuf.buf = (CHAR*)session->m_RecvRingBuffer.GetEnqueueBufferPtr();
    wsabuf.len = session->m_RecvRingBuffer.GetDirectEnqueueSize();
    DWORD dwflag = 0;
 
    if (wsabuf.len == 0) {
#if defined(ASSERT)
        // 0 바이트 수신 요청이 발생하는지 확인
        DebugBreak();
#else
        // 임시 조치 (불완전)
        session->m_RecvRingBuffer.ClearBuffer();
        wsabuf.buf = reinterpret_cast<char*>(session->m_RecvRingBuffer.GetEnqueueBufferPtr());
        wsabuf.len = session->m_RecvRingBuffer.GetDirectEnqueueSize();
#endif
    }
 
    if (WSARecv(session->m_Sock, &wsabuf, 1, NULL, &dwflag, &session->m_RecvOverlapped, NULL) == SOCKET_ERROR) {
        int errcode = WSAGetLastError();
        if (errcode != WSA_IO_PENDING) {
            int32 ref32 = InterlockedDecrement((uint32*)&session->m_SessionRef);
            JNetSession::SessionRef ref(ref32);
            if (ref.refCnt == 0) {
                // 세션 제거...
                SessionID64 sessionID = session->m_ID;
                if (DeleteSession(sessionID)) {
                    OnSessionLeave(sessionID);
                }
            }
        }
    }
}

Proc_SendCompletion()

void jnet::JNetCore::Proc_SendCompletion ( JNetSession * session )

private

IOCP 작업자 스레드의 송신 완료 통지 시 처리 함수

{
    for (int i = 0; i < session->m_SendOverlapped.Offset; i++) {
        JBuffer* sendBuff = session->m_SendPostedQueue.front();
        //IncrementSendTransactions(true, sendBuff->GetUseSize());
        FreeSerialBuff(sendBuff);
        session->m_SendPostedQueue.pop();
    }
 
    InterlockedExchange(reinterpret_cast<long*>(&session->m_SendFlag), 0);
 
    if (session->m_SendBufferQueue.GetSize() > 0) {
        SendPost(session->m_ID);
    }
 
    int32 ref32 = InterlockedDecrement((uint32*)&session->m_SessionRef);
    JNetSession::SessionRef ref(ref32);
    if (ref.refCnt == 0) {
        // 세션 제거...
        SessionID64 sessionID = session->m_ID;
        if (DeleteSession(sessionID)) {
            OnSessionLeave(sessionID);
        }
    }
}

CalcTpsThreadFunc()

UINT __stdcall jnet::JNetCore::CalcTpsThreadFunc ( void * arg )

staticprivate

{
    JNetCore* jnetcore = reinterpret_cast<JNetCore*>(arg);
 
    // Transaction / TPS / Total Transactions 초기화
    for (int i = 0; i < NUM_OF_TPS_ITEM; i++) {
        jnetcore->m_Transactions[i] = 0;
        jnetcore->m_TransactionsPerSecond[i] = 0;
        jnetcore->m_TotalTransaction[i] = 0;
    }
 
    while (true) {
        // Transaction / TPS / Total Transactions 갱신
        for (int i = 0; i < NUM_OF_TPS_ITEM; i++) {
            jnetcore->m_TransactionsPerSecond[i] = jnetcore->m_Transactions[i];
            jnetcore->m_TotalTransaction[i] += jnetcore->m_Transactions[i];
            jnetcore->m_Transactions[i] = 0;
        }
 
        Sleep(1000);
    }
    return 0;
}

GetAcceptTPS()

UINT jnet::JNetCore::GetAcceptTPS ( )

inline

{return GetTransactionsPerSecond(ACCEPT_TRANSACTION);}

GetRecvTPS()

UINT jnet::JNetCore::GetRecvTPS ( )

inline

{return GetTransactionsPerSecond(RECV_TRANSACTION);}

GetSendTPS()

UINT jnet::JNetCore::GetSendTPS ( )

inline

{return GetTransactionsPerSecond(SEND_TRANSACTION);}

GetTotalAcceptTransaction()

UINT64 jnet::JNetCore::GetTotalAcceptTransaction ( )

inline

{return GetTotalTransactions(ACCEPT_TRANSACTION);}

GetTotalRecvTransaction()

UINT64 jnet::JNetCore::GetTotalRecvTransaction ( )

inline

{return GetTotalTransactions(RECV_TRANSACTION);}

GetTotalSendTransaction()

UINT64 jnet::JNetCore::GetTotalSendTransaction ( )

inline

{return GetTotalTransactions(SEND_TRANSACTION);}

IncrementRecvTransactions()

void jnet::JNetCore::IncrementRecvTransactions ( bool threadSafe, UINT incre )

inline

{if (incre > 0) {IncrementTransactions(RECV_TRANSACTION, threadSafe, incre);}}

IncrementSendTransactions()

void jnet::JNetCore::IncrementSendTransactions ( bool threadSafe, UINT incre )

inline

{if (incre > 0) {IncrementTransactions(SEND_TRANSACTION, threadSafe, incre);}}

IncrementAcceptTransactions()

void jnet::JNetCore::IncrementAcceptTransactions ( bool threadSafe = false, UINT incre = 1 )

inline

{if (incre > 0) {IncrementTransactions(ACCEPT_TRANSACTION, threadSafe, incre);}}

IncrementTransactions()

void jnet::JNetCore::IncrementTransactions ( BYTE type, bool threadSafe = false, UINT incre = 1 )

inlineprivate

                                                                                          {
        if (threadSafe) {
            if (incre == 1) {InterlockedIncrement(&m_Transactions[type]);}
            else {InterlockedAdd((LONG*)&m_Transactions[type], incre);}
        }
        else {
            m_Transactions[type] += incre;
        }
    }

GetTransactionsPerSecond()

LONG jnet::JNetCore::GetTransactionsPerSecond ( BYTE type )

inlineprivate

{return m_TransactionsPerSecond[type];}

GetTotalTransactions()

UINT64 jnet::JNetCore::GetTotalTransactions ( BYTE type )

inlineprivate

{return m_TotalTransaction[type];}

멤버 데이터 문서화

m_Sessions

std::vector<JNetSession*> jnet::JNetCore::m_Sessions

private

세션 관리 벡터

m_MaximumOfSessions

uint16 jnet::JNetCore::m_MaximumOfSessions

private

수용 가능한 최대 세션 수

m_SessionIndexQueue

LockFreeQueue<uint16> jnet::JNetCore::m_SessionIndexQueue

private

세션 인덱스 할당 큐 (SessionID's index part)

m_SessionIncrement

uint64 jnet::JNetCore::m_SessionIncrement

private

세션 증분 (SessionID's increment part)

m_IOCP

HANDLE jnet::JNetCore::m_IOCP

private

JNetCore's IOCP 객체

m_NumOfIocpWorkerThrd

uint16 jnet::JNetCore::m_NumOfIocpWorkerThrd

private

IOCP 작업자 스레드 갯수

m_IocpWorkerThrdHnds

std::vector<HANDLE> jnet::JNetCore::m_IocpWorkerThrdHnds

private

IOCP 작업자 스레드 핸들 벡터

m_IocpWorkerThrdIDs

std::vector<uint32> jnet::JNetCore::m_IocpWorkerThrdIDs

private

IOCP 작업자 스레드's ID 벡터

m_TlsMemPoolMgr

TlsMemPoolManager<JBuffer, true, false> jnet::JNetCore::m_TlsMemPoolMgr

private

Tls 메모리 풀 관리 (직렬화 패킷 버퍼 풀 할당 및 관리자)

m_TlsMemPoolUnitCnt

size_t jnet::JNetCore::m_TlsMemPoolUnitCnt

private

m_TlsMemPoolUnitCapacity

size_t jnet::JNetCore::m_TlsMemPoolUnitCapacity

private

m_MemPoolBuffAllocSize

uint32 jnet::JNetCore::m_MemPoolBuffAllocSize

private

m_CalcTpsFlag

bool jnet::JNetCore::m_CalcTpsFlag

protected

NUM_OF_TPS_ITEM

const int jnet::JNetCore::NUM_OF_TPS_ITEM = 4

staticprivate

m_CalcTpsThread

HANDLE jnet::JNetCore::m_CalcTpsThread

private

m_Transactions

UINT jnet::JNetCore::m_Transactions[NUM_OF_TPS_ITEM]

private

m_TransactionsPerSecond

UINT jnet::JNetCore::m_TransactionsPerSecond[NUM_OF_TPS_ITEM]

private

m_TotalTransaction

UINT64 jnet::JNetCore::m_TotalTransaction[NUM_OF_TPS_ITEM]

private

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• include/JNetCore.h
• JNetCore/JNetCore.cpp