9 ms·
Announcing Rust 1.27
- computerphage 8y agoThe new syntax for dynamically-dispatched traits, “dyn Trait”, is an example of Rust’s persistently excellent consideration of what should be explicit and what should be implicit. Python’s mantra of “explicit is better than Implicit” mostly captures my general feeling, but you can’t make everything explicit. Back before impl Trait existed, just Box<Trait> seemed very clear. Now that there’s an important thing to differentiate it from, it seems better to have dyn Trait and impl Trait both prefixed with keywords. It also makes for much easier googling. ;)
- kbd 8y ago> Rust’s trait object syntax is one that we ultimately regret. Would someone please explain the problem (and the solution) for someone who doesn't know Rust yet?
- the_mitsuhiko 8y agoThis thread explains it quite well: https://www.reddit.com/r/rust/comments/8sqiin/newbie_question_why_is_the_impl_and_dyn_in_the/ https://www.reddit.com/r/rust/comments/8sqiin/newbie_questio...
- steveklabnik 8y agoThe linked thread is good, but the short answer: Box<Foo> If Foo is a struct, this is a single pointer to the heap. If Foo is a trait, this is a double pointer: a pointer to the data on the heap, and a pointer to a vtable for its methods. These two things are very different, but look similar. That's the mistake. This change separates the two. Now: Box<dyn Foo> is always the latter, a "trait object". We have to keep the old syntax working for stability reasons, but can lint against it, so that it nudges you into the better syntax. So in this world, // always a single pointer to a struct (or enum) Box<Foo> // always a double pointer Box<dyn Foo> This is more clear for humans. The compiler can tell with 100% fidelity, of course. But humans aren't compilers. Different things with different costs look different. As an addendum, the parent mentions another feature, "impl Trait", which can be used with traits. Their point was, originally, Box<Trait> was the only thing that existed like this. With "impl Trait", it was "impl Trait" vs "Trait", and is now "impl Trait" vs "dyn Trait", which is much more clear, at least in many people's opinions. :)
- KwanEsq 8y ago>We have to keep the old syntax working for stability reasons Will Rust 2018 enable you to remove the old syntax? Or is that a bigger change than the opt-in is allowed to cover?
- db48x 8y agoYes, the next edition will allow breaking changes, while still allowing you to use crates written in the older edition.
- steveklabnik 8y agosome forms of breaking changes. This is of that kind, though we cannot make arbitrary ones.
- steveklabnik 8y agoThis kind of change is the kind an edition can make, though I’m not 100% sure if the plan for 2018 is to warn or error on the older syntax.
- lewisinc 8y agoI feel like a warning for one edition and error on the next would make it straightforward as to how much time is left to update the code.
- steveklabnik 8y agoThat’s generally true, the question is, do you warn in 2015 or 2018? That being said, this particular fix is 100% automatable, and rustfix can already do it, so the time to update is “a few seconds”.
- dikaiosune 8y agoRust's built-in lints are configurable with compiler directives, so you'll be able to add #![deny(bare_trait_objects)] To the top of your crate and cause a compiler warning if someone uses the old syntax on your project. EDIT: just realized I mis-parsed "you" in parent. Oh well.
- algesten 8y agoA trait is like an interface. A struct implementing a trait means it takes on the methods of that interface (but there's more to it, because a trait can have default implementations of of the trait methods). If you want to express something like "this is a variable that holds something that fulfils this trait", without knowing the _actual_ type it is, that variable effectively has an unknown runtime size. std::io::Read is an interface for reading bytes of some source, like a file or a socket. This matters because we're talking about a stack frame. So the size needs to be known at compile time. let a: u64 = 42; // ok, because well known size. let b: Read = ...; // illegal, because unknown size. A "trait object" places the object on the heap and has a pointer in its place. let b: Box<Read> = ... // legal, because pointer is a known size However it's a bit more complicated, because this syntax allows for dynamic dispatch at runtime using a vtable. So there's a quite big difference between Box<u64> (a 64 bit unsigned integer on the heap) vs Box<Read> (a runtime dispatched lookup via a vtable). This difference is not obvious at a glance though. Hence the new syntax: Box<dyn Read>. (I think I got that right)
- steveklabnik 8y agoYou did, except that it’s not one pointer, it’s two. This is one way that rust is different than C++; the vtable isn’t stored with the data, but separately, with the “trait object” itself being two pointers to the two things.
- algesten 8y agoGood to know!
- tzahola 8y ago>This is one way that rust is different than C++; the vtable isn’t stored with the data Which “data” is the vtable stored with in C++? An object contains only a pointer to its vtable, not the vtable itself...
- steveklabnik 8y agoMy understanding is that, generally (because (again in my understanding) this is all compiler-specific, not mandated by the standard) is that in C++, there's a single pointer that points to the combo of the vtable and then the data, after it. See http://www.drdobbs.com/cpp/storage-layout-of-polymorphic-objects/240012098 http://www.drdobbs.com/cpp/storage-layout-of-polymorphic-obj... for example. While a Shape is a position, outline, and fill, if you have virtual functions, the pointer points to a vtable pointer, and then all of the data. In other words, in Rust, a pointer to a shape is (pointer to vtable, pointer to data) whereas, in C++, a pointer to a shape is (pointer to shape) where shape is (pointer to vtable, data) If that's incorrect, I'm quite happy to be corrected! This isn't an area I'm an expert in.
- weavie 8y agoReading up an static vs dynamic dispatch may help - https://en.wikipedia.org/wiki/Dynamic_dispatch https://en.wikipedia.org/wiki/Dynamic_dispatch. Essentially Box<Foo> is static dispatch. You know at compile time which exact methods you are going to call. Box<dyn Foo> is dynamic dispatch. Since Foo is a trait, at compile time you won't know which methods are called, it depends on the type of the object passed in (as long is it implements the Foo trait).
- TheCycoONE 8y agoYour example is misleading. If Foo is a trait Box<Foo> and Box<dyn Foo> are the same thing. Impl Foo is for static dispatch. Illustrating the need to dump the old unqualified syntax.
- weavie 8y agoAh ok, I'm back to being confused again then! Is this right: If Foo is a struct then Box<Foo> is static dispatch. If Foo is a trait Box<dyn Foo> is dynamic dispatch, but then so is Box<Foo> - but that is the regrettable point. So from now on, if Foo is a trait we should be writing Box<dyn Foo>, which is largely syntactic sugar to make the situation more clear? I don't fully understand what the release notes are saying about using impl Trait. When would you use Box<impl Foo> vs Box<dyn Foo>?
- steveklabnik 8y agoYou are right. It’s not that you would use Box<impl Foo>, but when taking about the two features, it’s easier to compare them, as they’re actually distinct syntactically.
- weavie 8y agoThankyou.
- sametmax 8y agoPython is my goto language but let's not forget it disrespects it's own mantra very often. Like a certain pirate would say, "it's more what you call a guideline than actual rules". Duck typing is implicit interface. Foo().bar() is an implicit Foo.bar(Bar()) as self is only explicit on declaration, not call. __init__ is called and passed parameters implicitly. __new__ is an implicit class method. Some time the magic is nice to have. Sometime it's like yield. Yield implicitly turns your function into a very different object, which makes everybody goes wtf the few first times. They fixed that with async / await, but I still wish we had a "gen def" to allow yield in bodies, like we have "async def".
- computerphage 8y agoSIMD on stable is very exciting news. SIMD unlocks the power of the GPU-esque parallelism that is already inside your CPU. While compilers do try very hard to take advantage of this automatically, it’s not always predictable and can make performance fragile. This is what people are talking about when they refer to “low level control”. Don’t expect that with Rust 1.27 you’ll need to understand SIMD to get anything done. Do expect various libraries to just get faster on stable. For example, BurntSushi, the author of the regex crate and the ripgrep tool, has already enabled it if you’re on Rust 1.27 Stable. [1] SIMD is another notch towards never needing to use nightly Rust. What this really looks like in practice is that less frequently will a user encounter a fast-mode and a slow-mode for a crate depending on whether they’re using nightly, with all the unstable features enabled, or not. [1] https://github.com/rust-lang/regex/pull/490 https://github.com/rust-lang/regex/pull/490
- seanmcdirmid 8y agoHow useful is SIMD on CPU these days given that most of the touted original applications (back in the MMX SSE days) have been moved over to GPUs?
- vvanders 8y agoStill really useful. We use NEON on Android all the time since there's not a great API there and spinning up a GPU on a mobile device is not something you want to do unless you absolutely have to.
- flipgimble 8y agoI don't want to worry you, but on a mobile device with a screen the GPU is always spinning. That is where the pixels come from after all. I get your point that there are energy efficiency tradeoffs to consider. However for massively data parallel tasks like image operations, 3d graphics, machine learning, vision etc, I haven't seen SIMD implementation come close to GPU compute in terms of efficiency. Perhaps short lived text pressing and file compression where data access is more random could benefit from SIMD.
- eberkund 8y agoYes!! I have been waiting for the new time helpers to arrive in stable. It may be a small thing but is so much nicer and makes Rust feel more like a higher level language when I can do `some_time.subsec_millis()` rather than `some_time.subsec_nanos() / 1_000_000`.
- AndrewGaspar 8y agoHeh, was just bemoaning this two days ago. Glad I can use them now.
- oddity 8y agoI don't understand your comment. It feels like a higher level language because you can use a different unit for measuring time?
- pimeys 8y agoHaving written enough of boilerplate to do millisecond timestamps, or including a quite big chrono library for a nicer interface for a few time operations, these additions are quite luxurious.
- kibwen 8y agoSIMD! For anyone curious about the performance impact of this feature and a real-world implementation, check out the PR adding support to the regex library: https://github.com/rust-lang/regex/pull/456 https://github.com/rust-lang/regex/pull/456
- burntsushi 8y agoAnd just because this kind of thing is fun, if you use the right kind of pattern on a big enough file, SIMD can be quite noticeable: $ rg-with-simd --version ripgrep 0.8.1 (rev 223d7d9846) +SIMD +AVX $ rg-without-simd --version ripgrep 0.8.1 -SIMD -AVX $ time cat OpenSubtitles2016.raw.en > /dev/null real 0m1.280s user 0m0.020s sys 0m1.257s $ time wc -l OpenSubtitles2016.raw.en 336602465 OpenSubtitles2016.raw.en real 0m4.303s user 0m3.132s sys 0m1.167s $ time rg-with-simd -c 'Sherlock Holmes|John Watson|Professor Moriarty' OpenSubtitles2016.raw.en 6033 real 0m2.099s user 0m1.750s sys 0m0.347s $ time rg-without-simd -c 'Sherlock Holmes|John Watson|Professor Moriarty' OpenSubtitles2016.raw.en 6033 real 0m4.128s user 0m3.781s sys 0m0.343s $ time rg-with-simd -c 'Sherlock Holmes|John Watson|Irene Adler|Inspector Lestrade|Professor Moriarty' OpenSubtitles2016.raw.en 6731 real 0m1.989s user 0m1.621s sys 0m0.366s $ time rg-without-simd -c 'Sherlock Holmes|John Watson|Irene Adler|Inspector Lestrade|Professor Moriarty' OpenSubtitles2016.raw.en 6731 real 0m18.417s user 0m18.000s sys 0m0.403s Looks like `cat` is still faster, so there's some room for improvement. ;-) With a single pattern, we're almost there: $ time rg -c 'Sherlock Holmes' OpenSubtitles2016.raw.en 5107 real 0m1.333s user 0m0.974s sys 0m0.357s This one is mostly thanks to glibc's memchr implementation (which uses SIMD of course), and the regex crate's frequency based searcher. Of course, I'm presenting best cases here. Plenty of inputs can make ripgrep run quite a bit more slowly than what's shown here! The crazy thing is that we're still only barely scratching the surface. Check out Intel's Hyperscan project for some truly next level SIMD use in regex searching!
- vvanders 8y agoUf da, that's still some good speedups. BTW as a happy daily user of rg thanks for all the work you put into it, definitely shows.
- harry8 8y agoAnyone happen to know when inline asm will hit stable?
- steveklabnik 8y agoNot slated any time soon. There are major questions about the approach; the current implementation is "do whatever LLVM does" which is not in itself stable, and so cannot be our final implementation.
- harry8 8y agoclang manages with "Do whatever gcc does" I wonder why that isn't good enough. Doing nothing useful now as we might want to do something more useful later than what we can now seems a bit self defeating, but I may be missing the point because I want to us inline assembly language in unsafe blocks.
- roblabla 8y agoThe problem is, rust has stability guarantees to uphold. As such, depending on the unstable behavior of an upstream component is not possible in the stable branch of rust. Furthermore, there are worries that depending on the llvm behavior might impede work on alternative rust backends, such as cretonne.
- dbaupp 8y agoClang isn't using LLVM's inline asm directly, it translates from the (stable) GCC format into the internal LLVM one. rustc could theoretically do the same translation, but implementing that is significantly more work than just stabilizing the current implementation of asm!().
- simias 8y agoThat and GCC's format is not exactly great. I'm generally looking unfavorably towards NIH but in this instance I really hope they figure out something better.
- rl3 8y agoAny idea what SIMD in Rust via WebAssembly will look like?
- steveklabnik 8y agoWasm doesn’t support SIMD yet, so no way to tell.
- rl3 8y agoThanks, wasn't able to easily discern how far along the browser SIMD wasm implementations were. Do you see a future where wasm has its own std::arch module?
- steveklabnik 8y agoYeah, SIMD is on the wasm roadmap; we’ll see what form that takes for exact details, but that’s what I’d expect.