성댕쓰 똑똑한 생활

Unicode

성댕쓰 — Sun, 7 May 2023 00:26:19 +0900

가변길이 데이터 중 문자열을 보내는 방법에 대해 알아보자.

char sendData[1000] = "가"; // CP949
char sendData[1000] = u8"가"; // UTF-8 Unicode (한글 3바이트 + 로마 1바이트)
WCHAR sendData[1000] = L"가"; // UTF-16 (한글, 로마 2바이트)
TCHAR sendData[1000] = _T("가");

ClientPacketHandler.cpp

struct S_TEST
{
	uint64 id;
	uint32 hp;
	uint16 attack;
	// 가변 데이터
	// 1) 문자열 (ex. name)
	// 2) 그냥 바이트 배열 (ex. 길드 이미지)
	// 3) 일반 리스트
	vector<int64> buffs;

	wstring name;
};

...

void ClientPacketHandler::Handle_S_TEST(BYTE* buffer, int32 len)
{
	BufferReader br(buffer, len);

	PacketHeader header;
	br >> header;

	...

	wstring name;
	uint16 nameLen;
	br >> nameLen;
	name.resize(nameLen);

	br.Read((void*)name.data(), nameLen * sizeof(WCHAR));

	wcout.imbue(std::locale("kor"));
	wcout << name << endl;
}

ServerPacketHandler.cpp

SendBufferRef ServerPacketHandler::Make_S_TEST(uint64 id, uint32 hp, uint16 attack, vector<BuffData> buffs, wstring name)
{
	SendBufferRef sendBuffer = GSendBufferManager->Open(4096);
	
	BufferWriter bw(sendBuffer->Buffer(), sendBuffer->AllocSize());

	PacketHeader* header = bw.Reserve<PacketHeader>();
    
...

	bw << (uint16)name.size();
	bw.Write((void*)name.data(), name.size() * sizeof(WCHAR));

	header->size = bw.WriteSize();
	header->id = S_TEST; // 1 : Test Msg

	sendBuffer->Close(bw.WriteSize());

	return sendBuffer;
}

1. 문자열 집합과 인코딩의 차이는?

- 문자열 집합은 문자를 숫자에 매핑한 정보, 인코딩은 매핑한 정보를 어떻게 해석할 것인지에 대한 정보

2. UTF-8 encoding 이란?

- Unicode 문자열 집합을 해석하는 방법, e.g) 첫 바이트 마지막 비트가 0 이면 1바이트 만으로 해석하고 그렇지 않으면 2~3바이트로 해석하는 방법 (한글은 3바이트)

3. UTF-16 encoding 이란?

- Unicode 문자열 집합을 해석하는 방법. UTF-8 과 다르게 BMP 이외 모든 문자를 2바이트로 해석하는 방법

4. CP949 란?

- Encoding 방법, 그런데 2 가지 문자집합을 이용한다.

5. MBCS vs WBCS

- MBCS 는 가변길이 인코딩, WBCS 는 고정길이 인코딩. MBCS 대표로 UTF-8, WBCS 는 UTF-16이 있다.

참조 : [C++과 언리얼로 만드는 MMORPG 게임 개발 시리즈] Part4: 게임 서버 대시보드 - 인프런 | 강의 (inflearn.com)

PacketHandler

성댕쓰 — Sat, 6 May 2023 00:27:28 +0900

이전 시간에 만든 Packet을 쓰거나 읽을 때 필요한 공통적인 부분을 모듈화 해보자

ServerPacketHandler.h, ServerPacketHandler.cpp

#pragma once
enum
{
	S_TEST = 1 
}; 

struct BuffData
{
	uint64 buffId;
	float remainTime;
};

class ServerPacketHandler
{
public:
	static void HandlePacket(BYTE* buffer, int32 len);

	static SendBufferRef Make_S_TEST(uint64 id, uint32 hp, uint16 attack, vector<BuffData> buffs);
};

#include "pch.h"
#include "ServerPacketHandler.h"
#include "BufferReader.h"
#include "BufferWriter.h"

void ServerPacketHandler::HandlePacket(BYTE* buffer, int32 len)
{
	BufferReader br(buffer, len);
	
	PacketHeader header;
	br.Peek(&header);

	switch (header.id)
	{
	default:
		break;
	}
}

SendBufferRef ServerPacketHandler::Make_S_TEST(uint64 id, uint32 hp, uint16 attack, vector<BuffData> buffs)
{
	SendBufferRef sendBuffer = GSendBufferManager->Open(4096);
	
	BufferWriter bw(sendBuffer->Buffer(), sendBuffer->AllocSize());

	PacketHeader* header = bw.Reserve<PacketHeader>();
	// id(uint64), 체력(uint32), 공격력(uint16)
	bw << id << hp << attack;

	// 가변 데이터
	bw << (uint16)buffs.size();
	for (BuffData& buff : buffs)
	{
		bw << buff.buffId << buff.remainTime;
	}

	header->size = bw.WriteSize();
	header->id = S_TEST; // 1 : Test Msg

	sendBuffer->Close(bw.WriteSize());

	return sendBuffer;
}

ClientPacketHandler.h, ClientPacketHandler.cpp

#pragma once

enum
{
	S_TEST = 1
};

class ClientPacketHandler
{
public:
	static void HandlePacket(BYTE* buffer, int32 len);

	static void Handle_S_TEST(BYTE* buffer, int32 len);
};

#include "pch.h"
#include "ClientPacketHandler.h"
#include "BufferReader.h"

void ClientPacketHandler::HandlePacket(BYTE* buffer, int32 len)
{
	BufferReader br(buffer, len);

	PacketHeader header;
	br >> header;

	switch (header.id)
	{
	case S_TEST:
		Handle_S_TEST(buffer, len);
		break;
	}
}

// 패킷 설계 TEMP
struct BuffData
{
	uint64 buffId;
	float remainTime;
};

struct S_TEST
{
	uint64 id;
	uint32 hp;
	uint16 attack;
	// 가변 데이터
	// 1) 문자열 (ex. name)
	// 2) 그냥 바이트 배열 (ex. 길드 이미지)
	// 3) 일반 리스트
	vector<int64> buffs;
};

void ClientPacketHandler::Handle_S_TEST(BYTE* buffer, int32 len)
{
	BufferReader br(buffer, len);

	PacketHeader header;
	br >> header;

	uint64 id;
	uint32 hp;
	uint16 attack;
	br >> id >> hp >> attack;

	cout << "ID: " << id << " HP : " << hp << " ATT : " << attack << endl;

	vector<BuffData> buffs;
	uint16 buffCount;
	br >> buffCount;

	buffs.resize(buffCount);
	for (int32 i = 0; i < buffCount; i++)
	{
		br >> buffs[i].buffId >> buffs[i].remainTime;
	}

	cout << "BuffCount : " << buffCount << endl;
	for (int32 i = 0; i < buffCount; i++)
	{
		cout << "BufInfo : " << buffs[i].buffId << " " << buffs[i].remainTime << endl;
	}
}

GameSession.cpp

void GameSession::OnRecvPacket(BYTE* buffer, int32 len)
{
	ServerPacketHandler::HandlePacket(buffer, len);
}

GameServer.cpp

...

while (true)
{
    vector<BuffData> buffs{ BuffData{100, 1.5f}, BuffData{200, 2.3f}, BuffData{300, 0.7f} };
    SendBufferRef sendBuffer = ServerPacketHandler::Make_S_TEST(1001, 100, 10, buffs);

    GSessionManager.Broadcast(sendBuffer);

    this_thread::sleep_for(250ms);
}

...

DummyClient.cpp

...

virtual void OnRecvPacket(BYTE* buffer, int32 len) override
{
    ClientPacketHandler::HandlePacket(buffer, len);
}

...

BufferWriter.h

class BufferWriter
{
	...
    
    // 삭제 start
    template<typename T>
	BufferWriter& operator<<(const T& src);
    // 삭제 end
}

...

 // 삭제 start
template<typename T>
BufferWriter& BufferWriter::operator<<(const T& src)
{
	*reinterpret_cast<T*>(&_buffer[_pos]) = src;
	_pos += sizeof(T);
	return *this;
}
 // 삭제 end

template<typename T>
BufferWriter& BufferWriter::operator<<(T&& src)
{
	using DataType = std::remove_reference_t<T>;
	*reinterpret_cast<DataType*>(&_buffer[_pos]) = std::forward<DataType>(src);
	_pos += sizeof(T);
	return *this;
}

1. 기존 방법 안좋은 점

- Write 한 순서대로 Read 해야 함.

- Packet 지금 1 종류임.

2. 보편참조가 일어나는 조건은?

- rvalue 파라메터로 받는 template 함수, 같은 파라메터 이지만 lvalue로 받는 template 함수 있을 때, 전자 template 함수만 쓰이게 됨.

- 보편참조 함수에 lvalue 들어오면 "const T&" 로 rvalue 이면 "T&&"로 들어온다.

3. BufferWriter operator<<에 컴파일 에러가 생기는 이유와 해결방?
- 보편참조 함수에 uint64 들어옴 > 함수 안에서 const uint64& (= T값)의 포인터를 추출하려고 시도하기 때문임.

- 레퍼런스를 뺀 나머지만 이용하여 연산하면 해결됨.

- std::remove_reference_t<T> 는 T에 레퍼런스가 있으면 떼줌.

참조 : [C++과 언리얼로 만드는 MMORPG 게임 개발 시리즈] Part4: 게임 서버 대시보드 - 인프런 | 강의 (inflearn.com)

Buffer Helpers

성댕쓰 — Wed, 19 Apr 2023 22:38:50 +0900

버퍼에 데이터 쓰고 읽는데 도움주는 클래스를 만들어 보자.

BufferReader.h, BufferReader.cpp

#pragma once

/*--------------------
	BufferReader
--------------------*/

class BufferReader
{
public:
	BufferReader();
	BufferReader(BYTE* buffer, uint32 size, uint32 pos = 0);
	~BufferReader();

	BYTE* Buffer() { return _buffer; }
	uint32 Size() { return _size; }
	uint32 ReadSize() { return _pos; }
	uint32 FreeSize() { return _size - _pos; }

	template<typename T>
	bool Peek(T* dest) { return Peek(dest, sizeof(T)); }
	bool Peek(void* dest, uint32 len);

	template<typename T>
	bool Read(T* dest) { return Read(dest, sizeof(T)); }
	bool Read(void* dest, uint32 len);

	template<typename T>
	BufferReader& operator>>(OUT T& dest);

private:
	BYTE* _buffer = nullptr;
	uint32 _size = 0;
	uint32 _pos = 0;

};

template<typename T>
BufferReader& BufferReader::operator>>(OUT T& dest)
{
	dest = *reinterpret_cast<T*>(&_buffer[_pos]);
	_pos += sizeof(T);
	return *this;
}

#include "pch.h"
#include "BufferReader.h"

/*--------------------
	BufferReader
--------------------*/

BufferReader::BufferReader()
{
}

BufferReader::BufferReader(BYTE* buffer, uint32 size, uint32 pos /*=0*/)
	:_buffer(buffer), _size(size), _pos(pos)
{
}

BufferReader::~BufferReader()
{
}

bool BufferReader::Peek(void* dest, uint32 len)
{
	if (FreeSize() < len)
		return false;

	::memcpy(dest, &_buffer[_pos], len);
	return true;
}

bool BufferReader::Read(void* dest, uint32 len)
{
	if (Peek(dest, len) == false)
		return false;

	_pos += len;
	return true;
}

BufferWriter.h, BufferWriter.cpp

#pragma once
/*--------------------
	BufferWriter
--------------------*/

class BufferWriter
{
public:
	BufferWriter();
	BufferWriter(BYTE* buffer, uint32 size, uint32 pos = 0);
	~BufferWriter();

	BYTE* Buffer() { return _buffer; }
	uint32 Size() { return _size; }
	uint32 WriteSize() { return _pos; }
	uint32 FreeSize() { return _size - _pos; }

	template<typename T>
	bool Write(T* src) { return Write(src, sizeof(T)); }
	bool Write(void* src, uint32 len);

	template<typename T>
	T* Reserve();

	template<typename T>
	BufferWriter& operator<<(const T& src);

	template<typename T>
	BufferWriter& operator<<(T&& src);

private:
	BYTE* _buffer = nullptr;
	uint32 _size = 0;
	uint32 _pos = 0;

};

template<typename T>
T* BufferWriter::Reserve()
{
	if (FreeSize() < sizeof(T))
		return nullptr;

	T* ret = reinterpret_cast<T*>(&_buffer[_pos]);
	_pos += sizeof(T);
	return ret;
}

template<typename T>
BufferWriter& BufferWriter::operator<<(const T& src)
{
	*reinterpret_cast<T*>(&_buffer[_pos]) = src;
	_pos += sizeof(T);
	return *this;
}

template<typename T>
BufferWriter& BufferWriter::operator<<(T&& src)
{
	*reinterpret_cast<T*>(&_buffer[_pos]) = std::move(src);
	_pos += sizeof(T);
	return *this;
}

#include "pch.h"
#include "BufferWriter.h"

/*--------------------
	BufferWriter
--------------------*/

BufferWriter::BufferWriter()
{
}

BufferWriter::BufferWriter(BYTE* buffer, uint32 size, uint32 pos)
	:_buffer(buffer), _size(size), _pos(pos)
{
}

BufferWriter::~BufferWriter()
{
}

bool BufferWriter::Write(void* src, uint32 len)
{
	if (FreeSize() < len)
		return false;

	::memcpy(&_buffer[_pos], src, len);
	_pos += len;
	return true;
}

BufferWriter는 아래처럼 사용

GameServer.cpp

...
while (true)
{
    SendBufferRef sendBuffer = GSendBufferManager->Open(4096);
    
    BufferWriter bw(sendBuffer->Buffer(), 4096);

    PacketHeader* header = bw.Reserve<PacketHeader>();
    // id(uint64), 체력(uint32), 공격력(uint16)
    bw << (uint64)1001 << (uint32)100 << (uint16)10;
    bw.Write(sendData, sizeof(sendData));

    header->size = bw.WriteSize();
    header->id = 1; // 1 : Test Msg

    sendBuffer->Close(bw.WriteSize());
    
    GSessionManager.Broadcast(sendBuffer);

    this_thread::sleep_for(250ms);
}
...

BufferReader는 아래처럼 사용

DummyClient.cpp

...
virtual int32 OnRecvPacket(BYTE* buffer, int32 len) override
{
    BufferReader br(buffer, len);

    PacketHeader header;
    br >> header;

    uint64 id;
    uint32 hp;
    uint16 attack;
    br >> id >> hp >> attack;

    cout << "ID: " << id << " HP : " << hp << " ATT : " << attack << endl;

    char recvBuffer[4096];
    br.Read(recvBuffer, header.size - sizeof(PacketHeader) - 8 - 4 - 2);
    cout << recvBuffer << endl;

    return len;
}
...

1. BufferReader operator >> 이 하는 역할은?

- 데이터를 읽고 position을 읽은 만큼 이동시킴.

2. Peek 의 역할은?

- 데이터를 파싱할 수 있는지 확인함.

3. BufferReader 사용법과 설명, BufferWriter 사용법과 설명?

- BufferReader : Iocp Recv 이벤트 받음> ProcessRecv > OnRecv > OnRecvPacket 에서 write한 순서대로 읽음 마지막 len 계산은 가변길이 정보 읽는 방법 보여준 것.

- BufferWriter : SendBufferRef 생성 > BufferWriter 생성 > '<<' operator로 write > 'Hello World' 가변길이 데이터 보내기

Packet Session

성댕쓰 — Sun, 16 Apr 2023 21:25:25 +0900

Session.h, Session.cpp

...
/*----------------
  PacketSession
----------------*/

struct PacketHeader
{
	uint16 size;
	uint16 id; // 프로토콜ID (ex. 1=로그인, 2=이동요청)
};

// [size(2)][id(2)][data...]...[size(2)][id(2)][data...]
class PacketSession : public Session
{
public:
	PacketSession();
	virtual ~PacketSession();

	PacketSessionRef GetPacketSessionRef() { return static_pointer_cast<PacketSession>(shared_from_this()); }

protected:
	virtual int32 OnRecv(BYTE* buffer, int32 len) sealed;
	virtual int32 OnRecvPacket(BYTE* buffer, int32 len) abstract;
};

...
void Session::Send(SendBufferRef sendBuffer)
{
    if (IsConnected() == false)
        return;

    bool registerSend = false;
    
    // 현재 RegisterSend가 걸리지 않은 상태라면, 걸어준다
    {
		WRITE_LOCK;

		_sendQueue.push(sendBuffer);

        if (_sendRegistered.exchange(true) == false)
            registerSend = true;
    }

    if (registerSend)
        RegisterSend();
}
...
void Session::Disconnect(const WCHAR* cause)
{
    if (_connected.exchange(false) == false)
        return;

    // TEMP
    wcout << "Disconnect : " << cause << endl;

    RegisterDisconnect();
}
...
void Session::ProcessDisconnect()
{
    _disconnectEvent.owner = nullptr; // RELEASE_REF
    
    OnDisconnected(); // 컨텐츠 코드에서 오버라이딩
    GetService()->ReleaseSession(GetSessionRef());
}
...
/*----------------
  PacketSession
----------------*/

PacketSession::PacketSession()
{
}

PacketSession::~PacketSession()
{
}

// [size(2)][id(2)][data...]...[size(2)][id(2)][data...]
int32 PacketSession::OnRecv(BYTE* buffer, int32 len)
{
    int32 processLen = 0;

    while (true)
    {
        int32 dataSize = len - processLen;
        // 최소한 헤더는 파싱할 수 있어야 한다.
        if (dataSize < sizeof(PacketHeader))
            break;

        PacketHeader header = *(reinterpret_cast<PacketHeader*>(&buffer[processLen]));
        // 헤더에 기록된 패킷 크기를 파싱할 수 있어야 한다.
        if (dataSize < header.size)
            break;

        // 패킷 조립 성공
        OnRecvPacket(&buffer[processLen], header.size);

        processLen += header.size;
    }

    return processLen;
}

GameSession.h, GameSession.cpp

...
class GameSession : public PacketSession
{
public:
	~GameSession()
	{
		cout << "~GameSession" << endl;
	}

	virtual void OnConnected() override;
	virtual void OnDisconnected() override;
	virtual int32 OnRecvPacket(BYTE* buffer, int32 len) override;

	virtual void OnSend(int32 len) override;
};

...
int32 GameSession::OnRecvPacket(BYTE* buffer, int32 len)
{
	PacketHeader header = *((PacketHeader*)&buffer[0]);
	cout << "Packet ID : " << header.id << "Size : " << header.size << endl;

	return len;
}
...

GameServer.cpp

...
#include "GameSessionManager.h"

int main()
{
...
	char sendData[1000] = "Hello World";

	while (true)
	{
		SendBufferRef sendBuffer = GSendBufferManager->Open(4096);
		
		BYTE* buffer = sendBuffer->Buffer();
		((PacketHeader*)buffer)->size = (sizeof(sendData) + sizeof(PacketHeader));
		((PacketHeader*)buffer)->id = 1; // 1 : Hello Msg
		::memcpy(&buffer[4], sendData, sizeof(sendData));
		sendBuffer->Close((sizeof(sendData) + sizeof(PacketHeader)));
		
		GSessionManager.Broadcast(sendBuffer);

		this_thread::sleep_for(250ms);
	}
}

DummyClient.cpp

...
class ServerSession : public PacketSession
{
...
	virtual void OnConnected() override
	{
		//cout << "Connected To Server" << endl;
	}

	virtual int32 OnRecvPacket(BYTE* buffer, int32 len) override
	{
		PacketHeader header = *((PacketHeader*)&buffer[0]);
		//cout << "Packet ID : " << header.id << "Size : " << header.size << endl;

		char recvBuffer[4096];
		::memcpy(recvBuffer, &buffer[4], header.size - sizeof(PacketHeader));
		cout << recvBuffer << endl;

		return len;
	}

	virtual void OnSend(int32 len) override
	{
		//cout << "OnSend Len = " << len << endl;
	}

	virtual void OnDisconnected() override
	{
		//cout << "Disconnected" << endl;
	}
};

1. Session::Send 효율적이지 못한 부분은?

- 어느 한 쓰레드가 RegisterSend 호출 중 이라면 WriteLock에서 다른 많은 Send 요청이 대기 할 수 있음.

2. PacketSession 이 필요한 이유는?

- 보낸 모든 데이터를 한 번에 받는 다는 보장이 없는 TCP 특성 때문에, 데이터 모두 받았음을 확인 할 수 있는 수단이 필요.

3. PacketSession::OnRecv에서 header가 덜 들어왔거나 header만 들어온 상황은 어떻게 처리하지?

- RegisterRecv() > ProcessRecv() 호출 되면서 아직 들어오지 않은 부분 들어옴.

4. 접속 Client의 개수를 1000개로 늘리면, server broadcast에서 crash 나는 이유는 그리고 해결방법?

- sessions iterate 하다가 sessions 에 변화가 생겨서 남. OnDisconnect에서 session remove하고 있음.

- 해결방법 : Disconnect에서 session remove하지 않고 ProcessDisconnect에서 한다.

SendBuffer Pooling

성댕쓰 — Wed, 5 Apr 2023 22:54:44 +0900

Sendbuffer를 Pooling 하여 사용하도록 바꿔보자

CoreTLS.h, CoreTLS.cpp

#pragma once
#include <stack>

extern thread_local uint32 LThreadId;
extern thread_local std::stack<int32> LLockStack;
extern thread_local SendBufferChunkRef LSendBufferChunk;

#include "pch.h"
#include "CoreTLS.h"

thread_local uint32 LThreadId = 0;
thread_local std::stack<int32> LLockStack;
thread_local SendBufferChunkRef LSendBufferChunk;

SendBuffer.h, SendBuffer.cpp

#pragma once

class SendBufferChunk;
/*-----------
  SendBuffer
-----------*/

class SendBuffer
{
public:
	SendBuffer(SendBufferChunkRef owner, BYTE* buffer, int32 allocSize);
	~SendBuffer();

	BYTE* Buffer() { return _buffer; }
	int32 WriteSize() { return _writeSize; }
	void Close(uint32 writeSize);

private:
	BYTE* _buffer;
	uint32 _allocSize = 0;
	uint32 _writeSize = 0;
	SendBufferChunkRef _owner;
};

/*---------------------
  SendBufferChunk
---------------------*/

class SendBufferChunk : public enable_shared_from_this<SendBufferChunk>
{
	enum
	{
		SEND_BUFFER_CHUNK_SIZE = 6000
	};

public:
	SendBufferChunk();
	~SendBufferChunk();

	void Reset();
	SendBufferRef Open(uint32 allocSize);
	void Close(uint32 writeSize);

	bool IsOpen() { return _open; }
	BYTE* Buffer() { return &_buffer[_usedSize]; }
	uint32 FreeSize() { return static_cast<uint32>(_buffer.size()) - _usedSize; }

private:
	Array<BYTE, SEND_BUFFER_CHUNK_SIZE> _buffer = {};
	bool _open = false;
	uint32 _usedSize = 0;
};

/*---------------------
  SendBufferManager
---------------------*/

class SendBufferManager
{
public:
	SendBufferRef Open(uint32 size);

private:
	SendBufferChunkRef Pop();
	void Push(SendBufferChunkRef buffer);

	static void PushGlobal(SendBufferChunk* buffer);

private:
	USE_LOCK;
	Vector<SendBufferChunkRef> _sendBufferChunks;
};

#include "pch.h"
#include "SendBuffer.h"

/*-----------
  SendBuffer
-----------*/

SendBuffer::SendBuffer(SendBufferChunkRef owner, BYTE* buffer, int32 allocSize)
	: _owner(owner), _buffer(buffer), _allocSize(allocSize)
{

}

SendBuffer::~SendBuffer()
{
}

void SendBuffer::Close(uint32 writeSize)
{
	ASSERT_CRASH(_allocSize >= writeSize);
	_writeSize = writeSize;
	_owner->Close(writeSize);
}

/*---------------------
  SendBufferChunk
---------------------*/

SendBufferChunk::SendBufferChunk()
{
}

SendBufferChunk::~SendBufferChunk()
{
}

void SendBufferChunk::Reset()
{
	_open = false;
	_usedSize = 0;
}

SendBufferRef SendBufferChunk::Open(uint32 allocSize)
{
	ASSERT_CRASH(allocSize <= SEND_BUFFER_CHUNK_SIZE);
	ASSERT_CRASH(_open == false);

	if (allocSize > FreeSize())
		return nullptr;

	_open = true;
	return ObjectPool<SendBuffer>::MakeShared(shared_from_this(), Buffer(), allocSize);
}

void SendBufferChunk::Close(uint32 writeSize)
{
	ASSERT_CRASH(_open == true);
	_open = false;
	// cursor 옮기기
	_usedSize += writeSize;
}

/*---------------------
  SendBufferManager
---------------------*/

//[                 ] 많이 예약해두고 일부만 사용
SendBufferRef SendBufferManager::Open(uint32 size)
{
	if (LSendBufferChunk == nullptr)
	{ 
		LSendBufferChunk = Pop(); // WRITE_LOCK
		LSendBufferChunk->Reset();
	} 

	ASSERT_CRASH(LSendBufferChunk->IsOpen() == false);
	
	// 다 썼으면 버리고 새것으로 교체
	if (LSendBufferChunk->FreeSize() < size)
	{
		LSendBufferChunk = Pop(); // WRITE_LOCK
		LSendBufferChunk->Reset();
	}

	cout << "Free : " << LSendBufferChunk->FreeSize() << endl;

	return LSendBufferChunk->Open(size);
}

SendBufferChunkRef SendBufferManager::Pop()
{
	{
		WRITE_LOCK;
		if (_sendBufferChunks.empty() == false)
		{
			SendBufferChunkRef sendBufferChunk = _sendBufferChunks.back();
			_sendBufferChunks.pop_back();
			return sendBufferChunk;
		}
	}

	return SendBufferChunkRef(xnew<SendBufferChunk>(), PushGlobal);
}

void SendBufferManager::Push(SendBufferChunkRef buffer)
{
	WRITE_LOCK;
	_sendBufferChunks.push_back(buffer);
}

void SendBufferManager::PushGlobal(SendBufferChunk* buffer)
{
	GSendBufferManager->Push(SendBufferChunkRef(buffer, PushGlobal));
}

개선할 점? 매번마다 OnRecv에서 MakeShared ?? 근데, 메모리 풀 사용하잖아? 그럼에도 메모리 양이 커지면 pooling 안하고 new, delete 방식임.

메모리 미리 많이 잡아서 sendbuffer 잡는 게 낭비

크게 할당 (SendBufferChunk ) 잘라먹기 가 포인트

SendBufferManager에서 더 이상 사용하지 않는 메모리 관리하는 방법은?

- 메모리 풀에 해당 메모리 반납

SendBufferChunkRef를 tls에 만드는 이유는?

- lock 사용을 최소화 하기 위함.

할당 한 Chunk 메모리를 모두 사용하여 새 거로 교체되면 이전 메모리는 해제 되지 않음을 어떻게 보장하는지?

- SendBuffer는 WSASend에서 Ref 카운팅 되고 있다.

참조 : [C++과 언리얼로 만드는 MMORPG 게임 개발 시리즈] Part4: 게임 서버 대시보드 - 인프런 | 강의 (inflearn.com)

DllMain 정리

성댕쓰 — Wed, 24 Aug 2022 15:13:11 +0900

DllMain

Dynamic link library로 링크할 경우, DllMain이 진입점 함수로 불린다.

기본 함수 모양은 다음과 같다.
함수 이름은 대소문자 구별하므로 주의하자.

BOOL WINAPI DllMain(
    HINSTANCE hinstDLL,  // handle to DLL module
    DWORD fdwReason,     // reason for calling function
    LPVOID lpvReserved )  // reserved
{
    // Perform actions based on the reason for calling.
    switch( fdwReason ) 
    { 
        case DLL_PROCESS_ATTACH:
         // Initialize once for each new process.
         // Return FALSE to fail DLL load.
            break;

        case DLL_THREAD_ATTACH:
         // Do thread-specific initialization.
            break;

        case DLL_THREAD_DETACH:
         // Do thread-specific cleanup.
            break;

        case DLL_PROCESS_DETACH:
        
            if (lpvReserved != nullptr)
            {
                break; // do not do cleanup if process termination scenario
            }
            
         // Perform any necessary cleanup.
            break;
    }
    return TRUE;  // Successful DLL_PROCESS_ATTACH.
}

DllMain은 프로세스 시작이나 쓰레드 시작할 때 호출된다.
fdwReason에 각 상황에 따라 다음 4가지 중 하나의 값으로 들어온다.

DLL_ATTACH_PROCESS
DLL_DETACH_PROCESS
DLL_ATTACH_THREAD
DLL_DETACH_THREAD

lpReserved는 DLL_PROCESS_ATTACH인 경우,

Dll이 명시적 런타임 링크 방식으로 로드 되면 NULL
암시적 로드타임 링크 방식이면 not NULL

값을 갖는다.

DLL_PROCESS_DETACH인 경우,

FreeLibrary 호출 또는 Dll 로드 실패이면 NULL
프로세스가 종료중이라면 not NULL

값을 갖는다.

주의사항

DllMain이 호출되었을 때 다른 Dll은 로드되지 않았거나, DllMain이 호출되지 않았을 수도 있다.
따라서, DllMain에서 다른 dll의 함수를 호출하면 안된다.
또한 Dll 의존 루프가 발생할 수도 있어서, LoadLibrary, FreeLibrary도 호출해선 안된다.

DllMain 함수를 만들지 않으면 C/C++ 런타임 라이브러리 DllMain 함수가 사용된다.

DllMain의 네 가지 통지

DLL_PROCESS_ATTACH

2. DLL_PROCESS_DETACH

프로세스 종료
- 특정 쓰레드가 TerminateProcess 함수 호출하여 프로세스 종료하면,
  다른 DllMain 호출하지 않음.

2. FreeLibrary 호출

3. DLL_THREAD_ATTACH
프로세스 내에 새로운 쓰레드가 생성되면,
시스템은 프로세스에 로드된 모든 dll의 DllMain함수를
DLL_THRAD_ATTACH값을 전달하여 호출한다.
하지만 쓰레드가 먼저 생성되고 Dll이 로드 되었다면 호출되지 않는다.
또, DLL_PROCESS_ATTACH를 호출한 쓰레드에 대해선 호출하지 않는다.

4. DLL_THREAD_DETACH
시스템은 ExitThread를 호출할 때 스레드를 바로 죽이지 않고
프로세스 주소 공간에 매핑된 모든 dll의 DLL_THREAD_DETACH 값을 인자로 하여 호출하고
모든 Dll이 DllMain함수를 반환하면 그 때 쓰레드를 종료한다.
만약, 특정 스레드가 TerminateThread 함수를 호출하여 스레드를 종료한 경우
DLL_THREAD_DETACH 값으로 어떤 DllMain 함수도 호출되지 않는다.

참고 :
https://docs.microsoft.com/en-us/windows/win32/dlls/dllmain?redirectedfrom=MSDN
http://egloos.zum.com/sweeper/v/2991972

Strand 정리

성댕쓰 — Tue, 23 Aug 2022 14:54:10 +0900

Strands 란

event handler 순차 실행을 보장하는 api.
이를 활용하면, 멀티 쓰레드 환경에서 명시적 lock없이 코드를 만들 수 있다.

strand는 application code와 handler 실행 사이에 layer를 제공한다.
worker thread가 직접 handler를 호출하지 않고 strand queue에 쌓는다.

Strand Implementation

Strand가 보장해야 할 기능은 다음과 같다.

동시에 핸들러를 실행하지 않는다.
- 이를 만족하기 위해, worker 스레드가 strand를 실행하고 있는지 확인할 수 있어야 한다.
- strand는 queue를 가지고 handler를 queuing 한다.
핸들러는 worker 스레드에서만 실행된다.(boost 용어로 io_service::run 실행하는 thread)
핸들러 실행 순서는 보장하지 않음.

구현해야할 주요 메서드는 다음과 같다.

post
- 추후 실행할 handler를 추가하는 기능. 핸들러를 실행하지 않는다.
dispatch
- 조건이 맞으면 handler 바로 실행. 아니면, post 한다.
run
- 대기중인 handler 실행. public interface 아님.

사용한 Helper class는 다음과 같다.

CallStack
- 현재 콜스택에 마커를 놓고, 현재 스레드에서 함수가 실행되는지 확인할 수 있게 해줌.
WorkQueue
- 간단한 mutiple producer / consumer queue.

그리고 monitor 클래스.
Object T에 접근할 때 동기화 기능을 갖게 한다.

template <class T>
class Monitor {
private:
    mutable T m_t;
    mutable std::mutex m_mtx;
 
public:
    using Type = T;
    Monitor() {}
    Monitor(T t_) : m_t(std::move(t_)) {}
    template <typename F>
    auto operator()(F f) const -> decltype(f(m_t)) {
        std::lock_guard<std::mutex> hold{m_mtx};
        return f(m_t);
    }
};

Strand 구현

#pragma once
#include "Callstack.h"
#include "Monitor.h"
#include <assert.h>
#include <queue>
#include <functional>
 
//
// A strand serializes handler execution.
// It guarantees the following:
// - No handlers executes concurrently
// - Handlers are only executed from the specified Processor
// - Handler execution order is not guaranteed
//
// Specified Processor must implement the following interface:
//
//  template <typename F> void Processor::push(F w);
//      Add a new work item to the processor. F is a callable convertible
// to std::function<void()>
//
//  bool Processor::canDispatch();
//      Should return true if we are in the Processor's dispatching function in
// the current thread.
//
template <typename Processor>
class Strand {
public:
    Strand(Processor& proc) : m_proc(proc) {}
 
    Strand(const Strand&) = delete;
    Strand& operator=(const Strand&) = delete;
 
    // Executes the handler immediately if all the strand guarantees are met,
    // or posts the handler for later execution if the guarantees are not met
    // from inside this call
    template <typename F>
    void dispatch(F handler) {
        // If we are not currently in the processor dispatching function (in
        // this thread), then we cannot possibly execute the handler here, so
        // enqueue it and bail out
        if (!m_proc.canDispatch()) {
            post(std::move(handler));
            return;
        }
 
        // NOTE: At this point we know we are in a worker thread (because of the
        // check above)
 
        // If we are running the strand in this thread, then we can execute the
        // handler immediately without any other checks, since by design no
        // other threads can be running the strand
        if (runningInThisThread()) {
            handler();
            return;
        }
 
        // At this point we know we are in a worker thread, but not running the
        // strand in this thread.
        // The strand can still be running in another worker thread, so we need
        // to atomically enqueue the handler for the other thread to execute OR
        // mark the strand as running in this thread
        auto trigger = m_data([&](Data& data) {
            if (data.running) {
                data.q.push(std::move(handler));
                return false;
            } else {
                data.running = true;
                return true;
            }
        });
 
        if (trigger) {
            // Add a marker to the callstack, so the handler knows the strand is
            // running in the current thread
            Callstack<Strand>::Context ctx(this);
            handler();
 
            // Run any remaining handlers.
            // At this point we own the strand (It's marked as running in
            // this thread), and we don't release it until the queue is empty.
            // This means any other threads adding handlers to the strand will
            // enqueue them, and they will be executed here.
            run();
        }
    }
 
    // Post an handler for execution and returns immediately.
    // The handler is never executed as part of this call.
    template <typename F>
    void post(F handler) {
        // We atomically enqueue the handler AND check if we need to start the
        // running process.
        bool trigger = m_data([&](Data& data) {
            data.q.push(std::move(handler));
            if (data.running) {
                return false;
            } else {
                data.running = true;
                return true;
            }
        });
 
        // The strand was not running, so trigger a run
        if (trigger) {
            m_proc.push([this] { run(); });
        }
    }
 
    // Checks if we are currently running the strand in this thread
    bool runningInThisThread() {
        return Callstack<Strand>::contains(this) != nullptr;
    }
 
private:
    // Processes any enqueued handlers.
    // This assumes the strand is marked as running.
    // When there are no more handlers, it marks the strand as not running.
    void run() {
        Callstack<Strand>::Context ctx(this);
        while (true) {
            std::function<void()> handler;
            m_data([&](Data& data) {
                assert(data.running);
                if (data.q.size()) {
                    handler = std::move(data.q.front());
                    data.q.pop();
                } else {
                    data.running = false;
                }
            });
 
            if (handler)
                handler();
            else
                return;
        }
    }
 
    struct Data {
        bool running = false;
        std::queue<std::function<void()>> q;
    };
    Monitor<Data> m_data;
    Processor& m_proc;
};

사용예

#include "Strand.h"
#include "WorkQueue.h"
#include <random>
#include <stdlib.h>
#include <string>
#include <atomic>
 
int randInRange(int min, int max) {
    std::random_device rd;
    std::mt19937 eng(rd());
    std::uniform_int_distribution<> distr(min, max);
    return distr(eng);
}
 
struct Obj {
    explicit Obj(int n, WorkQueue& wp) : strand(wp) {
        name = "Obj " + std::to_string(n);
    }
 
    void doSomething(int val) {
        printf("%s : doing %dn", name.c_str(), val);
    }
    std::string name;
    Strand<WorkQueue> strand;
};
 
void strandSample() {
    WorkQueue workQueue;
    // Start a couple of worker threads
    std::vector<std::thread> workerThreads;
    for (int i = 0; i < 4; i++) {
        workerThreads.push_back(std::thread([&workQueue] { workQueue.run(); }));
    }
 
    // Create a couple of objects that need strands
    std::vector<std::unique_ptr<Obj>> objs;
    for (int i = 0; i < 8; i++) {
        objs.push_back(std::make_unique<Obj>(i, workQueue));
    }
 
    // Counter used by all strands, so we can check if all work was done
    std::atomic<int> doneCount(0);
 
    // Add work to random objects
    const int todo = 20;
    for (int i = 0; i < todo; i++) {
        auto&& obj = objs[randInRange(0, objs.size() - 1)];
        obj->strand.post([&obj, i, &doneCount] {
            obj->doSomething(i);
            ++doneCount;
        });
    }
 
    workQueue.stop();
    for (auto&& t : workerThreads) {
        t.join();
    }
 
    assert(doneCount == todo);
}

결론

명시적 lock이 없어서 코드가 간결해지고, 버그 확률도 줄어든다.
blocking 이 적어진다.
Cache locality가 좋아진다.

참고 : https://www.gamedeveloper.com/programming/how-strands-work-and-why-you-should-use-them

부사 더 쓰기

성댕쓰 — Mon, 15 Aug 2022 11:57:34 +0900

definitely

It's definitely better.

It's definitely lighter.

That's definitely fake.

carefully

I read through the instructions very carefully many times.

I carefully asked him how old he was.

I carefully asked her if she was married.

thoroughly

do a thorough job

Wow they did a real thorough job.

He thoroughly went over every single detail during the meeting.

During the meeting, the boss went through every single detail.

noticeably

This is noticeably thinner and lighter than the last version.

Her condition got noticeably better over time.

My sister was in a car accident a few days ago.

It's nothing serious. No one got hurt.

But she's undertandably still quite shaken up by it.

She was arguably one of the best singers in the 1980's.

Parallel paring is arguably the hardest driving skill to master.

We're patiently / anxiously / eagerly wating for some good news.

definitely

1. It's definitely worse.

2. It's definitely heavier.

3. That's definitely true.

4. I think we can definitely go this time.

5. I would've definetly liked to have some options with source.

6. It could definitely been served with a bowl instead of a plate.

carefully

1. He read through the instrunctions about his car very carefully many times.

2. She carefully asked me how old I was.

3. He carefully prepared the presentation he was going to show

4. They should read this instruction very carefully.

5. People who read carefully read the warning can survied.

6. We had carefully our hair dry because if not, we could have snow on our sholders.

thoroughly

1. Wow He did a real thorough job.

2. Give him big applause for doing a real thorough job.

3. She thoroughly went over every single detail during the meeting.

4. During the meeting, he went through every single line very thoroughly.

5. we expect she is going to do a real thorough job.

6. I read thoughly the instructions as my cat is lying around all the day.

noticeably

1. This is going to be noticeably thinner and lighter than the last version.

2. Our relation ship is noticeably better than the last.

3. His condition got noticeably better over time.

4. The weather got noticeably better over time.

5. Almost all the things that was damaged by the heavy rain got noticeably better over time.

6. This is noticeably more silient than the last thing.

understandably

1. They was in a car accident a few days ago. It's nothing serious. No one got hurt.

But someone of them are understandably still quite shaken up by it.

2. Some accident come up a few months ago. No one got hurt.

But someone have only lived for a few months, so they are understandably still quite shaked up by it.

3. Sometimes, a false fire alarm rang in the middle of night. I am now quite accustomed it.

But at a first few times I am understandably quite shaked up by it.

4. I got a new car a few days ago. It's noticeably bigger than the last one.

I have only drived for 6 months, so I understandably am little hard to park it.

5. She had no experience about this job. So, she understandably missed a little detail.

6. They are going to be understandably shaken up by this roller coaster.

arguably

1. They are arguably one of the best football players in this time.

2. Parallel parking was arguably the hardest driving skill to master before an auto paking came out.

3. A caffe is not arguably good place to study.

4. Listening a classic music is arguably good for a baby.

5. A coffee is arguably good for health.

6. The wine is arguably one of the best among the same level line up.

patiently / anxiously / eargerly

1. I am eargerly wating for being promoted this year.

2. She is patiently wating for her hersband.

3. They are going to be anxiously ready for the news.

4. We got anxiously our car fixed.

5. He was patiently wating for the enemy even though there were many noisy arguments

6. We eagerly wanted the team could participate in the world cup.

참고 : 부사를 더 써야 합니다 - YouTube

Although, I would've liked, I feel like + could've

성댕쓰 — Mon, 15 Aug 2022 10:12:38 +0900

It's okay / It's all right.

Although, it's a little slow-paced for me.

Plus, it's all text and I really would've liked to see visual aids here and there.

And, I feel like it could've been written in plainer language.

I'm finding some parts very difficult to understand.

It was good.

Although, it was a little too bland for me.

Plus, I would've liked to have some options with the sauce.

And I feel like it could've been served in a bowl instead of a plate.

I thinkg it would've been easier to eat.

It went well / okay / all right.

Although, it was a little awkward for me when I was signing the contract.

I really would've liked to have a day or two to review it more thoroughly.

And I feel like the meating could've been held a little earlier in the day.

1. It's okay. Althogh, it's a little slow-paced for me.

Plus, the dialogue sound is hard to listen because the background sound is higher than this.

I really would've liked to see some subtitles when the war scene was playing.

And, I feel like it could been written in plainer korean. I found some parts very difficult to understand.

2. It was good. Although, it was a little too blend for me.

Plus, I would've liked to have some options with the soup.

And, I feel like it could've been served with a spoon instead of just a folk.

I think it would've been easier to pick the food.

3. It went well. Although it was a little awkward for me when I was explaining the contract.

I really would've liked to have a one or two day to review it more thoroughly.

Plus, I think the next meeting could have scheduled a little earlier than the day we talked.

4. I think it is going to be well.

Although there is a concern about we don't expect.

Plus, I would have liked to have a day or two day to prepare thoroughly.

We could have expected more perfect result if we had extra days.

5. It is good. Although it is a little too bland for me.

I really would liked it has a slightly stronger flavor than this.

And I feel like it could have been some sparklings in the one.

It could be more popular than now.

6. It was good. Although there was a enormous traffic jam in the morning.

I could have been late in the office.

I would have liked to be reported about a current traffic environment.

If it is expected to be a traffic jam, I could choose other transport platforms.

참고 : 영어 말하기 연습 가이드 "좋았지만 (이런저런 것)이 아쉬웠어." - YouTube

Having met, having lived, having been

성댕쓰 — Sun, 7 Aug 2022 11:47:09 +0900

I moved to my current place in October last year.

I had a lot of initial concerns back then because, well you know, there are certain things about a place you just can't know for sure until you actually start living there, like neighbors.

But now having lived there for almost 6 months, I can pretty confidently say that i'm very satisfied with the place.

I started teaching English straight out of a school in 2008 and haven't stopped ever since.

So, I have been doing this for a fairly long time.

Having met hudres if not thousand of students throughout my career, I feel like I have a pretty good understanding of what the students need, what their weekness are and therefore what i need to do for them.

===========================

I moved to my current place in October last year

1. I moved to my current place after I have married.

2. I'm going to move to next to my current place late this year.

3. She moved to my current place in October because we have married.

4. They are going to move their place two years later.

5. I have no money as I moved my home just before.

6. As long as it's not an emergency, we are going to move our place.

I had a lot of inital concerns back then because, well you know, there are certain things about a place you just can't konw for sure until you actually start living there, like neighbors.

1. It could be that she had a lot of initial concerns back then because, well you know, there are certain things about a place you just can't know for sure until you actually start living there, like neighbors.

2. I had a lot of concerns back then because, well you know, there are certain things about a company you just can't know for sure until you actuall start working for it, like team members.

3. She has a lot of concerns about the presentation she is goint to do. because she worrys about how the audience think the presentation is.

4. They had a lot of concerns back then, well you know there are certain thins about a team work you just don't know for sure until you actaully start doing team work.

5. We are going to have a few concerns slight moments layer well you know there are certain things about a task we have to do.

6. We had a lot of concerns back then well you know, there are certain things about a economy.

But now having lived there for almost 6 months, I can pretty confidently say that I'm very satisfied with the place.

1. Having lived my home for almost 6 months, I can pretty confidently say that Im very satisfied with the place.

2. Having wored for my company for almost half a year, I can pretty confidently say that I'm satisfied with my company.

3. Having lived with for almost 6 months, I can pretty confidently say that I'm satified with my life with my wife.

4. Having used the laptop almost 1 year, I can pretty confidently say that I'm satisfied with this one.

5. Having had a lot of concerns back then, I think it is little useless.

6. Having finished the task, I don't know why I made so many mistakes.

I started teaching English straight out of a school in 2008 and haven't stopped ever since.

1. I started working straight out of a school in 2016 and haven't stopped ever since.

2. I started leaning the computer science straight out of a school in 2016 and haven't stopped ever since.

3. She started preparing a dinner right after she got to a home and hasn't stopped ever since.

4. He is going to start speaking to us straing out of the meeting and is not gonna stop it.

5. I could have started studying straing out of a office but instead I had watched videos on the Youtube.

6. I started running right after I got to the home and haven't stopped ever since.

So, I have been doing this for a fairly long time.

1. So, I have been software engineer for a fairly long time.

2. So, you are going to doing this for a fairly long time.

3. So, She has been doing this for a farily long time.

4. So, They have been living together for a fairly long time.

5. So, this has been happening for a fairly long time.

6. So, I have been thinking for a fairly long time.

Having met hundreds if not thousand of students throught my carrer, I feel like I have a pretty good understanding of what the students need, what their weekness are and therefore what I need to do for them.

1. Having done this hudreds times if not thousand times throught all a week, I feel like I have a pretty good understanding of what this is, what this needs and therefore what i need to do for this.

2. Having taken dozens if not hundred of pictures throught all day, I feel like I have pretty good understanding how to take a picture, what i need to do for a good picture and therefore how nicely I provide the service.

3. Having written tens if not dozen of sentences throught the study time, I feel like I have pretty good understaing how to express, what words is needed and therefore what I need to speak better sentences.

4. Having cleaned tens if not dozens throught the time we have lived together I feel like I have pretty good understaing how nicely to clean, what she is satisfied with and therefore what I need to do for my wife and my home.

5. Having had times together hudreds if not thousand of days throught days we have lived together, I feel like I have pretty good understaing of what she likes dislikes and therefore what I need to do for making her happy.

6. Having drunken tens if not hudred of wines you know I feel like i have pretty good understanding of what the good wine is, what are good foods having together with.

참조 : (3) having met, having lived, having been 특이하지만 자주 쓰이는 분사구문 - YouTube