HappyTanuki/NP_Midterm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

일단 거의 모든 버그 다 고칢..

Browse Source
This commit is contained in:
HappyTanuki
2025-05-02 11:16:25 +09:00
parent 6622cc8939
commit 14c325c428
10 changed files with 212 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
impl/Socket/IOCP.cpp
View File

@@ -1,24 +1,15 @@
#include "Socket/IOCP.hpp"
#include "Socket/WSAManager.hpp"
#include "Socket/Log.hpp"
#include "Utils/ThreadPool.hpp"
#include "precomp.hpp"
namespace Chattr {
IOCP::IOCP(std::shared_ptr<ThreadPool> __IOCPThread) {
init(__IOCPThread);
}
IOCP::~IOCP() {
}
void IOCP::init(std::shared_ptr<ThreadPool> __IOCPThread) {
IOCPThread_ = __IOCPThread;
void IOCP::registerSocket(SOCKET sock) {
#ifdef _WIN32
struct Chattr::WSAManager wsaManager;
completinPort_ = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if (completinPort_ == NULL)
log::critical("CreateIoCompletionPort()");
HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock, completionPort_, sock, 0);
if (returnData == 0)
completionPort_ = returnData;
#elif __linux__
#endif

26
impl/Socket/Socket.cpp
View File

@@ -15,8 +15,8 @@ Socket::~Socket() {
int Socket::init(int domain, int type, int protocol) {
this->domain = domain;
sock_ = ::socket(domain, type, protocol);
if (sock_ == INVALID_SOCKET)
sock = ::socket(domain, type, protocol);
if (sock == INVALID_SOCKET)
log::critical("socket()");
valid_ = true;
@@ -28,9 +28,9 @@ void Socket::destruct() {
if (!valid_)
return;
#ifdef _WIN32
::closesocket(sock_);
::closesocket(sock);
#elif __linux__
::close(sock_);
::close(sock);
#endif
valid_ = false;
}
@@ -38,7 +38,7 @@ void Socket::destruct() {
Socket::operator SOCKET() {
if (valid_) {
valid_ = false;
return sock_;
return sock;
}
spdlog::critical("No valid socket created.");
return INVALID_SOCKET;
@@ -50,41 +50,41 @@ void Socket::set(const SOCKET __sock, int __domain) {
destruct();
sock_ = __sock;
sock = __sock;
valid_ = true;
};
int Socket::bind(Address __addr) {
bindAddr = __addr;
int retVal = ::bind(sock_, &__addr.addr, __addr.length);
int retVal = ::bind(sock, &__addr.addr, __addr.length);
if (retVal == INVALID_SOCKET)
log::critical("bind()");
return retVal;
}
int Socket::recvfrom(void *__restrict __buf, size_t __n, int __flags, struct Address& __addr) {
int retVal = ::recvfrom(sock_, (char*)__buf, __n, __flags, &__addr.addr, &__addr.length);
int retVal = ::recvfrom(sock, (char*)__buf, __n, __flags, &__addr.addr, &__addr.length);
if (retVal == SOCKET_ERROR)
log::error("recvfrom()");
return retVal;
}
int Socket::sendto(const void *__buf, size_t __n, int __flags, struct Address __addr) {
int retVal = ::sendto(sock_, (char*)__buf, __n, __flags, &__addr.addr, __addr.length);
int retVal = ::sendto(sock, (char*)__buf, __n, __flags, &__addr.addr, __addr.length);
if (retVal == SOCKET_ERROR)
log::error("sendto()");
return retVal;
}
Socket::Socket(Socket &&other_) {
Socket::Socket(Socket &&other_) noexcept {
other_.valid_ = false;
sock_ = other_.sock_;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
}
Socket& Socket::operator=(Socket && other_) {
Socket& Socket::operator=(Socket && other_) noexcept {
other_.valid_ = false;
sock_ = other_.sock_;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
return *this;

15
impl/Socket/TCPSocket.cpp
View File

@@ -9,35 +9,36 @@ int TCPSocket::init(int domain) {
}
int TCPSocket::listen(int __n) {
int retVal = ::listen(sock_, __n);
int retVal = ::listen(sock, __n);
if (retVal == INVALID_SOCKET)
log::error("listen()");
return retVal;
}
void TCPSocket::accept(TCPSocket& newSock, Address& __addr) {
newSock.set(::accept(sock_, &__addr.addr, &__addr.length), domain);
if (newSock == INVALID_SOCKET)
newSock.set(::accept(sock, &__addr.addr, &__addr.length), domain);
memcpy(&newSock.remoteAddr, &__addr, sizeof(Chattr::Address));
if (newSock.sock == INVALID_SOCKET)
log::error("accept()");
}
int TCPSocket::connect(Address& serveraddr) {
int retVal = ::connect(sock_, (struct sockaddr *)&serveraddr.addr, serveraddr.length);
remoteAddr = serveraddr;
int retVal = ::connect(sock, (struct sockaddr *)&serveraddr.addr, serveraddr.length);
memcpy(&remoteAddr, &serveraddr, sizeof(Chattr::Address));
if (retVal == INVALID_SOCKET)
log::error("connect()");
return retVal;
}
int TCPSocket::recv(void *__restrict __buf, size_t __n, int __flags) {
int retVal = ::recv(sock_, (char *)__buf, __n, __flags);
int retVal = ::recv(sock, (char *)__buf, __n, __flags);
if (retVal == SOCKET_ERROR)
log::error("recv()");
return retVal;
}
int TCPSocket::send(const void *__buf, size_t __n, int __flags) {
int retVal = ::send(sock_, (char*)__buf, __n, __flags);
int retVal = ::send(sock, (char*)__buf, __n, __flags);
if (retVal == SOCKET_ERROR)
log::error("send()");
return retVal;

39
impl/Utils/ThreadPool.cpp
View File

@@ -11,11 +11,7 @@ ThreadPool::ThreadPool(std::uint32_t numThreads) {
}
ThreadPool::~ThreadPool() {
terminate_ = true;
jobQueueCV_.notify_all();
for (auto& t : workers_)
t.join();
terminate();
}
void ThreadPool::init(std::uint32_t numThreads) {
@@ -29,12 +25,36 @@ void ThreadPool::init(std::uint32_t numThreads) {
numCPU = sysconf(_SC_NPROCESSORS_ONLN);
#endif
spdlog::info("Auto-detected cpu count: {}", numCPU);
spdlog::info("Set ThreadPool Worker count to: {}", numCPU);
if (numCPU == 1 || numCPU == 2) {
numCPU = 4;
spdlog::info("Set ThreadPool Worker count to: {} due to program to oprate concurrently", numCPU);
}
else {
spdlog::info("Set ThreadPool Worker count to: {}", numCPU);
}
}
threadCount = numCPU;
workers_.reserve(numCPU);
while (numCPU--)
workers_.push_back([this]() { this->Worker(); });
workers_.push_back([this]() {
this->Worker();
});
}
void ThreadPool::terminate() {
terminate_ = true;
jobQueueCV_.notify_all();
spdlog::debug("waiting for threads to end their jobs...");
for (auto& t : workers_)
t.join();
}
void ThreadPool::respawnWorker(std::uint32_t numThreads) {
terminate();
terminate_ = false;
init(numThreads);
}
void* ThreadPool::Worker() {
@@ -43,18 +63,17 @@ void* ThreadPool::Worker() {
#elif __linux__
pthread_t pid = pthread_self();
#endif
spdlog::info("ThreadPool Worker : {} up.", pid);
while (!terminate_) {
std::unique_lock<std::mutex> lock(jobQueueMutex);
jobQueueCV_.wait(lock, [this]() { return !this->jobs_.empty() || terminate_; });
if (this->jobs_.empty())
return nullptr;
break;
auto job = std::move(jobs_.front());
jobs_.pop();
lock.unlock();
spdlog::info("ThreadPool Worker : {} Executing a job", pid);
spdlog::debug("ThreadPool Worker : {} Executing a job", pid);
job();
}