Asynchrony and coroutines

Асинхронность и сопрограммы
Григорий Демченко, разработчик YT, 2017

План
▌Введение
▌Сопрограммы
▌Планировщики
▌Синхронизация
▌Примеры
▌Заключение

Синхронный многопоточный сервер
5
void multitheadedServer() {
Acceptor acceptor{80}; // слушаем 80 порт
while (true) {
auto socket = acceptor.accept(); // 1-й блокирующий вызов
thread([socket] {
auto request = socket.read(); // 2-й блокирующий вызов
auto response = handleRequest(request);
socket.write(response); // 3-й блокирующий вызов
}).detach();
}
}

Асинхронный сервер
6
void asynchronousServer() {
Acceptor acceptor{80};
acceptor.onAccept([] (auto socket) { // 1-й асинхронный вызов
socket.onRead([socket](auto request) { // 2-й асинхронный вызов
socket.onWrite(response, []() { // 3-й асинхронный вызов
// завершение
});
});
// продолжаем принимать соединения...
});
}

Реальный асинхронный сервер
7
void realAsynchronousServer() {
Handler accepting = [&acceptor, &accepting] {
struct Connection {
explicit Connection(Socket sock) : socket(std::move(sock)) {}
void onConnect() {
if (error)
return onError(error);
socket.onRead([this](const Request& request, const Error& error) {
if (error)
response = handlerRequest(request);
socket.onWrite(response, [this](const Error& error) {
if (error)
onDone();
});
});
}
private:
void onError(const Error& error) {
delete this;
}
void onDone() {
delete this;
}
Response response;
Socket socket;
};
acceptor.onAccept([&accepting](Socket socket, const Error& error) {
if (!error) {
(new Connection{socket})->onConnect();
accepting();
}
});
};
}
▌ Сравните:
void asynchronousServer() {
acceptor.onAccept([] (socket) {
socket.onRead([socket](request) {
response = handleRequest(request);
socket.onWrite(response, []() {
// завершение
});
});
// продолжаем принимать соединения
});
}

Асинхронный сервер: обсуждение
8
▌ Плюсы:
› Производительность
› Автоматическая параллелизация исполнения
▌ Минусы:
› Сложность:
1.Нелинейный рост сложности и проблем
2.Явная передача контекста исполнения
3.Обработка ошибок
4.Время жизни объектов
5.Отладка

Что бы хотелось?
9
▌Использовать эффективность асинхронного подхода
▌Использовать простоту синхронного подхода

│ Решение: использовать
│ сопрограммы
10

Сопрограммы
▌ Подпрограмма: результат доступен сразу после завершения.
▌ Сопрограмма: результат будет доступен позже. Точка вызова
и точка получения результата разнесены
Примеры сопрограмм:
▌ Генераторы на языке Python.
▌ Async/await C++ proposal.
Метод сохранения контекста исполнения:
▌ Stackful сопрограммы.
12

Реализация сопрограмм
13
Проблема
▌ Сопрограммы пока еще не являются частью языка
▌ Необходимо применять низкоуровневые примитивы.
Решение: boost.context:
▌ Эффективное решение: использование ассемблера
▌ Десктопные платформы: Windows, Linux, MacOSX
▌ Мобильные платформы: Windows Phone, Android, IOS
▌ Процессоры: x86, ARM, Spark, Spark64, PPC, PPC64, MIPS
▌ Компиляторы: GCC, Clang, Visual Studio

boost.context
14
Работа с контекстом:
▌ make_fcontext: создает контекст
▌ jump_fcontext: переключает контекст
Контекст исполнения:
▌ execution_context<Args…>: создает контекст исполнения
Конструктор принимает сигнатуру:
▌ execution_context(execution_context ctx, Args… args)

Сопрограммы в действии
15
void coroFun() {
log << "2";
yield();
log << "4";
}
log << "1";
Coro c{coroFun};
log << "3";
c.resume();
log << "5";
Вывод:
▌ 12345

Использование сопрограммы
16
Преобразовать асинхронный вызов:
async(completionCallback);
В синхронный:
synca(); // async -> synca
Используя следующий подход:
void synca() {
auto& coro = currentCoro();
async([&coro] {
coro.resume();
});
yield();
}

Проблема: состояние гонки
18

Возможные решения
19
▌std::mutex
▌boost::asio::strand
▌defer

Использование defer
20
▌ defer откладывает асинхронный вызов:
using Handler = std::function<void()>;
void defer(Handler handler);

Использование: defer
22
void synca() {
async([&coro] {
coro.resume();
});
yield();
}
void synca() {
defer([&coro] {
async([&coro] {
coro.resume();
});
});
}

Абстрагирование от сопрограмм
23
void synca() {
defer([&coro] {
async([&coro] {
coro.resume();
});
});
}
void synca() {
deferProceed([](Handler proceed) {
async(proceed);
});
}

Synca сервер
24
void syncaServer() {
while (true) {
auto socket = acceptor.accept();
go([socket] { // стартуем новую сопрограмму
auto request = socket.read();
socket.write(response);
});
}
}

Планировщик
▌ Интерфейс планировщика:
struct IScheduler {
virtual void schedule(Handler) = 0;
};
Планировщик запускает обработчики.

Пул потоков
27
struct ThreadPool : IScheduler {
explicit ThreadPool(size_t threads);
void schedule(Handler handler) {
service.post(std::move(handler));
}
private:
boost::asio::io_service service;
};

Сопрограммы и планировщик
28
struct Journey {
void defer(Handler handler) {
deferHandler = std::move(handler);
yield();
}
void proceed() {
scheduler->schedule([this] {
coro.resume();
deferHandler();
});
}
private:
IScheduler* scheduler;
Coro coro;
Handler deferHandler;
};

Телепортация
29
▌ Давайте перепрыгнем на другой планировщик:
go([&] {
log << "Inside 1st thread pool";
teleport(tp2);
log << “Inside 2nd thread pool";
}, tp1);
▌ Реализация:
void Journey::teleport(IScheduler& s) {
scheduler = &s;
defer([this] {
proceed();
});
}

Телепортация: Sequence Diagram
30

Порталы
31
▌ Портал – это RAII телепортация:
struct Portal {
Portal(IScheduler& destination)
: source{currentScheduler()} {
teleport(destination);
}
~Portal() {
teleport(source);
}
private:
IScheduler& source;
};

Использование порталов
32
struct Network {
void handleNetworkEvents() {
// действия внутри сетевого пула потоков
}
};
ThreadPool commonPool{4};
ThreadPool networkPool{2};
portal<Network>().attach(networkPool);
go([] {
log << "Inside common pool";
portal<Network>()->handleNetworkEvents();
log << "Inside common pool";
}, commonPool);

│ Портал – абстракция
│ среды исполнения
33

Alone
35
struct Alone : IScheduler {
void schedule(Handler handler) {
strand.post(std::move(handler));
}
private:
boost::asio::io_service::strand strand;
};
strand гарантирует, что ни один обработчик не будет запущен
параллельно с другим

│ Alone – это
│ неблокирующая
│ синхронизация
│ без дедлоков
36

Интегральный пример: инициализация
38
struct DiskCache/MemCache {
optional<string> get(const string& key);
void set(const string& key, const string& val);
};
struct Network {
string performRequest(const string& key);
};
ThreadPool commonPool{3}; // общий пул операций
ThreadPool diskPool{2}; // дисковый пул операций
ThreadPool netPool{1}; // сетевой пул операций
Alone memAlone{commonPool}; // MemCache синхронизация
portal<DiskCache>().attach(diskPool);
portal<MemCache>().attach(memAlone);
portal<Network>().attach(netPool);

Интегральный пример: получение значения
39
string obtainValue(const string& key) {
auto res = portal<MemCache>()->get(key);
if (res)
return *res;
res = portal<DiskCache>()->get(key);
if (res)
return *res;
auto val = portal<Network>()->performRequest(key);
go([key, val] {
portal<MemCache>()->set(key, val);
portal<DiskCache>()->set(key, val);
});
return val;
}

Свойства портала
40
▌Работает с исключениями
▌Абстрагирует контекст исполнения

▌ 2. Есть код после вызова:
// код до
async(..., cb);
// код после
// код до
go { async(..., cb); };
// код до
go { synca(...); cb(); };
Теорема
42
Любая асинхронная задача может быть реализована через сопрограммы
▌ 1. Нет кода после вызова:
// код до
async(params..., cb);
// отсутствует код
// код до
synca(params...);
cb();

Выводы
43
▌ Синхронный подход: простота
▌ Асинхронный подход : эффективность
▌ Неблокирующая синхронизация без дедлоков
▌ Прозрачно для использования
▌ Работает с исключениями
▌ Работа с вложенными таймаутами
▌ Отмена операций
▌ Принципиально новые подходы и паттерны
▌ Это прикольно!

Асинхронность и сопрограммы
habrahabr.ru/users/gridem
gridem.blogspot.com github.com/gridem
bitbucket.org/gridem
Григорий Демченко, Разработчик YT
44

Asynchrony and coroutines

More Related Content

What's hot (20)

Similar to Asynchrony and coroutines (20)

More from corehard_by (20)

Asynchrony and coroutines