Как показывает практика, повсеместное применение классического, основанного на callback’ах подхода к асинхронному программированию обычно оказывается неудобным. Для упрощения написания и поддержки сложного асинхронного кода можно использовать иной подход — с использованием сопрограмм. Он значительно сокращает объём и сложность кода, превращая код из асинхронного в синхронный.

2. Асинхронность и
сопрограммы
Демченко Григорий, старший разработчик
C++ User Group, 27 февраля 2015

3. План рассказа
Реализация сопрограмм
Ожидающие примитивы
Примитивы, использующие планировщик
Заключение

4. План рассказа
Реализация сопрограмм
Ожидающие примитивы
Примитивы, использующие планировщик
Заключение

5. Многопоточный сервер
Acceptor acceptor(80);
while (true) {
socket = acceptor.accept();
go([socket] { // запуск в новом потоке
request = socket.read();
response = handleRequest(request);
socket.write(response);
});
}
• Недостатки:
o Большую часть времени потоки ожидают на I/O событиях и не
делают полезной работы => бесполезная трата ресурсов

6. Асинхронность
action1();
action2();
• Синхронность: action2 не выполняется, пока не закончится
action1.
• Асинхронность: action2 выполняется, даже если action1 не
завершился.

7. Асинхронность
Когда заканчивается операция?
1. Мы вызываем: периодический опрос состояния - реакторная
модель (select, epoll, kqueue)
2. Нас вызывают: проакторная модель исполнения (UI, IOCP,
javascript):
void onActionComplete(Result) {...}
action1(onActionComplete);
Будем использовать проактор boost.asio

8. Асинхронный сервер
Acceptor acceptor(80);
acceptor.onAccept([] (socket) {
socket.onRead([&socket](request) {
response = handleRequest(request);
socket.onWrite([&response]() {
// completed
});
});
// continue accepting???
});
• Более бережное использование ресурсов, но…

9. Асинхронный сервер: обсуждение
• Достоинства
o Производительность
o Относительно простая параллелизация
• Недостатки
o Сложность:
 Передача контекста
 Нелинейная структура кода
 Обработка ошибок
 Время жизни объектов
 Отладка
 С ростом количества операций сложность растет нелинейно

10. Решение
Что бы хотелось?
• У асинхронного взять быстродействие
• У синхронного - простоту
Т.е. объединить достоинства и убрать недостатки, присущие обоим
методам.
Как этого добиться? Ответ: использовать сопрограммы!!!

11. Сопрограммы
• Подпрограмма: выполняются все действия перед возвратом
управления
• Сопрограмма: частичное выполнение действий перед возвратом
управления
Сопрограмма обобщает понятие подпрограммы, т.е. подпрограмма -
это частный случай сопрограммы.
Пример сопрограммы: генераторы (например, на python)
Для эффективной реализации на С++ будем использовать метод
сохранения контекста исполнения (stackful coroutines).

12. Реализация сопрограмм
• Проблемы
o Сопрограммы никак не описаны в стандарте
o Необходимо применять низкоуровневые операции =>
зависимость от платформы, архитектуры и даже компилятора.
• Решение: использовать boost.context:
o Используется только ассемблер
o Поддержка платформ: Windows, Linux, MacOSX
o Поддержка мобильных платформ: Windows Phone, Android, IOS,
o Поддержка архитектур: x86, x86_64, ARM, Spark, Spark64, PPC,
PPC64, MIPS
o Поддержка компиляторов: GCC, Clang, Visual Studio

13. boost.context
Реализует 2 функции:
• make_fcontext: создает контекст и инициализирует стек
сопрограммы
• jump_fcontext: переходит в новый контекст с сохранением текущего
контекста для последующего возврата
Использование:
1. Выделение памяти под стек.
2. Создание контекста
ctx = make_fcontext(stackPtr, stackSize, callback)
3. Переход: jump_fcontext(callerCtx, ctx, ptr)
4. Возврат: jump_fcontext(ctx, callerCtx, ptr)

14. Реализация сопрограмм: Coro
void coroFn() {
CLOG("Yielding...");
yield();
CLOG("Returning...");
}
CLOG("Starting...");
Coro c(coroFn);
CLOG("Resuming...");
c.resume();
CLOG("Completed");
Выдача:
0: Starting...
1: Yielding...
0: Resuming...
1: Returning...
0: Completed

15. Использование сопрограмм
• Переделываем асинхронный вызов:
performAsyncOp(completionAction);
• В синхронный с использованием сопрограмм:
performOp();
void performOp() {
auto& coro = currentCoro();
performAsyncOp([&coro] { coro.resume(); });
yield();
}

16. Использование сопрограмм
• Scheduler:
boost::asio::io_service
• Thread: std::thread
• Coro: реализация с использованием
boost.context
• Network:
boost::asio::read/write/...

17. Проблема: состояние гонки
Возможно возобновление
работы сопрограммы до
выхода из нее
Варианты решения:
1. std::mutex
2. boost::asio::strand
3. defer

18. Решение: defer
defer: откладывание асинхронной
операции до выхода из
сопрограммы
typedef
std::function<void()> Action;
void defer(Action);

19. Использование defer
void performOp() {
auto& coro = currentCoro();
performAsyncOp([&coro] { coro.resume(); });
yield();
}
void performOp() {
auto& coro = currentCoro();
defer([&coro] {
performAsyncOp([&coro] { coro.resume(); });
});
}

20. Реализация на сопрограммах
Acceptor acceptor(80);
while (true) {
socket = acceptor.accept();
go([socket] { // запуск в сопрограмме
request = socket.read();
response = handleRequest(request);
socket.write(response);
});
}
• Код полностью идентичен синхронному подходу

21. План рассказа
Реализация сопрограмм
Ожидающие примитивы
Примитивы, использующие планировщик
Заключение

22. Ожидание завершения операции
• Задача: запустить асинхронно операцию и дождаться её завершения.
void goWait(Action action);
• Проблема обычного подхода: во время ожидания поток остается
заблокированным
• Сопрограммы с легкостью решают эту проблему

23. Ожидание завершения операции
void goWait(Action action) {
deferProceed([&action](Action proceed) {
go([proceed, &action] { // создаем новую сопрограмму
action();
proceed(); // продолжаем выполнение сопрограммы
});
});
}
void deferProceed(std::function<void(Action)> proceed) {
auto& coro = currentCoro();
defer([&coro, proceed] {
proceed([&coro] { coro.resume(); });
});
}

24. Ожидание завершения операций
• Задача: запустить асинхронно несколько операций и дождаться их
завершения.
void goWait(std::initializer_list<Action> actions);
• Проблема: во время ожидания поток остается заблокированным
• Сопрограммы с легкостью решают эту проблему

25. Ожидание завершения операций
void goWait(std::initializer_list<Action> actions) {
deferProceed([&actions](Action proceed) {
std::shared_ptr<void> proceeder(
nullptr, [proceed](void*) { proceed(); });
for (const auto& action: actions) {
go([proceeder, &action] {
action();
});
}
});
}

26. Ожидание завершения операций
Последовательность вызовов для:
goWait(action1, action2);

27. Пример: вычисление числа Фибоначчи
int fibo(int v) {
if (v < 2)
return v;
int v1, v2;
goWait({
[v, &v1] { v1 = fibo(v-1); },
[v, &v2] { v2 = fibo(v-2); }
});
return v1 + v2;
}

28. План рассказа
Реализация сопрограмм
Ожидающие примитивы
Примитивы, использующие планировщик
Заключение

29. Планировщик
• Интерфейс планировщика:
struct IScheduler {
virtual void schedule(Action action) = 0;
};
• Планировщик отвечает за запуск задач: action
• ThreadPool реализует интерфейс IScheduler с использованием
boost.asio:
struct ThreadPool : IScheduler {
ThreadPool(size_t thread_count) { … }
void schedule(Action action) {
service.post(std::move(action));
}
private:
boost::asio::io_service service;
};

30. Возобновление сопрограммы
• Возобновление работы сопрограммы происходит с использованием
планировщика:
struct Journey {
void proceed() {
scheduler->schedule([this] {
coro.resume();
onComplete();
});
}
void onComplete(); // вызов action в defer
// или удаление сопрограммы
private:
IScheduler* scheduler;
Coro coro;
};

31. Телепортация
• Переключение между планировщиками. Внутри сопрограммы:
ThreadPool tp1(1);
ThreadPool tp2(1);
go([&tp2] {
JLOG("Inside tp1");
teleport(tp2);
JLOG("And now inside tp2!!!");
}, tp1);
• Реализация:
void Journey::teleport(IScheduler& s) {
scheduler = &s;
defer(proceedAction());
}

32. Телепортация
Происходит
переключение
исполнения
сопрограммы с
Scheduler/Thread на
Scheduler2/Thread2

33. Портал
• Портал - телепортация туда и обратно:
struct Portal {
Portal(IScheduler& destination)
: source(currentScheduler()) {
teleport(destination);
}
~Portal() {
teleport(source);
}
private:
IScheduler& source;
};

34. Использования портала
• Пример использования портала:
struct Network {
void handleNetworkEvents() {
// долгие и нетривиальные операции
}
};
ThreadPool common(1);
ThreadPool networkPool(1);
portal<Network>().attach(networkPool);
go([] {
JLOG("Execution inside common");
portal<Network>()->handleNetworkEvents();
JLOG("Continue execution inside common");
}, common);

35. Alone
• Для глобальных объектов часто требуется эксклюзивный доступ.
Обычно используется мьютексы.
• Сопрограммы позволяют ввести новый паттерн: Alone.
struct Alone : IScheduler {
void schedule(Action action) {
strand.post(std::move(action));
}
private:
boost::asio::io_service::strand strand;
};
• Гарантирует выполнение не более одного action в каждый момент
времени.

36. Интегральный пример
struct DiskCache/MemCache {
boost::optional<std::string> get(const std::string& key);
void set(const std::string& key, const std::string& val);
};
ThreadPool commonPool(3); // общий пул потоков
ThreadPool diskPool(2); // пул для дисковых операций
Alone memAlone(commonPool); // сериализация действий с памятью
portal<DiskCache>().attach(diskPool); // привязка портала для диска
portal< MemCache>().attach(memAlone); // привязка портала для памяти
boost::optional<std::string> result = goAnyResult<std::string>({
[&key] { return portal<DiskCache>()->get(key); },
[&key] { return portal< MemCache>()->get(key); }
});

37. Обсуждение использования порталов
struct MemCache {
boost::optional<std::string> get(const std::string& key);
void set(const std::string& key, const std::string& val);
};
portal<MemCache>()->set(key, val);
Дружественность к исключениям
Абстракция от контекста исполнения: возможно использование с
различными планировщиками.
Порталы – аналог акторов:
– Типы сообщений → методы
– Сообщение → параметры метода

38. План рассказа
Реализация сопрограмм
Ожидающие примитивы
Примитивы, использующие планировщик
Заключение

39. Теорема
Любую асинхронную задачу можно решить с помощью сопрограмм
1. После вызова код отсутствует:
// код до вызова
async(..., action);
// код до вызова
synca(...); action();
2. После вызова код присутствует:
// код до вызова
async(..., action);
// код после вызова
// код до вызова
go { async(..., action); }
// код после вызова
// код до вызова
go { synca(...); action(); }
// код после вызова

40. Бонус: простой GC
struct A { ~A() { TLOG("~A"); } };
struct B:A { ~B() { TLOG("~B"); } };
struct C { ~C() { TLOG("~C"); } };
go([] {
A* a = gcnew<B>();
C* c = gcnew<C>();
});
Обратите внимание на невиртуальные
деструкторы!
Вывод в консоли:
tp#1: [1] ended
tp#1: ~C
tp#1: ~B
tp#1: ~A

41. Реализация простого GC
template<typename T, typename... V>
T* gcnew(V&&... v) {
return gc().add(new T(std::forward(v)...));
}
GC& gc() { return journey().gc; }
struct GC {
~GC() {
for (auto& deleter: boost::adaptors::reverse(deleters))
deleter();
}
template<typename T> T* add(T* t) {
deleters.emplace_back([t] { delete t; });
return t;
}
private:
std::vector<Handler> deleters;
};

42. Выводы
• Простота синхронного подхода
• Эффективность асинхронного подхода
• Бережное использование ресурсов (нет ожиданий)
• Эффективная реализация многопоточных паттернов
• Введение новых паттернов (телепортация, порталы, …)
• Это прикольно!
Код: https://bitbucket.org/gridem/synca
gridem@yandex-team.ru
http://habrahabr.ru/users/gridem

43. Спасибо за внимание!