C++에서 MessagePack을 활용한 직렬화 성능 최적화

{
  "name": "Alice",
  "age": 25,
  "languages": ["C++", "Python"]
}

// MessagePack을 사용하여 위 JSON 데이터를 직렬화하면
\x83\xa4name\xa5Alice\xa3age\x19\xa8languages\x92\xa3C++\xa6Python

vcpkg install msgpack-c

find_package(msgpack CONFIG REQUIRED)
target_link_libraries(my_project PRIVATE msgpack-c)

conan install msgpack/4.0.0@

[requires]
msgpack/4.0.0

git clone https://github.com/msgpack/msgpack-c.git

cmake_minimum_required(VERSION 3.10)
project(MyProject)

# MessagePack 경로 추가
include_directories(/path/to/msgpack/include)

add_executable(my_project main.cpp)

#include <iostream>
#include <msgpack.hpp>

int main() {
    std::string data = "Hello, MessagePack!";

    // 직렬화
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, data);

    std::cout << "Serialized Data Size: " << buffer.size() << " bytes" << std::endl;

    return 0;
}

Serialized Data Size: 20 bytes

#include <iostream>
#include <msgpack.hpp>

int main() {
    std::string data = "Hello, MessagePack!";

    // 직렬화
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, data);

    // 역직렬화
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    std::string result;
    obj.convert(result);

    std::cout << "Deserialized Data: " << result << std::endl;
    return 0;
}

Deserialized Data: Hello, MessagePack!

#include <iostream>
#include <msgpack.hpp>

int main() {
    // 직렬화할 데이터
    std::string data = "Hello, MessagePack!";

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, data);

    std::cout << "Serialized Data Size: " << buffer.size() << " bytes" << std::endl;

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    std::string result;
    obj.convert(result);

    std::cout << "Deserialized Data: " << result << std::endl;
    return 0;
}

Serialized Data Size: 20 bytes
Deserialized Data: Hello, MessagePack!

#include <iostream>
#include <msgpack.hpp>

// 사용자 정의 구조체
struct Person {
    std::string name;
    int age;

    MSGPACK_DEFINE(name, age);  // MessagePack 직렬화 지원
};

int main() {
    // Person 객체 생성
    Person p1 = {"Alice", 30};

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, p1);

    std::cout << "Serialized Data Size: " << buffer.size() << " bytes" << std::endl;

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    Person p2;
    obj.convert(p2);

    std::cout << "Deserialized Person: " << p2.name << ", " << p2.age << " years old" << std::endl;
    return 0;
}

Serialized Data Size: 10 bytes
Deserialized Person: Alice, 30 years old

#include <iostream>
#include <vector>
#include <msgpack.hpp>

int main() {
    // 벡터 데이터 생성
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, numbers);

    std::cout << "Serialized Data Size: " << buffer.size() << " bytes" << std::endl;

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    std::vector<int> result;
    obj.convert(result);

    std::cout << "Deserialized Vector: ";
    for (int num : result) std::cout << num << " ";
    std::cout << std::endl;

    return 0;
}

Serialized Data Size: 8 bytes
Deserialized Vector: 1 2 3 4 5

#include <iostream>
#include <fstream>
#include <msgpack.hpp>

int main() {
    std::string data = "Hello, File Storage!";

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, data);

    // 파일 저장
    std::ofstream file("data.msgpack", std::ios::binary);
    file.write(buffer.data(), buffer.size());
    file.close();

    std::cout << "Data saved to file!" << std::endl;

    // 파일 읽기
    std::ifstream infile("data.msgpack", std::ios::binary);
    std::string serialized((std::istreambuf_iterator<char>(infile)), std::istreambuf_iterator<char>());
    infile.close();

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(serialized.data(), serialized.size());
    msgpack::object obj = oh.get();

    std::string result;
    obj.convert(result);

    std::cout << "Deserialized from file: " << result << std::endl;
    return 0;
}

Data saved to file!
Deserialized from file: Hello, File Storage!

msgpack::sbuffer buffer;
msgpack::pack(buffer, data);

#include <msgpack.hpp>

int main() {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> packer(buffer);

    // 데이터를 개별적으로 추가 (불필요한 복사 최소화)
    packer.pack(std::string("Hello"));
    packer.pack(42);
    packer.pack(std::vector<int>{1, 2, 3, 4, 5});
}

#include <iostream>
#include <msgpack.hpp>

int main() {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> packer(buffer);

    // 여러 개의 데이터를 한 번에 직렬화
    packer.pack(100);
    packer.pack(std::string("Hello, World"));
    packer.pack(std::vector<int>{10, 20, 30});

    msgpack::unpacker unpacker;
    unpacker.reserve_buffer(buffer.size());
    memcpy(unpacker.buffer(), buffer.data(), buffer.size());
    unpacker.buffer_consumed(buffer.size());

    msgpack::object_handle oh;
    while (unpacker.next(oh)) {
        msgpack::object obj = oh.get();
        std::cout << "Unpacked Object: " << obj << std::endl;
    }

    return 0;
}

Unpacked Object: 100
Unpacked Object: "Hello, World"
Unpacked Object: [10, 20, 30]

msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
msgpack::object obj = oh.get();

#include <msgpack.hpp>

int main() {
    msgpack::vrefbuffer buffer;
    msgpack::packer<msgpack::vrefbuffer> packer(buffer);

    packer.pack(std::string("Efficient Binary Data"));
    packer.pack(123456);

    std::cout << "Serialized data size: " << buffer.size() << " bytes" << std::endl;

    return 0;
}

#include <iostream>
#include <thread>
#include <msgpack.hpp>

void serialize_data(int thread_id) {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> packer(buffer);

    packer.pack(std::string("Thread Data: " + std::to_string(thread_id)));

    std::cout << "Thread " << thread_id << " Serialized Data Size: " << buffer.size() << " bytes" << std::endl;
}

int main() {
    std::thread t1(serialize_data, 1);
    std::thread t2(serialize_data, 2);

    t1.join();
    t2.join();

    return 0;
}

#include <iostream>
#include <vector>
#include <msgpack.hpp>

int main() {
    // 직렬화할 벡터 데이터
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, numbers);

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    // 역직렬화된 데이터 변환
    std::vector<int> result;
    obj.convert(result);

    std::cout << "Deserialized Vector: ";
    for (int num : result) std::cout << num << " ";
    std::cout << std::endl;

    return 0;
}

Deserialized Vector: 1 2 3 4 5

#include <iostream>
#include <map>
#include <msgpack.hpp>

int main() {
    // 직렬화할 맵 데이터
    std::map<std::string, int> scores = {{"Alice", 90}, {"Bob", 85}, {"Charlie", 92}};

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, scores);

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    // 역직렬화된 데이터 변환
    std::map<std::string, int> result;
    obj.convert(result);

    std::cout << "Deserialized Map: \n";
    for (const auto& [key, value] : result) {
        std::cout << key << ": " << value << std::endl;
    }

    return 0;
}

Deserialized Map:
Alice: 90
Bob: 85
Charlie: 92

#include <iostream>
#include <unordered_map>
#include <msgpack.hpp>

int main() {
    // 직렬화할 해시맵 데이터
    std::unordered_map<std::string, double> prices = {{"Apple", 1.2}, {"Banana", 0.8}, {"Cherry", 2.5}};

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, prices);

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    // 역직렬화된 데이터 변환
    std::unordered_map<std::string, double> result;
    obj.convert(result);

    std::cout << "Deserialized Unordered Map: \n";
    for (const auto& [key, value] : result) {
        std::cout << key << ": " << value << std::endl;
    }

    return 0;
}

Deserialized Unordered Map:
Apple: 1.2
Banana: 0.8
Cherry: 2.5

#include <iostream>
#include <vector>
#include <msgpack.hpp>

// 사용자 정의 구조체
struct Student {
    std::string name;
    std::vector<int> scores;

    MSGPACK_DEFINE(name, scores);  // MessagePack 직렬화 지원
};

int main() {
    // 구조체 객체 생성
    Student student = {"Alice", {90, 85, 88}};

    // 직렬화 수행
    msgpack::sbuffer buffer;
    msgpack::pack(buffer, student);

    // 역직렬화 수행
    msgpack::object_handle oh = msgpack::unpack(buffer.data(), buffer.size());
    msgpack::object obj = oh.get();

    // 데이터 변환
    Student result;
    obj.convert(result);

    std::cout << "Deserialized Student: " << result.name << " Scores: ";
    for (int score : result.scores) std::cout << score << " ";
    std::cout << std::endl;

    return 0;
}

Deserialized Student: Alice Scores: 90 85 88

#include <iostream>
#include <boost/asio.hpp>
#include <msgpack.hpp>

using namespace boost::asio;
using ip::tcp;

int main() {
    try {
        io_service io;
        tcp::acceptor acceptor(io, tcp::endpoint(tcp::v4(), 8080));

        std::cout << "Server is running on port 8080..." << std::endl;

        tcp::socket socket(io);
        acceptor.accept(socket);

        // 송신할 데이터
        std::map<std::string, int> scores = {{"Alice", 90}, {"Bob", 85}, {"Charlie", 92}};

        // MessagePack 직렬화
        msgpack::sbuffer buffer;
        msgpack::pack(buffer, scores);

        // 데이터 전송
        boost::asio::write(socket, boost::asio::buffer(buffer.data(), buffer.size()));

        std::cout << "Sent MessagePack data to client." << std::endl;
    } catch (std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

#include <iostream>
#include <boost/asio.hpp>
#include <msgpack.hpp>

using namespace boost::asio;
using ip::tcp;

int main() {
    try {
        io_service io;
        tcp::socket socket(io);
        socket.connect(tcp::endpoint(ip::address::from_string("127.0.0.1"), 8080));

        // 데이터 수신 버퍼
        std::vector<char> buffer(1024);
        size_t len = socket.read_some(boost::asio::buffer(buffer));

        // MessagePack 역직렬화
        msgpack::object_handle oh = msgpack::unpack(buffer.data(), len);
        msgpack::object obj = oh.get();

        // 변환된 데이터 저장
        std::map<std::string, int> scores;
        obj.convert(scores);

        // 출력
        std::cout << "Received Scores: " << std::endl;
        for (const auto& [key, value] : scores) {
            std::cout << key << ": " << value << std::endl;
        }
    } catch (std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

Received Scores:
Alice: 90
Bob: 85
Charlie: 92

#include <iostream>
#include <uwebsockets/App.h>
#include <msgpack.hpp>

int main() {
    uWS::App().ws<"/*">([](auto *ws, auto *msg, size_t length, auto opCode) {
        // MessagePack 역직렬화
        msgpack::object_handle oh = msgpack::unpack(msg->data(), length);
        msgpack::object obj = oh.get();

        std::map<std::string, int> data;
        obj.convert(data);

        std::cout << "Received Data via WebSocket: " << std::endl;
        for (const auto& [key, value] : data) {
            std::cout << key << ": " << value << std::endl;
        }
    }).listen(9001, [](auto *token) {
        if (token) std::cout << "WebSocket Server started on port 9001" << std::endl;
    }).run();

    return 0;
}

#include <iostream>
#include <msgpack.hpp>

int main() {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> packer(buffer);

    // 데이터 한 번에 직렬화 (메모리 복사 최소화)
    packer.pack(std::string("Optimized MessagePack"));
    packer.pack(42);
    packer.pack(std::vector<int>{1, 2, 3, 4, 5});

    std::cout << "Optimized Serialization Completed." << std::endl;

    return 0;
}

#include <iostream>
#include <msgpack.hpp>

int main() {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> packer(buffer);

    // 여러 개의 데이터를 직렬화
    for (int i = 0; i < 1000; i++) {
        packer.pack(i);
    }

    msgpack::unpacker unpacker;
    unpacker.reserve_buffer(buffer.size());
    memcpy(unpacker.buffer(), buffer.data(), buffer.size());
    unpacker.buffer_consumed(buffer.size());

    msgpack::object_handle oh;
    while (unpacker.next(oh)) {
        int num;
        oh.get().convert(num);
        std::cout << "Unpacked: " << num << std::endl;
    }

    return 0;
}

#include <iostream>
#include <msgpack.hpp>

int main() {
    msgpack::vrefbuffer buffer;
    msgpack::packer<msgpack::vrefbuffer> packer(buffer);

    // 바이너리 데이터 저장
    std::string binary_data(1024, 'A');  // 1KB 크기의 'A'로 채워진 데이터
    packer.pack(binary_data);

    std::cout << "Optimized Binary Serialization Completed." << std::endl;
    return 0;
}

#include <iostream>
#include <thread>
#include <msgpack.hpp>

void serialize_data(int thread_id) {
    msgpack::sbuffer buffer;
    msgpack::packer<msgpack::sbuffer> packer(buffer);

    packer.pack("Thread Data: " + std::to_string(thread_id));

    std::cout << "Thread " << thread_id << " Serialized Data Size: " << buffer.size() << " bytes" << std::endl;
}

int main() {
    std::thread t1(serialize_data, 1);
    std::thread t2(serialize_data, 2);

    t1.join();
    t2.join();

    return 0;
}