ฝัง
- เผยแพร่เมื่อ 1 มิ.ย. 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
![โอ้มายก๊อด! ไม่ถึงชั่วโมงหมดเป็นแสน 😅 [cc] แดนแพทตี้ SS2 | EP.42 |](http://i.ytimg.com/vi/OH2ShXfO6tA/mqdefault.jpg)
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!
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)]`
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
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! :)
*UPDATE: This video is re-uploaded with a better audio here* th-cam.com/video/7_o-YRxf_cc/w-d-xo.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
Incredible explanation, it makes it so much easier to understand compiler errors when you have this video and memory mapping in mind. Thanks !
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!
Wow, I really love this. Nice refresher of multiple topics even for someone who is intermediate-advanced rust user.
A nice overview and/or refresher.
This is awesome! I didn't know that I needed this that badly! Thanks for sharing this great work!
Nice work! Hope to see more Rust videos from you.
Extremly well delivered information with not a single wasted second. Very good work!
I was confused about box, rc, and arc until now. Thanks!
The best video on vtable , Smart pointers, trait object..Awesome job. Thanks
Definitely the best Rust video on TH-cam. I will keep this video and watch again and again! 감사합니다🙏
Hats off for making everything clear🙌 You're extremely talented. You're able to explain things logically by providing reasons. Thanks❤️
Jesus Christ. This is so awesome explanation. Thanks to you I can be now understanding how stack and heap grows up
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
Very useful and nice depiction of memory layout of each data type. It should be placed right inside the documentation
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.
This video will remain as the best go-to video for new rustaceans! Excellent work Sreekanth!!!
Thanks for this. It is brilliant!
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
Visualization helps a lot, thanks!
This is very clear and great explanation on rust memory management. thanks for the explanations
very informative! thank you
Your video helped me a lot. Thank you.
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.
This video is gold. Thanks for the hard work!
Rust is the way forward and this is a great piece of work. Thanks.
Dude, amazing work! Just amazing
Wonderful. So thorough.
This video help me understand rust memory a lot , thanks ~
Great explanation! Thanks
thank you for sharing knowledge. appreciate the effort.
This is gold! Thank you.
Thank you! this was very helpful.
very good and clear
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 TH-cam but only a few like this, are actually understandable by novice Rustaceans.
finally I've understood strings in rust. thank you a lot!
This is gold! Congrats :)
Thank you man for sharing this stuff
Enlightening! Thank you!
Amazing video! Would be awesome if you made more videos like this for Rust
Wow, honestly incredible
Such wisdom, oh great one.
awesome explanation 👏👏👏👏👏
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.
Amazing video thanks.
bruh I loved this video. thanks for your great content.
extremely well done video!
love to learn thanks for sharing
This is golden, thanks!
great work, very helpful for me
need more videos like this
Thank you Sreekanth. Coming from a C background, this really helped me understand what Rust is about.
This is exactly i want. Thank you!
This is worth more than some of computer arch classes at university.👍
Awesome explaination
This is so useful! Thanks
good stuff, thank you very much
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 a lot, this makes learning Rust a lot easier. The less magic the better.
the best introduction has ever seen.
This video is beautiful
24:30 The malloc implementation will have some overhead (at least 8 bytes) in managing the extra heap allocation.
The best video!!! Thnx
I recently started with rust and holy shit i can'ttell how helpful this was
Thanks!!! Your video is too good
18:50 Couldn't the compiler get the size for a slice from it's initializer? It should know the size is 2 if I say 0..2. It's something like `constexpr` in C++.
This makes so much more sense! Could you please cover RefCell?
That was very useful 👍
this is the best video I have ever watched on youtube
We rustacean loved it! you should create more videos about rust, like this one!
I cannot thank you enough 🙏
This is high quality stuff!
This is the best explain to Rust
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
just beca a subscriber keep up the good work Sir.
Great ty ty
Super! Thanks
thank you for this
love it help me a lot i hope you do cargo next!
@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 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?
holy shit this was amazing
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.
thanks
awesome, cool
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.
19:54, I wish that proper memory visualizations were given for string and str as they are not represented in memory the same way.
Why the Array(Vec) variant of the Data enum is stored in stack if in the Vector section of the video it was explained that Vectors were stored in the heap so they can grow.
The three elements that constitute the Vec header (pointer to data, length and capacity) are stored on the stack. The Vec elements will be stored in the heap.
@@sreekanthpr thank you!!!!, I watched that section again and now I understood it better. I loved this visual explanation, everyone else does it with charts and words, but having it visually explained like you did totally improves and easies the understanding of these abstractions. Again, thank you!
you are brilliant ser :)))))))))))))
O Captain! My Captain! Are you going to publish a book? I think we need more lectures for memory dynamics.
why does the kernel add some paddings in memory when storing enums. I know it's to have the same size for every enum type. but why do we have to have the same size?
so freakin good
possibly the single most based rust video on yt
It is a cool video. Not only for Rustaceans.