OnceAI오래된 문제를 다시 적는 곳

게시판바둑 on-policy 학습: 대국 로그를 KataGo 라벨로 바꾸기예제 소스

예제 소스

바둑 on-policy 학습: 대국 로그를 KataGo 라벨로 바꾸기 · 파일 169개

tcpboardechoclient.cpp

#include "tcpboardechoclient.h"

#include <QAbstractSocket>
#include <QBuffer>
#include <QDataStream>
#include <QDebug>
#include <QElapsedTimer>
#include <QEventLoop>
#include <QTcpSocket>
#include <QTimer>

namespace TcpBoardEchoClient {

namespace {

void packU32BE(QByteArray *out, quint32 v)
{
    out->append(char((v >> 24) & 0xff));
    out->append(char((v >> 16) & 0xff));
    out->append(char((v >> 8) & 0xff));
    out->append(char(v & 0xff));
}

inline bool isValidBoardSize(int sz) { return sz == 19; }

} // namespace

Worker::Worker(QObject *parent)
    : QObject(parent)
{
}

Worker::~Worker()
{
    closeSocketLocked(QStringLiteral("worker destroyed"));
}

bool Worker::isBusy() const { return m_busy.loadAcquire() != 0; }

void Worker::closeSocketLocked(const QString &reason)
{
    Q_UNUSED(reason);
    if (m_socket) {
        m_socket->abort();
        m_socket->deleteLater();
        m_socket = nullptr;
    }
    m_curHost.clear();
    m_curPort = 0;
}

void Worker::cancel() { m_cancel.storeRelease(1); }

void Worker::shutdownForAppExit()
{
    m_cancel.storeRelease(1);
    closeSocketLocked(QStringLiteral("app exit"));
    m_busy.storeRelease(0);
}

bool Worker::ensureConnected(const QString &host, quint16 port, int timeoutMs, QString *errorOut)
{
    if (errorOut)
        errorOut->clear();
    if (m_socket && m_socket->state() == QAbstractSocket::ConnectedState && m_curHost == host
        && m_curPort == port) {
        return true;
    }
    if (m_socket)
        closeSocketLocked(QStringLiteral("reconnect"));

    m_socket = new QTcpSocket();
    m_socket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
    m_socket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
    m_socket->connectToHost(host, port);
    const int connTo = qBound(500, timeoutMs, 15000);
    if (!m_socket->waitForConnected(connTo)) {
        if (errorOut)
            *errorOut = QStringLiteral("TCP 연결 실패: %1").arg(m_socket->errorString());
        closeSocketLocked(QStringLiteral("connect fail"));
        return false;
    }
    m_curHost = host;
    m_curPort = port;
    return true;
}

bool Worker::writeAll(const QByteArray &data, int timeoutMs)
{
    if (!m_socket || m_socket->state() != QAbstractSocket::ConnectedState)
        return false;
    m_socket->write(data);
    while (m_socket->bytesToWrite() > 0) {
        if (m_cancel.loadAcquire() != 0)
            return false;
        if (!m_socket->waitForBytesWritten(qMax(200, timeoutMs)))
            return false;
    }
    return true;
}

bool Worker::readBytes(QByteArray *dst, qint64 nbytes, int deadlineMs)
{
    dst->clear();
    if (!m_socket)
        return false;
    QElapsedTimer deadline;
    deadline.start();
    while (dst->size() < nbytes) {
        if (m_cancel.loadAcquire() != 0)
            return false;
        if (m_socket->bytesAvailable() > 0) {
            QByteArray chunk = m_socket->read(nbytes - dst->size());
            if (!chunk.isEmpty())
                dst->append(chunk);
            if (dst->size() >= nbytes)
                return true;
            continue;
        }
        if (m_socket->state() != QAbstractSocket::ConnectedState)
            return false;
        const qint64 elapsed = deadline.elapsed();
        if (elapsed >= deadlineMs)
            return false;
        const qint64 remaining = deadlineMs - elapsed;

        QEventLoop loop;
        const auto cReady = QObject::connect(m_socket, &QTcpSocket::readyRead, &loop,
                                             &QEventLoop::quit);
        const auto cDisc = QObject::connect(m_socket, &QTcpSocket::disconnected, &loop,
                                            &QEventLoop::quit);
        const auto cErr = QObject::connect(
            m_socket,
            QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::errorOccurred), &loop,
            [&loop](QAbstractSocket::SocketError) { loop.quit(); });
        QTimer poll;
        poll.setSingleShot(true);
        const int slice = int(std::min<qint64>(remaining, 200));
        poll.start(qMax(50, slice));
        QObject::connect(&poll, &QTimer::timeout, &loop, &QEventLoop::quit);
        loop.exec();
        QObject::disconnect(cReady);
        QObject::disconnect(cDisc);
        QObject::disconnect(cErr);
    }
    return true;
}

void Worker::doPing(QString host, quint16 port, int timeoutMs)
{
    m_cancel.storeRelease(0);
    QString err;
    if (!ensureConnected(host, port, timeoutMs, &err)) {
        emit pingReady(false, err);
        return;
    }
    if (!writeAll(QByteArrayLiteral("PING"), timeoutMs)) {
        const QString e = m_socket ? m_socket->errorString() : QStringLiteral("PING 송신 실패");
        closeSocketLocked(QStringLiteral("ping write fail"));
        emit pingReady(false, e);
        return;
    }
    QByteArray pong;
    if (!readBytes(&pong, 4, timeoutMs) || pong != QByteArrayLiteral("PONG")) {
        closeSocketLocked(QStringLiteral("pong recv fail"));
        emit pingReady(false, QStringLiteral("PONG 응답 없음/불일치"));
        return;
    }
    emit pingReady(true, QString());
}

void Worker::requestBoardEcho(QImage boardImage, QByteArray boardPacked, int boardSize,
                              QString host, quint16 port, int timeoutMs)
{
    m_cancel.storeRelease(0);
    m_busy.storeRelease(1);

    auto fail = [&](const QString &msg) {
        m_busy.storeRelease(0);
        emit echoReady(false, msg);
    };

    if (!isValidBoardSize(boardSize)) {
        fail(QStringLiteral("지원하지 않는 보드 크기: %1 (19만 지원)").arg(boardSize));
        return;
    }
    const int expected = boardSize * boardSize;
    if (boardPacked.size() != expected) {
        fail(QStringLiteral("판 직렬화 크기 오류 (%1, 기대 %2)")
                 .arg(boardPacked.size())
                 .arg(expected));
        return;
    }

    QByteArray png;
    {
        QBuffer buf(&png);
        buf.open(QIODevice::WriteOnly);
        if (!boardImage.save(&buf, "PNG")) {
            fail(QStringLiteral("판 PNG 인코딩 실패"));
            return;
        }
    }

    QByteArray body;
    body.append(char(static_cast<unsigned char>(boardSize)));
    body.append(char(0)); // reserved
    packU32BE(&body, quint32(png.size()));
    body.append(png);
    body.append(boardPacked);

    QByteArray frame;
    frame.append("BRD1", 4);
    packU32BE(&frame, quint32(body.size()));
    frame.append(body);

    QString err;
    bool ok = false;
    for (int attempt = 0; attempt < 2 && !ok; ++attempt) {
        if (m_cancel.loadAcquire() != 0) {
            fail(QStringLiteral("사용자 취소"));
            return;
        }
        if (!ensureConnected(host, port, qMin(15000, qMax(2000, timeoutMs / 8)), &err)) {
            if (attempt == 1) {
                fail(err);
                return;
            }
            continue;
        }
        if (!writeAll(frame, qMin(60000, qMax(5000, timeoutMs / 4)))) {
            err = m_socket ? m_socket->errorString() : QStringLiteral("송신 실패");
            closeSocketLocked(QStringLiteral("write fail"));
            continue;
        }
        ok = true;
    }
    if (!ok) {
        fail(err);
        return;
    }

    QByteArray head;
    if (!readBytes(&head, 4, timeoutMs)) {
        const bool canceled = m_cancel.loadAcquire() != 0;
        closeSocketLocked(QStringLiteral("rtxt head fail"));
        fail(canceled ? QStringLiteral("사용자 취소")
                      : QStringLiteral("응답 헤더 수신 실패 (추론 시간 초과 가능)"));
        return;
    }
    if (head != QByteArrayLiteral("RTXT")) {
        closeSocketLocked(QStringLiteral("bad head"));
        fail(QStringLiteral("잘못된 응답 헤더 (RTXT 기대)"));
        return;
    }
    QByteArray flag;
    if (!readBytes(&flag, 1, timeoutMs)) {
        closeSocketLocked(QStringLiteral("flag fail"));
        fail(QStringLiteral("응답 플래그 수신 실패"));
        return;
    }
    const unsigned char f = static_cast<unsigned char>(flag.at(0));
    if (f == 1U) {
        QByteArray lenRaw;
        if (!readBytes(&lenRaw, 4, timeoutMs)) {
            closeSocketLocked(QStringLiteral("len fail"));
            fail(QStringLiteral("텍스트 길이 수신 실패"));
            return;
        }
        QBuffer blen(&lenRaw);
        blen.open(QIODevice::ReadOnly);
        QDataStream dlen(&blen);
        dlen.setByteOrder(QDataStream::BigEndian);
        quint32 tlen = 0;
        dlen >> tlen;
        if (tlen > 32U * 1024U * 1024U) {
            closeSocketLocked(QStringLiteral("text too long"));
            fail(QStringLiteral("응답 텍스트 길이 비정상"));
            return;
        }
        QByteArray text;
        if (!readBytes(&text, qint64(tlen), timeoutMs)) {
            closeSocketLocked(QStringLiteral("text body fail"));
            fail(QStringLiteral("텍스트 본문 수신 실패"));
            return;
        }
        m_busy.storeRelease(0);
        emit echoReady(true, QString::fromUtf8(text));
        return;
    }

    QByteArray lenRaw;
    if (!readBytes(&lenRaw, 2, timeoutMs)) {
        closeSocketLocked(QStringLiteral("err len fail"));
        fail(QStringLiteral("에러 길이 수신 실패"));
        return;
    }
    QBuffer blen(&lenRaw);
    blen.open(QIODevice::ReadOnly);
    QDataStream dlen(&blen);
    dlen.setByteOrder(QDataStream::BigEndian);
    quint16 elen = 0;
    dlen >> elen;
    QByteArray emsg;
    if (!readBytes(&emsg, elen, timeoutMs)) {
        closeSocketLocked(QStringLiteral("err body fail"));
        fail(QStringLiteral("에러 본문 수신 실패"));
        return;
    }
    fail(QString::fromUtf8(emsg));
}

} // namespace TcpBoardEchoClient