Boost ASIO / Coroutines: Попытка написать эхо-сервер с использованием boost asio и сопрограмм, но я получаю противоречивое поведение

Похоже, что я неправильно понял, как Windows обрабатывает сокеты в TIME_WAIT, когда открыто много сокетов. Если в TIME_WAIT висит слишком много, это просто ошибки. Linux очищает старые подключения и успешно (по крайней мере, на моем компьютере, не знаю, где это задокументировано).

Я пытаюсь написать эхо-сервер на основе сопрограмм, но он ведет себя немного случайным образом. Я явно что-то упускаю. Может кто-нибудь сказать мне, если мой подход неверен, и если да, то, что мне не хватает?

Обновление: Протестировано это на Linux (Ubuntu 14.04 / gcc 4.8 / boost 1.56), и все, кажется, хорошо. На окнах клиент начинает бросать исключения (Client Exception: Only one usage of each socket address (protocol/network address/port) is normally permitted) иногда. В других случаях все работает нормально.

Обновление два: я предположил, что что-то напортачило в моем коде, но, похоже, это больше проблема с моим пониманием работы в сети Windows. Похоже, что когда сокет находится в TIME_WAIT на окнах, он остается на месте, даже если новые сокеты запрашиваются выше некоторого предела, в linux они отбрасываются, когда запрашивается новый сокет, если вокруг слишком много зависаний.

#include <iostream>
#include <thread>
#include <memory>
#include <atomic>

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>

using namespace boost::asio::ip;
using namespace boost::asio;
using std::cout;
using std::endl;

std::atomic<int> active;

void echo_server(boost::asio::io_service &svc, int c)
{
spawn(svc, [&svc, c](yield_context y) {
try
{
tcp::acceptor acceptor(svc, tcp::endpoint(tcp::v4(), 6789));
for (int i = 0; i < c; i++)
{
std::shared_ptr<tcp::socket> s = std::make_shared<tcp::socket>(svc);
acceptor.async_accept(*s, y);

spawn(y, [s](yield_context y) mutable {
try
{
streambuf buf;
for (;;)
{
async_read(*s, buf, transfer_at_least(1), y);
async_write(*s, buf, y);
}
}
catch (boost::system::system_error &e)
{
if (e.code() != error::eof)
cout << e.what() << endl;
}
});
}
cout << "Server Done\n";
}
catch (std::exception &e)
{
std::cerr << "Server Exception: " << e.what() << std::endl;
}
});
}

void echo_client(boost::asio::io_service &svc)
{
spawn(svc, [&svc](yield_context y) {
tcp::socket sock(svc);
try
{
async_connect(sock, tcp::resolver(svc).async_resolve(
tcp::resolver::query("localhost", "6789"), y), y);

char data[128];
memcpy(data, "test", 5);
async_write(sock, buffer(data), y);
memset(data, 0, sizeof(data));
async_read(sock, buffer(data), transfer_at_least(1), y);
if (strcmp("test", data))
cout << "Error, server is broken\n";

}
catch (std::exception &e)
{
std::cerr << "Client Exception: " << e.what() << std::endl;
}

active--;
});
}

int main(int argc, char **argv)
{
io_service svc;
int c = 10000;
active = 0;

// Schedule a server
echo_server(svc, c);

// Schedule a bunch of clients, run only 1000 at a time.
while (c > 0)
{
cout << "Remain " << c << endl;
for (int i = 0; i < 1000; i++)
{
echo_client(svc);
}
active = 1000;
while (active > 0)
{
if (svc.run_one() == 0)
{
cout << "IO Service reset\n";
svc.reset();
}
}
c -= 1000;
}
svc.run();

return 0;
}