Início / coding / Perguntas / 78100790
Accepted
Zohar81
Asked: 2024-03-04 19:07:17 +0800 CST

Executando o Boost Beast Resolver para vários URLs em paralelo

  • 772

Eu queria saber se executarmos várias chamadas, async_resolvena prática io_contextnão executaremos mais de uma solicitação por vez devido a uma limitação conhecida.

Aqui está um exemplo de exemplo em que eu esperaria que cada solicitação de resolução rendesse enquanto espera o retorno da resposta do DNS e passa para a próxima solicitação e assim por diante.

mas olhando para o Wireshark parece que a próxima resolução é executada somente após a conclusão da anterior.

boost::asio::ip::tcp::resolver resolver(io_ctx_);
const auto results1 = resolver.async_resolve(host1_, std::to_string(port1_), yield);
const auto results2 = resolver.async_resolve(host2_, std::to_string(port2_), yield);
const auto results3 = resolver.async_resolve(host3_, std::to_string(port3_), yield);

Lida io_contextapenas com uma solicitação de resolução por vez?

c++

1 respostas

  1. Best Answer

    Você produz e retoma especificamente a corrotina para cada invocação.

    Sua própria co-rotina é o que serializa explicitamente as invocações.

    Aqui está uma reprodução direta e independente:

    Ao vivo no Coliru

    #include <boost/asio.hpp>
#include <boost/asio/experimental/promise.hpp>
#include <boost/asio/experimental/use_promise.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>
namespace asio = boost::asio;
using asio::ip::tcp;

void foo(asio::yield_context yield) {
    struct {
        std::string                 host;
        uint16_t                    port;
        tcp::resolver::results_type results;
    } queries[]{
        {"www.example.com", 80, {}},
        {"localhost", 53, {}},
        {"httpbin.org", 443, {}},
    };
    tcp::resolver resolver(yield.get_executor());

    for (auto& [h, p, r] : queries)
        r = resolver.async_resolve(h, std::to_string(p), yield);

    for (auto& q : queries)
        for (auto& ep : q.results)
            std::cout << ep.host_name() << ":" << ep.service_name() << " -> " << ep.endpoint() << std::endl;
}

int main() {
    asio::io_context ioc;
    asio::spawn(ioc, foo);
    ioc.run();
}

    Impressão, por exemplo

    www.example.com:80 -> 93.184.216.34:80
www.example.com:80 -> [2606:2800:220:1:248:1893:25c8:1946]:80
localhost:53 -> 127.0.0.1:53
httpbin.org:443 -> 3.221.184.26:443
httpbin.org:443 -> 35.173.166.175:443
httpbin.org:443 -> 54.165.134.201:443
httpbin.org:443 -> 174.129.27.151:443

    Usando o rastreamento do manipulador :

    Promessas

    Há muitas maneiras de consertar isso, mas deixe-me tentar a "nova" use_promiseabordagem aqui:

    Ao vivo no Coliru

    #include <boost/asio.hpp>
#include <boost/asio/experimental/parallel_group.hpp>
#include <boost/asio/experimental/promise.hpp>
#include <boost/asio/experimental/use_promise.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>
namespace asio = boost::asio;
using asio::experimental::promise;
using asio::experimental::use_promise;
using asio::ip::tcp;
using boost::system::error_code;

void foo(asio::yield_context yield) {

    struct {
        std::string host;
        uint16_t    port;
    } queries[]{
        {"www.example.com", 80},
        {"localhost", 53},
        {"httpbin.org", 443},
    };

    tcp::socket   s(yield.get_executor());
    tcp::resolver resolver(yield.get_executor());

    std::vector<promise<void(error_code, tcp::resolver::results_type)>> pp;
    for (auto& [h, p] : queries)
        pp.emplace_back(resolver.async_resolve(h, std::to_string(p), use_promise));

    for (auto& p : pp)
        for (auto& ep : p(yield))
            std::cout << ep.host_name() << ":" << ep.service_name() << " -> " << ep.endpoint() << std::endl;
}

int main() {
    asio::io_context ioc;
    spawn(ioc, foo);
    ioc.run();
}

    Mesma saída, mas agora usando rastreamento de manipulador:

    BÔNUS

    Usar operadores aguardáveis ​​com corrotinas c++20 geralmente é mais amigável e não requer Boost Context (ou Boost Coroutine):

    Ao vivo no Coliru

    #include <boost/asio.hpp>
#include <boost/asio/experimental/awaitable_operators.hpp>
#include <iostream>
#include <ranges>
namespace asio = boost::asio;

using namespace asio::experimental::awaitable_operators;
using asio::ip::tcp;

asio::awaitable<void> foo() {
    tcp::resolver resolver(co_await asio::this_coro::executor);
    auto op1 = resolver.async_resolve("www.example.com", std::to_string(80), asio::use_awaitable);
    auto op2 = resolver.async_resolve("localhost", std::to_string(53), asio::use_awaitable);
    auto op3 = resolver.async_resolve("httpbin.org", std::to_string(443), asio::use_awaitable);

    auto [r1, r2, r3] = co_await (std::move(op1) && std::move(op2) && std::move(op3));

    for (auto&& eps : {r1, r2, r3})
        for (auto&& ep : eps)
            std::cout << ep.host_name() << ":" << ep.service_name() << " -> " << ep.endpoint() << std::endl;
}

int main() {
    asio::io_context ioc;
    co_spawn(ioc, foo, asio::detached);
    ioc.run();
}

    Ou use grupos paralelos , especificamente para torná-lo dinâmico com um grupo paralelo de longo alcance:

    Ao vivo no Coliru

    #include <boost/asio.hpp>
#include <boost/asio/experimental/parallel_group.hpp>
#include <boost/asio/spawn.hpp>
#include <iostream>
#include <ranges>
namespace r = std::ranges;
namespace v = r::views;
namespace asio = boost::asio;
using asio::ip::tcp;

asio::awaitable<void> foo() {
    struct {
        std::string host;
        uint16_t    port;
    } queries[]{
        {"www.example.com", 80},
        {"localhost", 53},
        {"httpbin.org", 443},
    };

    tcp::resolver resolver(co_await asio::this_coro::executor);
    auto          start_resolve = [&resolver](auto& q) {
        return resolver.async_resolve(q.host, std::to_string(q.port), asio::deferred);
    };

    auto r  = queries | v::transform(start_resolve);
    auto pg = asio::experimental::make_parallel_group(std::vector(r.begin(), r.end()));

    auto results = co_await pg.async_wait(asio::experimental::wait_for_all{}, asio::deferred);

    for (auto&& eps : get<2>(results))
        for (auto&& ep : eps)
            std::cout << ep.host_name() << ":" << ep.service_name() << " -> " << ep.endpoint() << std::endl;
}

int main() {
    asio::io_context ioc;
    co_spawn(ioc, foo, asio::detached);
    ioc.run();
}

    Ambos os exemplos do c++20 resultam em execução idêntica:insira a descrição da imagem aqui

    • 3

relate perguntas