Adding Async Algorithms to std C

Adding Async Algorithms to std
C++Russia, Санкт-Петербург
© 2016 Kirk Shoop (github twitter)
1
debounce
5
diagrams courtesy of André Staltz from rxmarbles
1 / 60
1
2 3 4 5 6
6

code (rxcpp)
asyncReadBytes() |
tap(printVectorOfBytes) |
concat_map(vectorOfStringsFromVectorOfBytes) |
group_by(groupFromString) |
flat_map(appendGroupStrings) |
subscribe(println(cout));
output (emscripten)
65 65 65 65 65 65 13 66 66 66 66
AAAAAA
66 66 66 66 66 66 66 66 66 66 66
66 66 13 67 67 67 67 67 67 67 13
BBBBBBBBBBBBBBBBB
CCCCCCC
68 68 68 68 68 68 68 68 68 68 68
68 68 68 13 69 69 69 69 69 69 69
DDDDDDDDDDDDDD
69 69 69 69 69 69 69 69 13
EEEEEEEEEEEEEEE
lines from bytes
© 2016 Kirk Shoop (github twitter) 2 / 60

code (rxcpp)
auto down$ = mousedown$("#window");
auto up$ = mouseup$("#window");
auto move$ = mousemove$("#window");
down$ |
flat_map([=](MouseEvent){
return move$ |
take_until(up$) |
map([](MouseEvent){return 1;}) |
start_with(0) |
sum();
}) |
map(
[](int c){
return to_string(c) + " moves while mouse down";
}) |
output (emscripten)
2 moves while mouse down
moves while mouse button down

code (rxcpp)
struct data { int size; string firstLine;};
struct model {
map<string, data> store;
};
httpGet("http://kirkshoop.github.io/.../README.md") |
flat_map([](response_t r) {
return r.progress() |
combine_latest(
[=](progress_t p, vector<uint8_t> d){
return make_tuple(r.url(), p, d);
},
r.load()) |
scan(
model{},
updateModelFromTuple);
}) |
output (emscripten)
README.md, 0
README.md, 0
README.md, 66
README.md, 66
здравствуйте!
bytes from http GET

1
combineLatest((x, y) => "" + x + y)
2D
5 / 60
A
1A
2
2A
B
2B
C
2C
D
3
3D
4
4D
5
5D

scan((x, y) => x + y)
6 / 60
1
1
2
3
3
6
4
10
5
15

why alogrithms?
documented
stable
optimized
descriptive

what do algorithms operate on?

sequences

in space
vector of mouse positions
generator of mouse positions
using mouseMoves = vector<tuple<int,int>>;
sequences
auto mouseMoves(int start, int end)
-> std::generator<tuple<int, int>> {
for(;start != end; ++start){
auto position = start * 100;
co_yield make_tuple(position, position);
}
}
0, 0 100, 100 200, 200 300, 300 400, 400
11 / 60

in time
mouse move events
network packets
auto window::mouseMoves()
-> async_generator<tuple<int, int>> {
for co_await(auto event : events()) {
if (event.id == MOUSEMOVE) {
co_yield mousePositionFrom(event);
}
}
}
auto socket::bytes()
-> async_generator<vector<byte>> {
vector<byte> out;
while (out = co_await read(. . .)) {
co_yield out;
}
}
sequences

what are the design options?
abstract the sequence or algorithm?
flow control using push or pull?
cancel by ommission or trigger?
chain algorithms using operator| or function nesting?

what designs allow async algorithms?
abstract flow cancel chain
sequence push trigger operator

what might a toy implementation based on these properties look like?

push sequence implementations
const auto ints = [](auto first, auto last){
return [=](auto r){
for(auto i=first;i <= last; ++i){
r(i);
}
};
};
const auto copy_if = [](auto pred){
return [=](auto dest){
return [=](auto v){
if (pred(v)) dest(v);
};
};
};
const auto printto = [](auto& output){
return [&](auto v) {
output << v << endl;
};
};
auto even = [](auto v){return (v % 2) == 0;};
push sequence concepts
struct sender
{
template<class Receiver>
void operator()(Receiver);
};
struct algorithm
{
template<class SenderV>
SenderV operator()(SenderV);
};
struct lifter
{
template<class ReceiverV>
ReceiverU operator()(ReceiverV);
};
struct receiver
{
template<class V>
void operator()(V);
};

code
ints(0, 9)(copy_if(even)(printto(cout)));
output (emscripten)
0
2
4
6
8
push sequence

code
ints(0, 9) |
copy_if(even) |
printto(cout);
output (emscripten)
0
2
4
6
8
push sequence

what needs to change to support last_or_default?
last
20 / 60
1 2 3 4
4

const auto last_or_default = [](auto def){
auto l = make_shared<decay_t<decltype(def)>>(def);
return make_receiver(
[=](auto v){
l = v;
},
[=](){
d(l);
d();
});
};
};
struct receiver
{
template<class V>
void operator()(V);
void operator()();
};

code
ints(0, 100000000) |
copy_if(even) |
last_or_default(42) |
printto(cout);
output (emscripten)
new ints
new copy_if
new last_or_default
new printto
new lifetime
last_or_default bound to dest
copy_if bound to dest
ints bound to dest
99999998
1 values received - done!
stopped
destructed
what needs to change to support last_or_default?

what needs to change to support take?
take(2)
23 / 60
1
1
2
2
3 4

const auto take = [](int n){
auto remaining = dest.lifetime.
template make_state<int>(n);
return make_receiver(dest, remaining,
[](auto& d, auto& r, auto v){
if (r-- == 0) {
d();
}
d(v);
});
};
};
struct subscription
{
using stopper = function<void()>;
bool is_stopped();
void stop();
void insert(subscription);
void erase(subscription);
void insert(stopper);
template<class Payload,
class... ArgN>
state<Payload>
make_state(ArgN... argn);
};
struct receiver
{
subscription lifetime;
template<class V>
void operator()(V);
void operator()();
};

code
async_ints(0, 9) |
copy_if(even) |
take(3) |
printto(cout);
output (emscripten)
new async_ints
new copy_if
new take
new printto
new lifetime
take bound to dest
async_ints bound to dest
0
2
4
3 values received - done!
stopped
destructed
what needs to change to support take?

what needs to change to support failure?

struct receiver
{
subscription lifetime;
template<class V>
void operator()(V);
void operator()(exception_ptr);
void operator()();
};

code
async_ints(0, 9) |
copy_if(always_throw) |
take(3) |
printto(cout);
output (emscripten)
new async_ints
new copy_if
new take
new printto
new lifetime
take bound to dest
async_ints bound to dest
always throw!
stopped
destructed

what needs to change to support delay?
1
delay
30 / 60
2 1
1 2 1

struct schedulable
: public worker
, public subscription {
void operator()();
};
struct worker {
steady_clock::time_point now();
void schedule(const schedulable& scbl);
void schedule(
steady_clock::time_point when,
const schedulable& scbl);
};
struct scheduler {
worker create_worker(subscription);
};
struct subscription {
void unsubscribe();
};
template<class T>
struct observer {
on_next(T);
on_error(exception_ptr);
on_completed();
};
template<class T>
struct subscriber
: public observer<T>
};
template<class T>
struct observable {
subscription subscribe(subscriber<T>);
};

code
interval(1s, scheduler) |
tap(printproduced) |
delay(1500ms, scheduler) |
take(5) |
subscribe(printemitted);
output (emscripten)
1.0s - 1 produced
2.0s - 2 produced
2.5s - 1 emitted
3.0s - 3 produced
3.5s - 2 emitted
4.0s - 4 produced
4.5s - 3 emitted
4.512s - real time elapsed

what needs to change to support testing?

struct test_worker {
void schedule(
void advance_to(long time) const;
void advance_by(long time) const;
void sleep(long time) const;
template<class T, class F>
auto start(F createSource, long created,
long subscribed, long unsubscribed) const
-> subscriber<T, testable_observer<T>>;
};
struct recorded {
steady_clock::time_point time() const;
template<class Observer>
virtual accept(const Observer& o) const;
};
struct test {
using messages_t vector<recorded>;
steady_clock::time_point now() const;
test_worker create_worker(subscription cs) const
template<class T>
auto make_hot_observable(messages_t m) const
-> testable_observable<T>;
template<class T>
auto make_cold_observable(messages_t m) const;
-> testable_observable<T>;
};

code
auto scheduler = make_test();
auto worker = scheduler.create_worker();
auto interval$ = scheduler.make_hot_observable({
on.next(1000, 1),
on.next(2000, 2),
on.next(3000, 3),
on.next(4000, 4)
});
auto res = worker.start([&]() {
return interval$ |
tap(printproduced) |
delay(1500ms, scheduler) |
take(3) |
tap(printemitted);
});
output (emscripten)
1.0s - 1 produced
2.0s - 2 produced
2.5s - 1 emitted
3.0s - 3 produced
3.5s - 2 emitted
4.0s - 4 produced
4.5s - 3 emitted
0.026s - real time elapsed
emitted value test - SUCCEEDED
lifetime test - SUCCEEDED

auto required = rxu::to_vector({
on.next(1000 + 1500, 1),
on.next(2000 + 1500, 2),
on.next(3000 + 1500, 3)
});
auto actual = res.get_observer().messages();
cout << "emitted value test";
if (required == actual) {
cout << " - SUCCEEDED" << endl;
} else {
cout << " - FAILED" << endl;
cout << "REQUIRED: " << required << endl;
cout << "ACTUAL : " << actual << endl;
}

what designs do other combinations produce?

async_generator
sequence pull trigger operator

template<class T>
struct await_iterator {
bool await_ready();
void await_suspend(coroutine_handle<>);
async_iterator<T> await_resume();
};
template<class T>
struct async_iterator {
T& operator*();
await_iterator<T> operator++();
};
template<class T>
struct async_generator {
await_iterator<T> begin();
async_iterator<T> end();
};
async_generator
async_generator concepts

async_generator
implement filter operator
template<typename T, typename P>
async_generator<T> filter(async_generator<T> s, P pred) {
for co_await(auto&& v : s) {
if (pred(v)) {
co_yield v;
}
}
}

async_generator
use operators to chain algorithms together
auto fiveOddInts = tempSensor() |
filter([](int n) { return n % 2 == 0; }) | // discard even
take(5); // stop after 5
for co_await(auto n : fiveOddInts) {
// . . .
}

sfrp
sequence pull omission function

sfrp
sequence pull omission function
example
template <typename R, typename Args...>
Behavior<R>
map(function<R(Args...)> func, Behavior<Args>... behaviors);
Behavior<Drawing>
circleFollowsMouse(Behavior<Point2D> mousePos) {
return map(circleAt, mousePos);
}

Спасибо!
I enjoyed visiting with you in
Санкт-Петербург!

complete.
questions?
20
merge
20
46 / 60
40
40
60
60
1
1
80
80
100
100
1
1

range-v3
sequence pull omission operator

range-v3
the range concept
template<class Iterator, class EndIterator = Iterator>
struct range {
Iterator begin();
EndIterator end();
};

range-v3 - implement the transform view
// A class that adapts an existing range with a function
template<class Rng, class Fun>
class transform_view : public view_adaptor<transform_view<Rng, Fun>, Rng>
{
class adaptor : public adaptor_base
{
// . . .
auto get(range_iterator_t<Rng> it) const -> decltype(fun_(*it)) {
return fun_(*it);
}
};
adaptor begin_adaptor() const { return {fun_}; }
adaptor end_adaptor() const { return {fun_}; }
// . . .
};
template<class Rng, class Fun>
transform_view<Rng, Fun> transform(Rng && rng, Fun fun) {
return {std::forward<Rng>(rng), std::move(fun)};
}

range-v3
auto fiveOddInts = view::ints(0) | //generates next int when asked
view::remove_if([](int n) { return n % 2 == 0; }) | // discard even ints
view::take(5); // stop after 5
auto result = fiveOddInts | view::to_vector;

Transducers
algorithm push omission function

Transducers
the step function
struct transducer {
template<class NextStep>
struct step {
template<class State, class T>
auto operator()(State state, T v);
template<class State>
auto operator()(State state);
};
template<class NextStep>
auto operator()(NextStep nextstep) {
return step<NextStep>(nextstep);
}
}; © 2016 Kirk Shoop (github twitter) 53 / 60

Transducers
implement the filterer transducer
auto filterer = [](auto pred) {
return [=](auto step) {
return stateless(
[=](auto s, auto v) {
if (pred(v)) {return step(s, v);}
return s;
},
[=](auto s){
return step(s);
});
};
};

Transducers
use function nesting to chain algorithms together
auto fiveOddInts = comp(
filter([](int n) { return n % 2 == 0; }), // discard even
take(5)); // stop after 5
auto result = into(vector<int> {}, fiveOddInts, range(0, 10));

rxcpp

struct schedulable
: public worker
void operator()();
};
struct worker {
void schedule(
};
struct scheduler {
worker create_worker(subscription);
};
struct subscription {
void unsubscribe();
};
template<class T>
struct observer {
on_next(T);
on_error(std::exception_ptr);
on_completed();
};
template<class T>
struct subscriber
: public observer<T>
};
template<class T>
struct observable {
subscription subscribe(subscriber<T>);
};
concepts in rxcpp

rxcpp - implement the filter operator
auto filter = [](auto pred) {
return [=](auto subscriber) {
return make_subscriber(
[=](auto v) {
if (pred(v)) {
subscriber.on_next(v);
}
},
[=](std::exception_ptr ep) {
subscriber.on_error(ep);
},
[=]() {
subscriber.on_completed();
}
);
}
};

rxcpp
auto fiveOddInts = tempSensor() |
filter([](int n) { return n % 2 == 0; }) | // discard even
take(5); // stop after 5
fiveOddInts.subscribe([](int n){. . .});

Adding Async Algorithms to std C

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (15)

Similar a Adding Async Algorithms to std C

Similar a Adding Async Algorithms to std C (20)

Más de Sergey Platonov

Más de Sergey Platonov (16)

Último

Último (20)

Adding Async Algorithms to std C