ScyllaDBとSeastarのアーキテクチャ：スレッドパーコア実行、Shared-Nothing C++、P99レイテンシ

// Example: Seastar asynchronous I/O
#include <seastar/core/app-template.hh>
#include <seastar/core/future.hh>
#include <seastar/core/file.hh>
#include <seastar/core/reactor.hh>
#include <seastar/core/thread.hh> // For seastar::thread

// Function to write data asynchronously to a file
seastar::future<> write_to_file(const seastar::sstring& filename, const seastar::sstring& data) {
    // Open the file asynchronously. O_CREAT | O_TRUNC | O_WRONLY are standard flags.
    // 0644 is file permissions.
    return seastar::open_file_dma(filename, seastar::open_flags::rw_create | seastar::open_flags::truncate).then([data](seastar::file f) {
        // Allocate a DMA-aligned buffer for efficient I/O
        auto buffer = seastar::temporary_buffer<char>::aligned(4096, data.size());
        std::copy(data.begin(), data.end(), buffer.begin());

        // Write the buffer to the file asynchronously
        return f.dma_write(buffer.get(), 0, buffer.size()).then([f = std::move(f), buffer = std::move(buffer)] (size_t bytes_written) {
            std::cout << "Wrote " << bytes_written << " bytes to " << f.get_path() << std::endl;
            // Close the file asynchronously
            return f.close();
        });
    }).handle_exception([](std::exception_ptr ep) {
        // Handle any exceptions during file operations
        std::cerr << "Error writing to file: " << seastar::current_exception_better_what(ep) << std::endl;
        return seastar::make_exception_future<>(ep);
    });
}

// Function to read data asynchronously from a file
seastar::future<seastar::sstring> read_from_file(const seastar::sstring& filename) {
    return seastar::open_file_dma(filename, seastar::open_flags::ro).then([filename](seastar::file f) {
        // Get file size to allocate buffer
        return f.size().then([f = std::move(f), filename](uint64_t size) mutable {
            auto buffer = seastar::temporary_buffer<char>::aligned(4096, size);
            // Read into the buffer asynchronously
            return f.dma_read(buffer.get(), 0, size).then([f = std::move(f), buffer = std::move(buffer)](size_t bytes_read) mutable {
                std::cout << "Read " << bytes_read << " bytes from " << f.get_path() << std::endl;
                // Close the file asynchronously
                return f.close().then([buffer = std::move(buffer)]() mutable {
                    return seastar::sstring(buffer.begin(), buffer.size());
                });
            });
        });
    }).handle_exception([](std::exception_ptr ep) {
        std::cerr << "Error reading from file: " << seastar::current_exception_better_what(ep) << std::endl;
        return seastar::make_exception_future<seastar::sstring>(ep);
    });
}

int main(int argc, char** argv) {
    seastar::app_template app;

    // Define the application's main function
    app.run(argc, argv, [] {
        return seastar::make_ready_future().then([] {
            seastar::sstring test_data = "Hello, Seastar asynchronous I/O!";
            seastar::sstring filename = "test_async_io.txt";

            // Chain asynchronous operations: write, then read, then print
            return write_to_file(filename, test_data).then([filename] {
                return read_from_file(filename);
            }).then([](seastar::sstring content) {
                std::cout << "File content: " << content << std::endl;
            }).handle_exception([](std::exception_ptr ep) {
                std::cerr << "Application failed: " << seastar::current_exception_better_what(ep) << std::endl;
                return seastar::make_exception_future<>(ep);
            });
        });
    });
    return 0;
}

# Assuming Seastar is installed and SEASTAR_HOME is set
g++ -std=c++17 -Wall -Werror -O2 -I${SEASTAR_HOME}/include -L${SEASTAR_HOME}/build/lib -Wl,-rpath=${SEASTAR_HOME}/build/lib -o async_io async_io.cpp -lseastar -lfmt -lstdc++fs -lboost_program_options -lboost_thread -lboost_system -lboost_filesystem -lboost_chrono -lboost_context -lboost_atomic -lhwloc -latomic -lrt -lm -ldl -lucontext -lnuma -lz -lcryptopp -lgnutls -lprotobuf -ljsoncpp -lcap -luring
./async_io --smp 1 # Run with 1 core

// Conceptual illustration of io_uring usage within Seastar (simplified)
// In reality, Seastar abstracts this heavily.

#include <liburing.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <iostream>
#include <vector>
#include <string>

// This is a simplified, standalone example to demonstrate io_uring concepts.
// Seastar integrates io_uring much more deeply into its reactor model.

const int QUEUE_DEPTH = 64;
const int BLOCK_SIZE = 4096;

int main() {
    struct io_uring ring;
    int ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret < 0) {
        std::cerr << "io_uring_queue_init: " << strerror(-ret) << std::endl;
        return 1;
    }

    int fd = open("test_io_uring.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        std::cerr << "open: " << strerror(errno) << std::endl;
        io_uring_queue_exit(&ring);
        return 1;
    }

    std::string write_data = "Hello from io_uring!";
    std::vector<char> write_buffer(BLOCK_SIZE);
    std::copy(write_data.begin(), write_data.end(), write_buffer.begin());

    // Prepare a write request
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    if (!sqe) {
        std::cerr << "io_uring_get_sqe failed" << std::endl;
        close(fd);
        io_uring_queue_exit(&ring);
        return 1;
    }
    io_uring_prep_write(sqe, fd, write_buffer.data(), write_buffer.size(), 0);
    sqe->user_data = 1; // Unique identifier for this request

    // Submit the request
    io_uring_submit(&ring);

    // Wait for completion
    struct io_uring_cqe *cqe;
    ret = io_uring_wait_cqe(&ring, &cqe);
    if (ret < 0) {
        std::cerr << "io_uring_wait_cqe: " << strerror(-ret) << std::endl;
        close(fd);
        io_uring_queue_exit(&ring);
        return 1;
    }

    if (cqe->res < 0) {
        std::cerr << "Write failed: " << strerror(-cqe->res) << std::endl;
    } else {
        std::cout << "Write completed: " << cqe->res << " bytes" << std::endl;
    }

    io_uring_cqe_seen(&ring, cqe); // Mark completion as seen

    // Prepare a read request
    std::vector<char> read_buffer(BLOCK_SIZE);
    sqe = io_uring_get_sqe(&ring);
    if (!sqe) {
        std::cerr << "io_uring_get_sqe failed for read" << std::endl;
        close(fd);
        io_uring_queue_exit(&ring);
        return 1;
    }
    io_uring_prep_read(sqe, fd, read_buffer.data(), read_buffer.size(), 0);
    sqe->user_data = 2; // Unique identifier for this request

    // Submit the request
    io_uring_submit(&ring);

    // Wait for completion
    ret = io_uring_wait_cqe(&ring, &cqe);
    if (ret < 0) {
        std::cerr << "io_uring_wait_cqe for read: " << strerror(-ret) << std::endl;
        close(fd);
        io_uring_queue_exit(&ring);
        return 1;
    }

    if (cqe->res < 0) {
        std::cerr << "Read failed: " << strerror(-cqe->res) << std::endl;
    } else {
        std::cout << "Read completed: " << cqe->res << " bytes. Content: " << std::string(read_buffer.data(), cqe->res) << std::endl;
    }

    io_uring_cqe_seen(&ring, cqe);

    close(fd);
    io_uring_queue_exit(&ring);
    return 0;
}

g++ -std=c++17 -Wall -Werror -O2 -o io_uring_example io_uring_example.cpp -luring
./io_uring_example