Visualizing memory layout of Rust's data types [See description/first comment]
HTML-код
- Опубликовано: 6 июн 2024
- UPDATE: This video is re-uploaded with a better audio here • Visualizing memory lay...
Covers how a binary is executed, what segments are mapped to memory, the purpose/working of stack and heap memory, and how values of Rust's data types are laid out in memory. The data types that we cover here are integers, char, Vector, slice, String, string slice, structs, enums, smart pointers like Box, Rc, Arc, Trait object and Fn traits like FnOnce, FnMut and Fn.
We also cover the difference between String and str types, Vector and slice types. Topics like fat pointers, optimizations done by the Rust compiler when you wrap a reference inside an Option are also covered.
0:00 Segments in a binary
3:14 Stack & Heap
5:46 CPU Word size
7:08 Working of stack memory
10:25 working of Heap memory
14:00 Integer data types
14:30 char
15:15 size_of & align_of
15:51 Reference
16:58 Array
17:21 Vector
18:19 Slice of T
19:54 String, str, &str
21:17 Struct
22:14 Enum
24:14 Box pointer
24:51 Optimizations on Option
26:34 Copy Vs Move
29:21 Rc pointer
30:45 Send vs Sync traits
31:00 Why RC is neither Send nor Sync
31:24 Arc
32:19 Trait object
34:20 Function pointer
34:37 Closures
Life of an async fn: • RustFest Barcelona - T...
stack & heap / virtual address space:
lwn.net/Articles/738975/
docs.microsoft.com/en-us/wind...
Book: Programming Rust by Jason Orendorff, Jim Blandy, and Leonora F.S. Tindall
This solved lots of misunderstandings I had about Rust. It should be placed right in the documentation of the language (at least a link, so one could find it easily and early on the rust book)
Maybe the ownership is different, but everything else is school thing explained here.
@@MrEnsiferum77 could you point me to a program or a book where theese things are taught to people?
This was extremely enlightening in visualizing rust's memory model. Thank you for taking the time to create this!
This is not just a great video for Rust developers, but a great introduction for all developers into the process' memory layout and workings of the operating system!
Fax
Just remember about the memory layout of things like structs. You CANNOT rely on the memory layout or ordering of fields to be a certain way, as it's not defined how it will end up. If you need to rely on this, you need to use things like `#[repr(C)]`.
In fact, not even the tuple struct's memory layout is guaranteed. To guarantee it, you would need to use `#[repr(transparent)]`
*UPDATE: This video is re-uploaded with a better audio here* ruclips.net/video/7_o-YRxf_cc/видео.html
Corrections:
* 6:10, it should be 2^64 - 1 (without parenthesis)
* Trait is dynamically sized. Trait object has known size.
28:22 this isn't precise. Gargabe collection (as in JS, Go or Java) does not keep track of refernces. In its cleanup run GC just checks wether there is a reference to this memory or not and after it is finished it forgets about it. Your description fits more to automatic reference counting used by Objective-C and Swift.
by which software are the pictures drawn?
@@shumudu5377 For this video, I used Powerpoint. For all other videos in this channel, I use manim library (Python).
at 28:10, I suppose the indices should be 0, 1, 2 instead of 0, 2, 3.
btw great video, thanks you ❤
* trait objects are dynamically sized types, meaning that their size is known at runtime.
Pointer types to trait objects are sized at compile-time but have twice the size of pointers to sized types.
Correct me if i got something wrong
I was looking for info on dynamically sized types, but I found so much more in the video. One of the clearest explanations for such confusing concepts in Rust. Great video!
Incredible explanation, it makes it so much easier to understand compiler errors when you have this video and memory mapping in mind. Thanks !
This is awesome! I didn't know that I needed this that badly! Thanks for sharing this great work!
Wow, I really love this. Nice refresher of multiple topics even for someone who is intermediate-advanced rust user.
Hats off for making everything clear🙌 You're extremely talented. You're able to explain things logically by providing reasons. Thanks❤️
Extremly well delivered information with not a single wasted second. Very good work!
Definitely the best Rust video on RUclips. I will keep this video and watch again and again! 감사합니다🙏
This video will remain as the best go-to video for new rustaceans! Excellent work Sreekanth!!!
The best video on vtable , Smart pointers, trait object..Awesome job. Thanks
A nice overview and/or refresher.
Thanks for this. It is brilliant!
I was confused about box, rc, and arc until now. Thanks!
Nice work! Hope to see more Rust videos from you.
This video is gold. Thanks for the hard work!
Genuinely, thank you SO much for this video. I was banging my head against a wall trying to PRECISELY understand fat pointers, why str is a primitive type, and other low-level questions
Dude, amazing work! Just amazing
This is gold! Congrats :)
Beautiful, I'd consider the topics covered here to be required knowledge, and the video is a nice way to present things that can be difficult to visualize.
Great explanation. Love to see more such deep dive video about Rust.
Rust is the way forward and this is a great piece of work. Thanks.
This is gold! Thank you.
Very useful and nice depiction of memory layout of each data type. It should be placed right inside the documentation
Jesus Christ. This is so awesome explanation. Thanks to you I can be now understanding how stack and heap grows up
finally I've understood strings in rust. thank you a lot!
This is very clear and great explanation on rust memory management. thanks for the explanations
Wow, honestly incredible
Easy to understand video for complex concepts. Thanks for sharing.
It would be awesome if you put more Rust-related videos with the same level of explanation. IMHO there are a lot of videos of Rust internals available on RUclips but only a few like this, are actually understandable by novice Rustaceans.
extremely well done video!
This is golden, thanks!
Great lecture, but in the future, consider asking a friend to narrate! I know a lot of people don’t like posting themselves online, but many people would probably be happy to help out! :)
Thank you! this was very helpful.
Great video. I wanted to check out Rust for use in userspace applications, however the types seemed too high level and convoluted to me, since I primarily program in C. This video helped visualize the types and allows me to think of them in a more familiar C like way and visualize them in memory. I feel like every languages needs videos like this, as it makes mechanisms within the language more explicit and easy to understand in simpler terms.
Enlightening! Thank you!
Great explanation! Thanks
Such wisdom, oh great one.
Thank you man for sharing this stuff
Wonderful. So thorough.
Thank a lot, this makes learning Rust a lot easier. The less magic the better.
bruh I loved this video. thanks for your great content.
this is the best video I have ever watched on youtube
thank you for sharing knowledge. appreciate the effort.
This is high quality stuff!
Your video helped me a lot. Thank you.
This is so useful! Thanks
Visualization helps a lot, thanks!
This video help me understand rust memory a lot , thanks ~
This video is beautiful
This is exactly i want. Thank you!
Thank you Sreekanth. Coming from a C background, this really helped me understand what Rust is about.
Amazing video! Would be awesome if you made more videos like this for Rust
very informative! thank you
the best introduction has ever seen.
great work, very helpful for me
That was very useful 👍
Thanks!!! Your video is too good
damn i cannot imagine its the day that i will truly understand how memory handled by kernel and OS, just by clicking video about RUST HAHHAA
I recently started with rust and holy shit i can'ttell how helpful this was
Bro this was so cool, loved the video even tho it was with an AI voice, usually dont like those but the content was NOICE
Amazing video thanks.
Awesome explaination
We rustacean loved it! you should create more videos about rust, like this one!
The best video!!! Thnx
very good and clear
This is worth more than some of computer arch classes at university.👍
love to learn thanks for sharing
need more videos like this
This makes so much more sense! Could you please cover RefCell?
good stuff, thank you very much
I cannot thank you enough 🙏
awesome explanation 👏👏👏👏👏
this is the best memory video ever made. I downloaded it because of fear to lose it if youtube servers shut down or volcano, earthquake, meteor or something... lifesaving enum memory tip @23:55
thank you for this
Super! Thanks
love it help me a lot i hope you do cargo next!
This is the best explain to Rust
24:30 The malloc implementation will have some overhead (at least 8 bytes) in managing the extra heap allocation.
holy shit this was amazing
The mention of "malloc" made me think of the assertions around self-compiled language aspects, something I first remember hearing about with Pascal, then C. I presume then this does not include the libc and some other libraries, or perhaps just not always. I guess if it is a clang compilation, by implication, it's not self-compiled, so perhaps the assertion is it is self-compiled in some environments, or that some copies are self-compiled, or that the core of the compiler is self-compiled, but not all the libraries it uses.
just beca a subscriber keep up the good work Sir.
you are brilliant ser :)))))))))))))
Is it possible to make borrow-checker to take care of individual structure fields? I mean I want to pass the whole structure mutable reference in/out for functions, but to make the borrow-checker to care about what fields has been modified. Is it?
so freakin good
awesome, cool
Great ty ty
Awesome
thanks
Great video, thanks!
At 6:10, there is an error for the address range. The caption reads 2^(64-1), which is incorrect, as it implies 2^63 because of the parenthesis. The parens either needs to be removed, or put around the exponent to be correct.
Thank you. Happened during the final subtitle edits. It was written in words for generating the sound in the original text.
Very good
@15:47 Anyone know if the "padding" memory used up will have an effect when loaded into a cpu cache. Does it get condensed when loaded to cpu, or is the padding still there (taking up extra cpu cache)?
Is this documented somewhere? Where did you find the info to make the video? Awesome video by the way.
Rust specific things are mostly from the book "Programming Rust" (mentioned in video description)
O Captain! My Captain! Are you going to publish a book? I think we need more lectures for memory dynamics.
Great watch so far.
Questions @8:45 shouldn't the main stack frame allocate the `b` variable before entering the `add_one` function?
yes
In practice, yes. But really, no, it's not necessary. The compiler can even decide to reuse the space previously used by `a`. Because at that point, `a` is no longer used.
can u upload same kind of video for cpp r/l values / move semantics?
Thanks!
What tts do you use?
Microsoft one note >> View >> Immersive reader
Could you put it in the video description of what NTTS model/engine you are using to dub this amazing video?
I use Microsoft onenote/word >> View >> Immersive Reader