"We want to have control over our memory and that is how we get performance."
"Everything concrete, everything that allocates memory, everything you can toss around is an object."
"Let's don't return a pointer, return a smart pointer or at the very least, leave yourself an actual in-code compilable real note that you have to clean it up."
"The garbage collector has it easy, somebody else has to tell us where the pointers are."
"Instead of passing copies of the variables, you pass pointers to their addresses."
"So let's consider the stack in the context of swap and what's really happening here."
"Malloc is for memory allocation. It's a function that you can use to ask the operating system, MacOS, Linux, Windows, anything, for some number of bytes, 1 byte, 100 bytes, a gigabyte of memory."
"Memory is like a bunch of boxes storing data at addresses."
"I think I'd put that memory away a little bit, oh yeah, okay. No, for reals, for reals."
"There is only one copy of a static member in memory, no matter how many objects you create."
"And that's a quick look at memories in iOS 10."
"If you only remember one thing from tonight, don't synchronize on concurrent collections."
"Learning what to forget, what to remember, and what to pay attention to."
"Memory was limited, so standardizing the size of data types like ints and chars provided benefits."
"Reformat your card every time you start a new photoshoot."
"Mojo takes one step further instead of waiting until the end scope, it frees memory on the last use of the object."
"Human suffering is essentially a consequence of your inability to handle your memory."
"Memory is strictly managed. Unproductive ones must be eliminated."
"It's good practice to release your variables as soon as you finish with them."
"Does Apple's unified memory absolutely destroy its Windows competition? Well, today we will find out once and for all with this ultimate multitasking RAM."
"Smart pointers have been introduced to imply the concept of ownership of memory."
"As a programmer, I've not really had to think about deleting and cleaning up my own memory, it does it for me."
"The memory VRM on this thing is actually significantly better than on the Hall of Fame."
"Structured concurrency reduces the chances of creating memory leaks."
"Each vertex in a chunk is only four bytes long to make the game as memory efficient as possible."
"Basically a pointer just refers to a memory relocation for a variable."
"So there's this really neat feature that's built into the Samsung galaxy S twenty-two that allows you to utilize storage on your phone for additional amounts of RAM."
"It's okay to forget; you have a lot to keep track of as a dungeon master in your game."
"Why have the same library in memory more than once?"
"Given 4 gigabytes, you can figure out how many requests, replication groups, and table information can be held in memory of a request manager."
"It's okay to forget things; just remember to prioritize and manage your time effectively."
"They have the main context, which is analogous to main memory, physical memory, RAM."
"And another function that's available to you is kind which is going to return the number of bytes for each of our types."
"Your brain kind of puts everything in short-term memory and then decides what's important enough to put in long-term memory afterwards..."
"The stack memory on a modern program is like way more memory than you had on this whole computer."
"Pointer is a very fundamental and important concept in programming."
"Pointers are variables that store the address of another variable."
"Managing the Heap is considerably more complex than managing the stack."
"The Heap can be your best ally if you use it with responsibility."
"Memory is finite, so what do we do if all the memory is already in use by other programs?"
"Garbage collection in Java automatically frees memory by removing unused objects."
"Instead of just being able to store it as a pointer, we now have to use this mysterious number two."
"So how that would work is basically the garbage collector keeps track of any type of new object that gets created and then basically it checks now it's more complicated than this but it just keeps a reference of you know how many variables are pointing to this object."
"Automatic reference counting is Apple's way of handling memory management of objects."
"Always use Smart pointers to represent ownership."
"Pass unique pointers by value and return unique pointers by value to transfer ownership between functions."
"Weak pointers are useful for caching."
"Weak pointers can help with the dangling reference problem."
"Unique pointer owns the memory that it points to, in fact, it assumes it has exclusive ownership or unique ownership of that memory."
"Unique pointer is very useful for implementing RAII (Resource Acquisition Is Initialization)."
"Smart pointers drastically simplify memory management because the programmer doesn't have to manually free, delete, or retire things."
"Malloc is returning the address of that chunk of memory, not the last address."
"Dynamic memory allocation is where we want to have some chunk of memory that's allocated at runtime."
"Proper memory management is critical to achieving performance and shipping titles."
"Rust's ownership rules ensure that memory is automatically cleaned up without the need of a garbage collector."
"With this fundamental understanding of memory management in Rust, you're well set up for the rest of your Rust Learning Journey."
"Memory is a resource. It's the perfect copilot, but you don't want it in the driver's seat."
"Ownership features can help developers fine-tune memory management behavior and performance-critical code."
"We want our language to be garbage collected."
"I'm dumb and I wanted to include a small 10 gig switch just for my limited 10 gig devices."
"In practice, if you're writing software in C, which many things are still written in C and probably will continue to be written in C for a while, you can mismanage your memory allocations."
"Rust sees just this simple relationship between a borrow of an object and the lifetime of that object."
"...if the victim process does something that maps to this same set and evicts one of the things that the attacker has put there then when the attacker goes to look at them again doot dooot doot these are quick quick quick slow quick quick quick quick quick quick quick right."
"Enums are tagged unions whose variance vary in size are prone to significant memory fragmentation in Rust."
"Zig gives you the composable memory efficiency by being specific about the number of bits you need."
"Delegate all that manual management to the smart pointer, so that you don't have to write explicit copy constructors and move constructors."
"Avoiding data races is all about the visibility of memory and the changes made to that memory."
"A `weak_ptr` is a ticket for a `shared_ptr`."
"...when memory is freed for that promise and whatnot, does it automatically clean up the awaitable object as well? Yes it does, thank you."
"...variables of value type contain the value directly while variables of the reference type contain the reference of the memory address where the value is stored in the memory."
"Rust has no garbage collector, which means it embeds well."
"Object pool design pattern helps us to better manage automatic memory allocation and garbage collection processes."
"If you are using a graphical development environment like iStudio or Vivado, you can often drag and drop memory elements onto the canvas."
"if we made this a shared pointer right if I just make this a shared pointer and then we just return this what does that mean that means I have a global shared pointer instance here so game layer instance will never die unless I explicitly uh reset it"
"Heap memory is used for data of unknown size or dynamically sized data."
"Structured concurrency: avoiding memory leaks and managing lifecycles."
"The weak and unowned keywords are related to memory management. Weak is used to break reference cycles, while unowned is used when you're 100% sure that it will never be nil."
"So this is actually a retain cycle and we would leak memory if we did it this way."
"So what you want to do is add weak self and you can do self question mark because now self is weakly retained."
"So if we did in a weak self, basically you would do that functionally it's correct but you're leaking memory and you really don't want to leak memory."
"...these arrays don't grow, they're a fixed size array... that memory doesn't grow or shrink, it just stays the same."
"...a way to offload things out of your brain where you can still see them, look at them, organize and make sense of them without having to keep all these things in your mind at the same time."
"Garbage collection is nothing but the process of looking at objects in heap and deleting the unused ones."
"So, this here is a correct way to de-allocate the memory."
"Memory patterns are the most important thing you can think about because they make a factor of 10 difference in performance."
"But with memory mapped registers, though, the compiler doesn't get to choose where the object resides because the hardware has determined that."
"...if you have let's say only 10 elements inside your dynamic array there is no need to have an array of 100 elements you can have a dynamic array of 15 elements for example so that you don't waste all of that memory that you are not currently using."
"If I'm going to read a page, I've got to go get it off of disk, put it up in memory. Everything that SQL Server does is in memory."
"SQL Server often doesn't have that page cached. SQL Server uses memory for all kinds of things."
"You can query your program for its runtime mem stats to see how much memory you're using."
"Efficient memory utilization is a cornerstone of app development."
"Effective memory management is essential for delivering a seamless user experience."
"Smart pointers help bridge the gap between manually managed memory and automatically managed memory."
"The lack of a heap or garbage collection feature in C is both one of the great strengths of the language and at the same time is likely the reason that the average programmer will never develop or maintain a major C application during their career."
"Garbage collector is responsible for cleaning up unused classes, objects, and memory areas."
"Ownership and borrowing are super important concepts that allow you to automatically manage memory in the case of Rust."
"These short methods will be faster and more memory efficient basically always."
"Pass by value copies the value of a variable, while pass by reference stores a reference to the variable's memory address."
"This means that this dma can do memory to memory."
"The beauty of the Vic chip is we shared the bus with the memory simultaneously."
"Virtual memory helps modern OS's divide up the physical RAM so that each process, each task, each app that's running has its own address space."
"The memory is deallocated automatically, which means that you don't have to worry about the allocating the memory or causing memory leaks."
"For now, all you need to know is you store fixed size data on the stack, you store dynamically sized data on the heap."
"They got it right. Part of what happened was that they needed tail recursion in order to allow you to keep calling things and never expect them to return without running out of memory."
"The buffer pool is the area of memory that MariaDB uses to cache data and indexes."
"I hope this helps you understand a little better what malloc and free are doing under the hood."
"When we edit a struct, we're going to copy and paste; a class is a reference type, so when we edit a class, we are editing the exact object that is already in memory."
"V8 actually patches the file in the memory itself."
"We're going to set a global memory location that we're going to call temperature."
"Dynamic memory allocation is a type of memory that you allocate after your program begins running."
"I hope this helps you make more informed decisions about your memory allocations and resizing arrays in the future in your future projects."
"It's best practice to destroy the things you create so that you don't have any memory leaks."
"Local variables are stored on the thread stack, and the object itself is stored on the heap."
"We can reduce the number of mem copies by half, which can result in substantial performance improvements."
"So copying doesn't make sense. We '=delete' the copy constructor on 'unique_ptr'."
"The array that originally could only store five integers can now store ten integers, and realloc gave that to us."
"We don't want to use raw pointers if we can, right?"
"Knowing about memory management is going to help you write more efficient code."
"Go is a garbage-collected language, but you still can have memory leaks in it just as you can with Java or Ruby."
"There is a cache of small integer values."
"The allocate function is ultra fast; it just kind of advances a pointer through a buffer for the most part."
"The scoped allocator model guarantees all the coherency and everything we want for keeping memory in the containers automatically managed."
"A memory pool with fixed block sizes provides constant time allocations and deallocations."
"Safety critical applications usually require separation of memory pools just for safety."
"Memory leak: a chronic condition in which an application retains a growing amount of memory that is never accessed and is never freed."
"Dynamic allocation of RAM to programs."
"The average freed bytes improved by more than one hundred and seventy-eight percent."
"It has an explicit as opposed to implicit memory ownership, including also GPU memory ownership."
"Garbage collector periodically scans the heap memory to identify and reclaim memory that is no longer in use."
"You really want to avoid generating garbage which is exactly what this pooling system stuff will allow you to avoid doing."
"What span gives you is a read/write view over some contiguous block of memory."
"If we're consuming memory to model time, GC will erase the past and the memories that nobody cares about anymore."
"Smart pointers, never write delete again."
"DB2's ability to manage buffer pools is fantastic because I can create these and drop these without having to restart the system."
"The memory management unit does that magic of transparently handling the translation."
"Shared memory using MMU... we can have different virtual addresses pointing to the same page frames."
"All arrays live on the heap, and so if arrays live on the heap, then that means whenever we create new arrays, we're going to have to create new pointers to things on the heap."
"This is a fairly dramatic representation of how much memory you can save just by using datasets."
"Without memory limits, pods running in your cluster will not have a restriction on the max amount of memory, which can disrupt other pods running on the same node."
"Generators are very memory efficient; they process the data incrementally and do not allocate memory to all the results at the same time."
"Do not communicate by sharing memory; share memory by communicating."
"Allocating them as an array can let you allocate them more efficiently, because array elements tend to not incur as much wasted memory, due to texture alignment requirements on the GPU."
"Welcome to the exciting world of memory addresses."
"The size of operator determines the size in bytes of a variable, data type, class, objects, etc."
"The least recently used, or LRU, is a linked list. There's a head and there's a tail, and every item is linked to each other."
"The bandwidth of the memory subsystem has to be twice the bandwidth that you want to saturate."
"Python allocates memory and creates an index for each and every object in a list."
"Smart pointers and kind of automatic memory management systems exist to make programmers' lives easier and not just easier but more robust."
"For the objects on the heap, there'll be a pointer to the object which is the variable reference stored on the stack."
"Having a good understanding of these concepts is going to be really important when we get talking about garbage collection and tuning the virtual machine."
"Remember that locality is an extremely powerful benefit of allocators."
"Global variables represent a memory region that is visible in every basic block of your module."
"If you want to write cache-friendly software, the CPU would love to have continuous memory like a vector or an array."
"Virtual memory is basically where, when the RAM is full, a part of your secondary storage is used as extra RAM."
"Heap dump on out of memory error is something I recommend all customers run with."
"The Java heap is a part of the process."
"Sometimes things reach out of the Java heap into the native space."
"We have to be very careful to make sure that we delete the array that we've created to free it from memory when we finished with it."
"We create a new instance of QBMatrix2 of type T, store into it temp result, delete temp result because we've allocated that ourselves using the new keyword, and then we return result."
"You're more efficient in terms of memory usage if you manage everything yourself."
"What if instead of having to track every piece of memory's lifetime specifically, we let groups of related allocations share a lifetime?"
"Memory issues plague other languages and causes incorrect data or even crashing of your application; Rust puts safety first."
"With Rust, because you're doing so much to manage your memory at compile time, the garbage collector is not even necessary."
"I want to pass in the address of x and the address of y, so that swap now has sort of special access to the contents of those locations in memory."
"Any time you allocate memory with malloc, the onus is on you, the programmer, to eventually give it back."
"The linker is responsible for loading shared libraries into memory and resolving all of the references to functions or data that the program needs."
"Push is going to store something to the stack; it's going to store a register to the stack."
"There's no point in duplicating that memory; the idea of broadcasting is to make things fast without allocating more memory than necessary."
"Manual memory management is actually quite powerful in the sense that we as the programmer control completely how we're using memory."
"We want the GC to compact the heap so that fragmentation is taken care of."
"Instead of copying entire structures from one place in memory to another, it is often more efficient to use pointers to structures."
"What numpy really is, it's really just an interpretive view of raw memory."
"We're trying to manage the movement of data back and forth to the disk and the memory so that we can handle databases that are larger than the total amount of memory that we have."
"The content of PC is added with the offset value."
"We're doing our own garbage collection but it's so easy and fast with modern C++."
"The memory view is helpful for diagnosing whether your app is using too much memory."
"This is the same function that we had in our memory snapshot, but now it's live."
"With ray tracing, there's very little deferred loading and ejecting from memory."
"The important part is the old blocks were never reallocated."
"The reason Rust is so strict about types... is because it literally needs to know how to lay things out in memory."
"The database systems are always gonna do a much better job than the operating system for managing memory."
"You should never touch memory that you have already freed."
"Iterator resources are not being left behind because it is not uncommon for the iterator resource state to amass hundreds of megabytes or gigabytes of memory."
"The DRAM controller is providing an AXI interface through which different AXI masters can perform transactions to the DRAM memory."
"Stack allocation is way, way faster, and so we want to use that wherever possible."
"Automatic reference counting keeps track of your strong references to an object."
"We like memory safety; we don't like garbage collection pauses."
"This ability to sort of lay out your memory frankly, or lay out a value structurally, turns out to make your program quite a bit more comprehensible."
"Chrome Task Manager can help you identify if you're using too much memory."
"That's how you spot and how you track down allocation bugs."
"It's easier than ever not to leak memory accidentally because we're no longer responsible for managing subscriptions, and this makes it possible to build entire Angular applications without zones by leveraging the idea that all of us use observables to track state changes."
"Every time you call malloc, you're carving out more and more bytes for your program to use."
"An array with just a fixed size might potentially waste a lot of space."
"If you want to think about it, you could just say to free anything is to just free that, free that recursively, and then free the cell; it's as simple as that."
"Since threads live in the same memory space, they have access to the same data."
"It can solve the problem of out of memory errors that we can get in NiFi if we consume and over allocate ourselves by trying to consume too much data at once."
"We don't have to remember to do that on our own every single time."
"We have to match the Java memory model despite the fact that we have all these very different memory models from underlying hardware."
"This form of the algorithm... permits the computation without random access memory."
"A good, nice, tidy Boy Scout or Girl Guide programmer will always request memory with malloc and then when they're finished, they'll always free the memory."