Function rpc

less_slow.cpp:6870–6912

 */
template <typename server_t, typename client_t>
static void rpc(bm::State &state, networking_route_t route, std::size_t batch_size, std::size_t packet_size) {

    std::string address_to_listen = route == networking_route_t::loopback_k ? "127.0.0.1" : "0.0.0.0";
    std::string address_to_talk = route == networking_route_t::loopback_k ? "127.0.0.1" : fetch_public_ip();

    rpc_batch_result stats;
    try {
        // Create server and client
        server_t server(address_to_listen, rpc_port_k, batch_size);
        client_t client(address_to_talk, rpc_port_k, batch_size);

        std::thread server_thread(std::ref(server));
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        // Benchmark round-trip time
        for (auto _ : state) {
            rpc_batch_result batch_stats = client();
            stats += batch_stats;
            double seconds =
                std::chrono::duration_cast<std::chrono::duration<double>>(batch_stats.batch_latency).count();
            state.SetIterationTime(seconds);
        }

        server.stop();        // Inform the server to stop polling for new packets
        server_thread.join(); // Wait for the server to finish
        server.close();       // Close the server socket and free resources
    }
    catch (std::exception const &e) {
        state.SkipWithError(e.what());
    }

    // Process and report stats
    auto const mean_batch_latency_us =
        stats.received_packets ? to_microseconds(stats.batch_latency).count() * 1.0 / state.iterations() : 0.0;
    auto const mean_packet_latency_us = to_microseconds(stats.batch_latency).count() * 1.0 / stats.received_packets;

    state.SetItemsProcessed(stats.sent_packets);
    state.SetBytesProcessed(stats.sent_packets * packet_size);
    state.counters["drop,%"] = 100.0 * (stats.sent_packets - stats.received_packets) / stats.sent_packets;
    state.counters["mean_batch_latency,us"] = mean_batch_latency_us;
    state.counters["mean_packet_latency,us"] = mean_packet_latency_us;
    state.counters["max_packet_latency,us"] = to_microseconds(stats.max_packet_latency).count();
}

static void rpc_libc(bm::State &state, networking_route_t route, std::size_t batch_size, std::size_t packet_size) {
    return rpc<rpc_libc_server, rpc_libc_client>(state, route, batch_size, packet_size);