Rust Programming Language RustFest Barcelona 2019, 28 Nov 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: RustFest Barcelona - Florian Gilcher: async/await with async-std

Description

async/await will be stabilised around RustFest Barcelona. This talk gives an overview of the existing ecosystem by then as well as practical guidance on how to use the feature. It puts a focus on modern async programming instead of comparisons with the past. For exemplary purposes, I will use async-std, a library built from the ground up around std::futures::Future and the modern async model.

https://barcelona.rustfest.eu/sessions/async-await-with-async-std

A

Florian: okay, here we go.

A

Yes, so hello and welcome..

A

This is a very special talk to me, because that means I'm so out of organising this conference.

A

That they are letting me give talks,. So just as an illustration there.

A

So, who am I?? I'm florian,? You can find me on twitter and github..

A

I own two companies, one that has nothing to do with programming languages and the other.

A

One that does just rust many I do programme rust since 2013,. I do train it since 2015,.

A

And since then I am a team member.. I also formed a couple of community things., I'm part of the community team,. I founded this conference,. I founded another conference.

A

Based on embedded subjects,, so I have been active.

A

Today, I'm going to present the async-rs/async-std project and we decided.

A

To call it async-std because that's what it is., it is a port of the rust standard library into the async world.

A

It takes the whole interface of libstd or anything that might do thread blocking,. Then.

A

Puts it on top of an executor and the rest of the interface is based on the futures-rs.

A

Library,, which is the abstract interface for working with futures.

A

The futures trade that was stabilised within rust is a very,, very minimal one, to allow.

A

Libraries, on top of it,, write extensions to it..

A

It really has the bare minimum interface of this is what a future is and all the operations.

A

That you can do on top of them are provided by the futures-rs library.

A

Async-Std is not new..

A

The people who kicked it off were first of all, stjepan glavina, who is also known as the.

A

Maintainer of crossbeam and used to work on tokio, and yoshua who works on tide and surf.

A

It's a community project with a lot of the development nowadays being done by community.

A

Contributors., so why are we building async-std? first of all, stability.?

A

We believe that the rust async ecosystem has been in flux for far too long, and we don't.

A

Want to reiterate further., we want to collect the knowledge of the last few years and put it in a library in a stable.

A

Fashion that you can rely on.

A

ergonomics:, it should be easy and consistent to use, and we figured out that the standard.

A

Library interfaces aren't actually bad..

A

There is a lot of work that has already been done around ergonomics, so we have adopted.

A

Them, instead of coming up with our own again, again not doing research.

A

It should be accessible,, it comes with a book and full api docs. So we have extensive api.

A

Documentation. it fully integrates with the wider rust ecosystem,, mostly with futures-rs, which it uses as its.

A

Interface, and speed.

A

speed should come out of the box and we believe it's the best library to get started with.

A

Async/Await. I want to give a personal motivation to the first point.

A

As a trainer, I found it quite interesting that over the last two years I have seen more.

A

And more people not be interested in async, rust training,, particularly to the point where.

A

Last year, people have said:, can you just skip the async part??

A

We are not going to use this for the next two years..

A

This is too much in flux.. So this is the state we are in, just to be clear.

A

It has a couple of additional properties., it has a very small dependency tree.. It is not overly generic, which means it compiles fast and does not expose you to an end. Application,.

A

Or does not contribute to an end application that compiles from it.

A

Let's talk about async., so this is a synchronous, function.

A

It takes a path, returns, an io result, takes a file and by opening and reading it through.

A

A buffer, we provide the capability of doing this,, basically adding async-std,, but you.

A

Have to add the prelude, and then you put async in front of the function and every operation.

A

Here becomes an awaitable future operation,, so file open will notify you once it's done.

A

And then you can continue and the same goes for reading.

A

Yes, and yesterday someone, particularly pascal,, met me here and said: yes,. We used it internally.

A

And it really works that way. we took our code, put async on top of every sync port and it worked.

A

It exports all types necessary for async programming, including some types of standard library, type.

A

So if you are talking about io result here, that's the same result as the standard library.

A

Has., why are we doing this?? The standard library has the habit of at some points actually being subtly blocking, for.

A

Example, standard path: path has blocking function,, particularly that exists for metadata and.

A

All of these functions,, so if ever there's a type within async-std that is also in std,.

A

You should use the async.

A

But talking more about what async functions represent,, so this is a manual desugaring.

A

Of what the async keyword does., it does a little more.

A

For example,, it activates the compiler mode, in which, again, you are allowed to use, await.

A

Within a function block but, most importantly, it returns the return type of a function into.

A

Impl future item and the result that we have stated there.

A

That also gives an interesting insight in what those functions do.

A

They generate futures., they don't actually do work.. We will come back to what that means in a second.

A

But what does the await mean?.

A

The await means that, at all of these points, there's an operation where this task has to.

A

Wait for something to complete,, so it will indicate actively:. I register interest in.

A

A certain event, in the first case, I want to open a file,. Please tell me when you are.

A

Done., this is what await the active indication that you are waiting. For.

A

It's also called completion. Base,, so await is the moment where you wait for something.

A

If you call this function,, we get a nice compiler warning which is: futures do nothing unless.

A

You await, or poll them., that's what I mean by async. Functions are generating futures.

A

The return type of this is this is a future that will open this file.

A

It kind of moves the thinking in the future,, that's where the name comes, from.

A

You are asking for:, please set up my program so that it can now open this file and tell.

A

Me when you are done.

A

And what do you need to run? Them? futures run using a task, and that one is important.

A

There's multiple ways to get to a task.

A

Those mostly differentiate in blocking, non-blocking, blocking in the background I come to that.

A

In a second., the important thing is multiple futures can run in the same task. Currently.

A

Tasks themselves may run in parallel.

A

This is depending on the execution strategy.. I will come back to that in a couple of slides.

A

As a differential for this talk,, this is a really, really rough comparison, but concurrent.

A

Means multiple processes run in a group, yielding to each other when they need to wait,, usually.

A

Called corporate scheduling,, so any of those operations will go until they need to wait.

A

For something again and then actively indicate:, I'm waiting,, someone else can run.

A

While parallel means:, multiple of these things, run next to each other,, usually on multiple.

A

Threads., when we talk about blocking, in this case, blocking, sadly, as many it terms, is not.

A

Sharply defined, but for this presentation, when I say something blocks,, it is blocking.

A

The thread that it's currently on,, which means,, if you have additional concurrent tasks on.

A

This thread,, they will be blocked as well,, and that is a huge problem, and this is something.

A

To avoid., this is why we choose how to run our futures task.

A

This is the task block on interface in async-std.

A

You will pretty often see that in examples, for the reason. Yes, for the reason that.

A

You need to block the main thread, as the same goes for any kind of example, that does threading,.

A

You need to block the main thread to make sure that your program doesn't exit while.

A

Something runs in the background,, so all examples pretty often use task block on because the.

A

Definition of task block on is it blocks the thread you are currently on and instead runs.

A

The task that you are passing, so in this case, for example, reading the file.

A

The nice thing about block on is it actually gives you the results back like if you had.

A

Called a normal function. because you can do that,. You are completely blocking the thread until it's done and then.

A

You can collect the result and immediately put it into a variable.

A

The second interface is spawn.

A

spawn, runs a background task concurrently and waits for its completion.

A

Sorry, no,, it doesn't wait for its completion.

A

It gives you a joinhandle back and block on.

A

You can then call block on, on the joinhandle, blocking the main thread.

A

The semantics here are: spawn, spawns the future that does the operation and it gives you a.

A

Joinhandle back,, exactly like the threading api in the normal standard, library.

A

It gives you a joinhandle back that is in itself a future and the operation that this.

A

Future represents is:, wait for the background task and then take the result. Back.

A

But these are two different kinds of operations..

A

It's always important to understand. What is the thing that I'm actually waiting? For?.

A

In this case,, first of all, I'm waiting for the file to be read.

A

Second,, I'm waiting for the background task to complete.

A

Joinhandles, much like the joinhandles in the standard library, will give you the result.

A

Back,, the past result.

A

Joinhandles are similar to standard thread joinhandles..

A

They are allocated together with the task that they spawn in one go.

A

This is a single allocation and they also provide you a back channel to the spawner.

A

And the joinhandle resource.

A

there's a second function and I am mixing up my slides.

A

This should be spawn blocking up there..

A

It's a second function called spawn blocking.

A

The body is correct., this is the old standard lib api, so this is opening a file and the way the standard library.

A

Works is it will block the current thread until the file is opened, until the kernel.

A

Wakes up that thread again,, but spawn blocking, indicates through the runtime: by the way.

A

I am aware that there's blocking things in this task,, which will make the runtime put.

A

The task on a single thread on its own thread,, to avoid blocking other concurrent processes.

A

It behaves exactly the same., it gives you a joinhandle back,. So what is possible, for example, is having blocking.

A

And non-blocking tasks resulting in the same type of result,, mixing them,, for example, putting.

A

Them all in a vector and waiting for all of them, so our model unifies these things on.

A

The level of the spawn.

A

There's two patterns on futures that I would like to introduce: you,, the first being racing,.

A

The second being joining.

A

What does racing mean?

A

racing means? I take two operations and await for the first to complete.

A

As an example here,, I use the surf http client and I am trying to get the index of two mirrors,.

A

For example, and trying to work out which one answers fastest.

A

What I can do, then, is say: take the first future, race, with the second, await.

A

We will get the first back and the second will be dropped and removed and potentially.

A

The request aborted., so this is racing.

A

Sometimes in the futures crate, there is also a macro that will have similar behaviour, but.

A

Not quite,, but you may have seen that one.

A

What's important here, is, when we are talking about concurrency, where there's parallelism,.

A

These two are concurrent because I'm taking two of these, putting them on a concurrent.

A

Merging them into the same future, and then I'm run them both on the same task.

A

What I can also do is, I can spawn both of them,, which may run them in parallel, because.

A

Now the runtime is free to do so, and then race for the completion of the task.

A

So this means I will the spawner will say:, let's join the joinhandles together and wait.

A

For one of them to return,, so this is a similar kind of execution. Behaviour.

A

A different kind of execution, behaviour.

A

The next that I would like to present is joining.

A

joining is important in the sense of:. I have two operations and I want to execute them.

A

Both and I don't want to continue until they are both complete.

A

In this case, I want to make multiple requests to a backend, and I want to wait until the.

A

Outcome., the next concept I need to talk about is streams.

A

Streams are a fundamental abstraction around items arriving concurrently into any kind.

A

Of part of my programme.

A

in async-std, they take the place of the iterator trait, so basically, standard iterator is replaced.

A

By async-std stream, so they can be split,, merged,, iterated over,. All these kind of things.

A

The classic example that you will probably have seen if you have ever had a look at async.

A

Code is the tcplistener, so new connections are arriving to my program.

A

I don't know when,, I don't know how many and I don't know how many at once and streams.

A

Give you the ability to work on this one-by-one,, so the tcplistener on the standard lib has.

A

A sync liberator,: we have a sync incoming stream and in now rust, 1.39.0 the recommended.

A

Way of iterating over that is by calling incoming next, stream.next.

A

This is the future, because we don't know approximate, there's something there yet or if it might.

A

Come in the future, so this will lay the task sleeping until something is coming in and.

A

We are awaiting on it.

A

There's no integration into four loops currently in the language.

A

Then we spawn for each of those connections,. We spawn a concurrent task that works on them.

A

Process is some function that processes this.

A

One important operation on streams is merging them.

A

There's a couple of other operations,, but I could give a whole talk on streams.

A

Here is an example that listens both on an ipv4 and an ipv6 interface, so I can use two.

A

Tcplisteners, bind them,, get the incoming stream for both and then I say, ipv4 merge.

A

To ipv6 and then just continue because they are returning exactly the same things.

A

They are giving me a tcp socket with a tcp connection, so I can merge them and start iterating.

A

A

We have a sync module exactly like standard sync.

A

It comes with async/await, ready versions of standard lib, structures.

A

It is important to understand that a lot of standard lib structures,, if they put you waiting,,.

A

Like, for example, you are trying to lock a mutex,, they will lock the current thread.

A

What it gives you is, they will lay the current task. Waiting.

A

So it comes with mutex, barrier, read, write locks,, all that.

A

This is what the code looks. Like, almost exactly like the standard. Mutex example that you already.

A

Have. the example here ...

A

Wake me up when it's my go.

A

So it is important to use future aware data structures in future code.

A

One interesting thing is: we have the arc here,. This is just an export from the standard library.

A

To make sure that you don't have a mix of std and async-std types.

A

Almost all types that async-std exports are either exported because they have a relationship.

A

To another one, or because we need to make changes.

A

Arc is the small exception and we don't want people to be too confused by having these.

A

Small exceptions of maybe 1%, 2% of the interface.

A

We have a channel implementation,, async-std channels are based on crossbeam channels, but.

A

In an async version., they are multiple producer,, multiple consumer channels..

A

They are always bounded..

A

We think that unbounded channels are an anti-pattern..

A

You will run into problems with bounded anyways.

A

What that means is they can bounder channels can only hold a certain number of items at.

A

Once otherwise, trying to write into them will lay your task sleeping,, and they are very.

A

Fast. they are faster than crossbeam channels.. These are the ones used in servo in the browser.

A

Because they are multiple producer, multiple consumer channels,, they should cover all your.

A

Generic use cases,, so that also means they cover one-to-one,. They cover one-to-multiple,.

A

They cover multiple-to-one,, just by virtue of covering end to end.

A

Channels are currently unstable for api discussions., a little.. We want to fix that in the next a couple of weeks, so you need to activate the unstable.

A

Feature flag, if you want to play around with them.

A

As a short example,, they work much like the stuff that I introduced.

A

Specifically,, the receiving end of a channel is a stream,, so it can generically be seen.

A

As a stream,, so the while-at-some pattern applies.

A

If you send, sending becomes a future operation, because if the channel is full, you will have.

A

To wait until the channel has capacity.

A

This is a ping pong example of two tasks or two futures that will ping pong each other.

A

Through a channel, or through two channels,, and you spawn both of them and they will stop.

A

Playing ping pong until kingdom come.

A

Understanding tasks and streams, in my opinion, is far more important than understanding futures.

A

Because streams, channels and tasks are the things, tasks are the things that communicate.

A

Streams and channels, streams being the abstract version of channels,, not everything almost.

A

All channels are streams., not every stream is a channel..

A

Those are the things, how tasks communicate.

A

this is,. If you have a problem,, how do you get some piece of data from a to b between.

A

Two concurrent tasks?, the answer is almost always: use a channel.

A

So, even if you are talking about, I want to work on a futures-based system,. It is important.

A

That you have that in mind.

A

So as a summary,, async-std provides a known and familiar interface of the rust standard.

A

Library, with appropriate changes for async., it avoids pitfalls by providing a full api surface around all async-critical modules.

A

It is fully based on futures-rs, so it integrates through the ecosystem. Very well.

A

We fully embrace the futures-rs library, so if you want to use async-std in an abstract.

A

Fashion without relying on async-std types,, you can take a step up and rely on the futures-rs.

A

Interface traits.

A

because all types expose the relevant interfaces from futures-rs,, so futures,, obviously futures,.

A

But async-std streams are always also futures streams and everything that is read. Write,.

A

Async read, write, is also futures. Async read write.

A

If you want to have the full interface of futures-rs, then you can also, on top of that.

A

Load, a futures-rs library.

A

one note about the futures-rs library,. It has recently been rearchitected to a core.

A

And an util and a couple of additions and from core to util to some of the remote additions.

A

It becomes more experimental,, so when I say we export the futures-rs library, specifically.

A

We rely on the core types where we know that they are going to be stable and probably not.

A

Subject to churn.

A

But if you want to opt into any of the more experimental types, you can totally do so.

A

By just loading, the futures-rs library, on top and using it.

A

Particularly of interest are the async read, async write, async seek traits.

A

A lot of the criticism that we got is you are not compatible with the ecosystem,, particularly.

A

Like tokio., the problem, there is, a lot of libraries are written on top of tokio, which don't implement.

A

The futures async read, write, seek traits unless you use they use tokio,, which are.

A

Different, and also subject to change, making them incompatible with the rest of the ecosystem.

A

I think it's okay.

A

Their view on this is we still want to experiment on this, and we would like to iterate on that.

A

Interface,, but that very much collides with our view that we should get stuff stabilised.

A

And that we have researched those traits for three years, so addressing the common question.

A

Why async stood, it's pretty simple: fundamental mission, goal.

A

That's as deep as it is.

A

Our view and vision for using std is applications should use async-std directly because application.

A

Development is far less abstract.

A

You want to pick a couple of libraries, solving your needs, use them and then the abstraction.

A

Level is usually pretty low..

A

You want to get stuff done.

A

Libraries should use futures-rs as their interface.

A

As an example,, we have a tls library under our own organisation,, and this one operates.

A

Completely on top of async read and write,, but you can use it on all async-std tcp socket.

A

And so on, types that expose read and write, so to make this more concrete,. If you are.

A

In an application, it is okay to take an async-std net, tcp socket directly.

A

If you are in a library, I would highly recommend you to instead use futures, io async read so.

A

That doesn't expose users to your choice of base runtime.

A

Because there are other runtimes around,- and this is something there's currently a binary.

A

Discussion happening around async-std versus tokio.

A

I don't want to have this discussion because there's a number of executables in our ecosystem.

A

Particularly google fuchsia is a big one.

A

There's bass, I do not know.rs, which is: this thing, never crashes, under no conditions.

A

There's wasm-bindgen-futures, which is a particularly built executor for wasm, and there's a number.

A

Of company internal ones, that those companies sometimes speak about, but pretty rarely speak.

A

About in public.

A

and async-std is meant for writing compatible libraries,. So if you are writing a library.

A

You can use async-std as your test bed.

A

Probably you should avoid binding to it, directly,, which brings me to speed.

A

It's something we have been asked about: a lot.

A

There's a problem there.. We also believe there's a hyperfocus on benchmarks in the rust community, at the cost of ergonomics.

A

And barring stabilisation., the biggest problem with benchmarks is, they are often changing and we don't really want.

A

To be a part of the benchmark race, so probably I will present these benchmarks and in two.

A

Weeks, they will look very, very different and I don't believe you should choose software.

A

By benchmarks alone, which also doesn't mean you shouldn't factor it in.

A

On reading, async-std is 1.56 faster than tokio.

A

You can look at that repository.

A

That's only on reading a 256k file.

A

If your application has a different read, write behaviour, your benchmarks might be different.

A

There's a fair warning.: our mutex is fast, up to nine times, faster.

A

There is futures intrusive.

A

We are nine times as fast as the futures implementation at that.

A

This also gives an interesting insight of, should I use futures lock, mutex?.

A

These types are mostly implemented for making sure people can use them and run with them.

A

So these were for the implementation phase of futures and they are still shipped, so.

A

That people that rely on them can still use them..

A

They are good., they are just not built towards, they should be fast.

A

So this is mutexs on the contention so actually mutexs,, there's frequent locking.

A

There we are up to two times faster than the fastest one and we are the fastest one under.

A

Contention. mutexs without contention,, and that is interesting,, also have a speed task, so mutexs that are.

A

Rarely actually a challenge,, and there we are around roughly the same speed.

A

Why do I say the same speed?

A

when we run those benchmarks,? They are highly variant in the sense, the results will remain.

A

Clear. the implementations don't change spot but on the other hand, some of those numbers change.

A

Up and down. finally, how fast is task spawning?.

A

These are the tokio ten times benchmarks. we are as fast..

A

There is another benchmark where we are slower,. The channel ring benchmark that tests single.

A

Threaded executors, where you put up a number of nodes and connect them in a ring and then.

A

Send a message around as fast as possible: multiple times, and there we are 0.9 times.

A

Slower than tokio and roughly three times faster than actix.

B

Yes, notice, for risks and side effects of synthetic benchmark. Please consult your active.

A

Keynoter., it is an innovative space.. I want to mention that again.

A

joinhandles were built by async-std and already adopted by others.

A

Single allocation tasks were invented in async-std and adopted by others.

A

You can both innovate and commit to stability.

A

Be aware what you, which thread, should you use.

A

Our roadmap 1.0 will be released on monday,, so tomorrow,, which will be a stable release.

A

With all base functionality and runtime concerns.

A

ongoing, stabilisation of currently unstable library, api.

A

Most importantly, channels.

A

also designing features that make async-std usable without the runtime.

A

I think this is particularly interesting.. What, if I want all those features, but actually don't want the runtime?.

A

We want to provide additional libraries with similar guarantees, access, compatibility,.

A

One onus. and just to be clear,. It is clear that we will have 2.0 at some point because there's.

A

New language features arriving and some of those might lead to breaking interface, changes,.

A

Not only in base grades but, for example, there is an asynchronous four loop coming and that.

A

Might need some changes to integrate well with that and when these changes are coming.

A

Down the line we will release 2.0 plus update guides on how to do that.

A

We would like you to hack with us in the next few days, so getting started. Writing more.

A

Libraries, on top or porting libraries to work with multiple executors.

A

We want you to challenge our benchmarks, because all benchmarks are wrong, and let's figure.

A

Out how., if you want,, we can get started, writing an application and we would like to get a lot.

A

Of feedback on our unstable api because we want to stabilise,, and that means we need.

A

A couple of ibots. finally, async-std is currently completely funded by ferrous systems and we have started.

A

Offsetting for all those projects., we are also hosting rust, analyser and open collective. So if you agree with all those.

A

Goals and would like to give us some more time to work on it, thank you.

A

Thank you,, florian.

B

We have time for two questions.

B

hands, please? hello,. Thank you for the great talk.

B

Do you think there are ever any use cases in which tokio should be preferred to async.

A

Standard? florian: sure. no, seriously,, there's at least six executors that I know of around,, all of them with different.

A

Tuning settings, different kinds of apis,, so yes, there's reasons for all of them.

A

Tokio currently has a better api for fine grain control of placing of a runtime which.

A

Is a very, very detailed thing to do and needs a lot of knowledge on how to actually place.

A

Runtimes correctly- and this is something that we currently don't provide at all.

A

So, yes, definitely.

B

You mentioned that racing and selecting aren't quite the same thing.

B

Could you elaborate on that?, florian: [laughing], so the select macro of the futures crate is a pretty, pretty big.

A

Beast that works on top of a library called proc-macro-hack which implements by itself.

A

A way of doing basically implements its own match statement along with two different.

A

Kinds of operations, how to react to an event happening on each of the branches.

A

So yes,, what I was hinting at is this select in rust, isn't a very well-defined term, while.

A

Racing is pretty clearly:, there's two futures giving you the same results and that's also.

A

The other thing., the select macro in the futures crate, allows you to use two futures that return different.

A

Kinds of results and react differently on whether the one resolves or the other one.

A

Resolves where racing is:? I expect the same back and I wait for the first.

A

So it's a vastly simpler operation.

A

Thank you,, florian.