 All right welcome quiz three review. So let's go through it quickly just a brief overview of all the topics What's on it, and then we'll do a sample question from from the final exam from? 2016 or something like that, which will probably be much more difficult than what's actually on the quiz So the quiz will probably be difficulty and distance what or length wise probably be between quiz one and two So quiz two didn't have very many questions, and it was kind of brutally long The questions that were given so and quiz one was really really short. So this one will be somewhere in between So it's going to cover four general topics scheduling page replacement page tables and the TLB so the translation look-aside buffer and General virtual memory questions a slew of true false or multiple choice ones So there won't be any sockets or anything like that because that's what we went over recently So just to remind you scheduling that's the thing that had a bunch of trade-offs We saw non preemptive ones, which you probably are pretty lame to ask on a quiz like first come first serve or shortest job first Then we saw two main ones when we had preemptive chins so we could change what process is currently running We can context switch to it at will We saw shortest remaining time first which optimizes the lowest waiting time But has an issue with starvation So you should know what starvation is where a process might not be scheduled because other Processes are already shorter or something like that and a long-ranging process may never be scheduled Then we saw around Robin everyone was really really bored everyone seemed to get it So won't go over, but it might be like hey here's some processes What's the schedule? Then we saw it even more scheduling algorithms The most you would see on the quizzes like we went over that dynamic priority scheduling example So that's another thing of hey Here's some processes which one's running other than that. It's fairly general stuff So like, you know some processes there's no one good Scheduling algorithm different processes need different things So if you are interacting with the process you want good interactivity good response time If it's just a batch process doing some computations You don't care you want to process as many of them as possible in a given time So you might care more about reducing the waiting time there and those two things are definitely at odds with each other So it's going to be no perfect solution We saw real-time all the difficulties that come up if we have multi-processor systems So either we have a big global queue and have to do locks or we have different scheduling algorithms on each for each individual CPU Then we saw ideally it's fair That's the idea behind the completely fair scheduler that's actually used in the Linux kernel But the Linux kernel stuff you're not gonna have to do scheduling that the Linux kernel does on a quiz or something like that So then we went into page tables page tables just translate virtual to physical addresses So we'll have a example today that will be harder than probably what would be on the quiz Modulo maybe We use multi-level page tables on the quiz cough cough but For page tables What you do so there's the MMU that's the memory management unit That's the hardware that uses page tables and does the translation So we could have either a single large page table which may be wasteful because it would have to be able to hold all the entries for every single possible virtual address and Processes unless you know your Chrome or VS code or something like that You're not gonna use all the the virtual addresses so you most processes don't actually need all those entries So a lot of it is actually wasted space So we looked at Multi-level page tables to save space idea behind them was each smaller table fit exactly on a page And then we just followed it however many levels we need to in order to find the allocation so we need for For one to resolve one address We need to have at least one page table for every single level to resolve one single address Which is still going to be way less memory than You know every single possibility And then if you're the kernel you only allocate pages or at memory in pages And you could do it with a simple free list or something that and the TLB is just the translation look aside buffer It's basically the cache from virtual addresses to physical addresses And we'll have a question at the end to see if we understand that Then we did page replacement everyone was really really bored about this Hopefully everyone can do this so given some page accesses. What are all the faults? That is a perfectly valid quiz question. It's like the algorithms you could do you could do optimal So, you know you replace the page. Let's use less in the future to get the most amount of essentially Accesses that are still in memory then random that obviously wouldn't be on the quiz because how the hell we're going to mark that and then FIFO so that's easy to implement first to come first or first in first out And then that had that weird anomaly where we had less memory and also less page faults Pretty much the only thing you care about in replace page replacement is minimizing the number of page faults So that was a weird thing with FIFO and then we saw a least recently used which gets close to optimal expensive to implement But for the purposes of the quiz you could probably do it. Yeah Yeah, so I don't think the other course actually went over the clock algorithm So there's probably not gonna be a question of like hey here is a schedule using a clock algorithm Tell me the number of page faults So I don't think the other section section one never did it So the clock algorithm is like it's in the idea of least recently used but it's not exactly recent Least recently used it's an approximation Well for the quiz it'll be like hey, what what are all the Tell me all the page faults if I use least recently used or tell me all the page faults if I use optimal Tell me all the page faults if I used FIFO Yeah, I don't think we have enough TA hours to do that so Yeah, so wouldn't be something like that Something mean to waste your time would be like hey do this for all different algorithms and tell me the answer But like optimal is gonna be better. Yeah It's gonna be in between so there's gonna be at least You know a big page stable question and probably a big scheduling or page replacement question and then a bunch of more multiple choices So and the multiple choice won't be essentially a long answer problem So either two or three long answers. So Scheduling put page replacement. They're kind of the same boring thing We kind of know how to do them and then probably page tables and we'll see a page table question and yeah, just for Giving terms to stuff so pages When it's on disk typically it goes into something called a swap file. So that's a Name you might run into in the multiple choice So the a bitmap is basically yeah So all the pages on this are in a big swap file and the swap file is what's all the what holds all the pages on this Yeah Yeah, so frame physical page page typically means virtual page. You could call it physical page You could call it physical frame. You could call it frame. They essentially all mean the same thing In the context of the question you should know understand what it's talking about but you might see different terminology And yeah, so quickly bitmap. So it's what slab allocators use. It's what Anything that allocates of a fixed size use just to be more explicit The bitmap itself is going to be contiguous block of memory that tracks slots So however many bits you have is however many slots you can track For example, if you have a bitmap that is 512 bytes Well 512 bytes times 8 that is 4096 bits. So you could keep track of 4096 slots So bit 500 would be slot 500 and you could do the math So if you wanted to check what bit 500 was you could see what byte you need to check by just dividing by 8 And then you take the remainder to see what bit you have to check and that's how that works Okay core map we didn't talk about and they didn't talk too much into detail of it But it's a data structure you should know Basically, it just manages the physical pages or frames again interchangeable So it keeps track of what processes are accessing what frames mostly in order to actually deallocate it properly So because we have two processes and we could have shared memory. So two processes could be Sharing the same physical frame from their own different virtual addresses So you have to keep track of how many processes are actually referencing a frame And that the core map is the data structure that does that So each frame would track what processes are pointing to it And when you deallocate it you would that process would no longer be pointing to it And if no processes are no longer pointing to it, then you can finally deallocate if you're the kernel. Yep Yeah Yeah Yeah, so this would happen on forks This would happen like you'd be sharing pages on forks. You could explicitly share pages to do shared memory But we haven't seen how to do that But it's not out of the realm of possibility where two things could map to the same frame and then actually share memory without Doing that copy on right thing Yeah Yeah, it could be a hash table. It could be Yeah, it's just figuring out given a frame what processes are pointing to it Yeah, okay So here's other things that might appear the multiple choice and good things to know so rough Latencies so cpu cache will be nanoseconds memory is like hundreds of nanoseconds or a micro second Which is a thousand times slower an ssd, which I think the quiz is old so they don't know what an ssd is so But that would take like double digit microseconds and then disks or hard drive like the spinning things would take up to milliseconds So that's why doing page replacement is bad and it's so slow because it would take milliseconds Which is like a factor of a lot different. Yeah So there's a lot of cache For doing the translation the cache is called the tlb But like there's caches for memory like your l your l1 cache and your l2 cache on the cpu Which doesn't quite correspond to the l1 and l2 page tables But that's a different thing just to make life confusing But that's like cache on your actual cpu But the only number if you get into the multiple choice and it's like hey, how slow is something It's probably asking about a disk. It's probably milliseconds So that's a good number to know All right last thing I didn't touch on but we kind of talked about it a little bit is spatial versus temporal locality And spatial locality just means accesses are close together in memory So they'd be contiguous or almost so if two memory accesses If you know two pieces of memory are accessed together Hopefully they are located together So they would at least be on the same page if not contiguous and that way you only have to do one Virtual memory into a physical translation and then there'd be a cache hit and it would be in the tlb So every other time you access either address it would be cached. It would be nice and fast So that's just each other in terms of space then the other is temporal locality It's being accesses close to each other in terms of time So if two accesses are close to each other in terms of time, they're kind of Related somehow and you would want them to also be located close together to be really fast But they're two separate things so things could be accessed close together in time But not located together and things could be located together, but not accessed at the same time Ideally you would want things to be Everything that is accessed together at the same time is close together, but they're two different things Okay, so we didn't give this a name, but we kind of talked about so thrashing is when there's a high number of page faults So when a process cannot have their working set in memory and a working set Is just the amount of memory a process needs to execute without any page faults at Given some like short time interval. So it's just how much memory it needs In order to actually run successfully without hitting any more page faults So if your working set wouldn't fit in memory It means that under normal execution that you would have a page fault And then you would have to do page replacement, which would go to disk which would be really really slow So if a process is constantly evicting pages, it's going to be really really slow And it's something you don't want So if you're the kernel you can kind of detect this by keeping track of the ratio of page faults And if it gets too high, maybe you just go ahead and deallocate memory from another process and You know pick a page from another process in order to give more memory to this current process It's trying to execute because it needs more memory And you actually want to clear it up a little bit give it more memory So it's working fit set can fit into memory and it's not constantly swapping out to disk all the time So the kernel could do something like that, but you might see the term working set on the quiz Okay, demand paging this is another thing that we didn't give a name to that we just kind of talked about So this is the idea of doing things lazily. So whenever you start a process or something like that You would assign all the virtual you'd set up all the page tables with all the virtual addresses But they wouldn't actually go to physical memory yet until their first access So if you're the kernel on the first access then you would allocate an actual page And then you would modify the page table entry to make it point to that newly allocated page So the flip side of this is if I didn't have this I would have to allocate all the memory for the process as soon as it starts And allocate all of it even though it might not ever use it and also that would be really really slow for starting up So then kernel can go ahead page fault figure out back it by an actual page And then during this too, it might not always Back it by a physical page if you're doing demand paging because that process as we've all done before could just access Any old virtual address that doesn't that isn't actually valid to access and then When it gets a page fault, it would just send a sag fault back up to that process and then we get our fun sag fault We've got So that's it for demand paging And then we have copy on right and then we'll go into our example, which will take most of the class So copy on right we've talked about this is just to make sure we get it So the idea behind this you can also you know do other interesting things is Same idea with data races if there's only reads to pages Then we're allowed to share them as many times as we like there's essentially no data races everything can be shared for free So When we fork two processes can share the same frame and then either could write to them But again, we want by default we want things to be independent So if you're the kernel you could go ahead have them share the same frame And then if either process tries to write to it then you would You'd essentially turn the right permission off. So you get page fault. So then you can service it So when you see that you would then and only then copy the actual physical memory of the page and have one page with the Modification map to the process that made the modification then you leave the other page alone and now the other Process can go ahead and write to it later if it wants to So this can also have some optimizations with read only frames if we're doing page replacement so For example assume that like our process is running. It's executing some code. It's only reading code over and over again So it would be loaded into memory It would be loaded into a page and then maybe we decide to evict that page that just has code that's being read Well, it's a bit of a waste of time to write it back out onto disk when that actually already exists In disks somewhere where that original file was So instead of writing that essentially read only page back to disk Only to write it back out to disk only to read out some information. That's elsewhere anyways I can just go ahead and reuse that page and then I can just go ahead if I need to Use that or swap that page back into disk. I'll just reread that file again from disk since it's there anyways Yeah Yeah, this is only possible if it's a read only page Otherwise it would have modifications and then you actually have to write it back out to disk if that's your only copy of it Okay So this is what we'll take a long time. So this question is a bit weird and we'll take most of the class so This is a bit of a weird one because we have it talks about tag tlbs which We talked about briefly, but this is a full example of it and tag tlb just means that So every process has its own virtual address range. So in the tlb There's also a spot where you can attach the process id that that Virtual address is valid for So let's go ahead and read this question So we have an early 16-bit processor uses a single level page table That's a slight sigh of relief. That's not a multi-level page table, but you should probably be prepared for one of those But anyways for this single level page table with 250 byte pages So anytime I see Some numbers Good practice is to just write the equivalent power of two just in case So what's 256 in powers of two? Oh no Eight to the eight so luckily that's the same as a byte To the eight So it's a number of values. You could have it in a byte. So to the eight So maximum, you know physical memory it can support is to the 16 so Now we know how big our physical frame number is so this is how many Bites our own machine so we have a 16-bit address here So then it shows us the tlb and the page table entry have a the following format in the tlb There is the virtual page number And then essentially after it is the page table entry And here we're used to seeing ppn like physical page number. This is just pfn, which is physical frame number Means the same thing So there is a in the page table entry. There is a physical frame number. There's a process id And then there are four bits. There is a bit that says If it's in swap and if it's in swap the Physical frame number should be interpreted as a swap location Um, and it only looks at just the valid bit is zero. So there's also a valid bit A reference bit Or sorry, not a reference bit Oh, there is a reference bit, but it's not used. Oh, sorry So reference bit is just if it's Currently referenced in the tlb. We actually won't use it in this It just lets you know that that entry has been referenced before So so that it's actually backed by a page. So it could be valid but not actually referenced so It could be a valid virtual address, but it doesn't actually point to a physical page yet. So you need to fix it up But don't worry the reference bit's not here. So all we care about is in the page table entry There's four bits here in the tlb. There's four bits here. So it's just four bits of space Okay First question is calculate the maximum number of processes whose page table entries may exist in the tag tlb at a time Which is other words of saying how big is this process id in terms of bits? So we have to do some math here So we have to figure out how big the physical frame number is in terms of bits Anyone hazard a guess as to how big that is So this is this machine has 16 bit addresses And the page size is 200 and 56 Sorry 256 bytes. So if we write out an address It would be offset and then you know Our physical frame number if this was a physical address. So how many bits are in our offset? Eight bits The total thing on this machine is 16 bits So how big is the physical frame number? Eight bits So it's just eight bits No, we're just figuring out how big the physical frame number is without looking at anything else So the physical frame number it takes up eight bits So now we can go back. Yeah Uh the offset. Yeah, so It's how many bits you need to Essentially address every single byte on your page so If my page is 256 bytes Then I need eight bits to be able to reference every one of those So I need to point to all the values. So I need to be able to go from zero to 255 Yeah, yeah this thing here Yeah, so that's our physical address made up in two parts the physical frame number and the offset So now it says the page table entry size is two bytes That's good. So These are four bits right here the permission and now we know this Physical frame number is also eight bits and then we know that the total thing Is two bytes or 16 bits So how large is this is the process id? four bits Half a biter. Isn't there a name for it a nibble or something nibble? There we go. It's a nibble so That's such a stupid name So, yeah, so we can So we can we have a nibble for our process id so that means we can Essentially the maximum number of processes we have is two to the four So that's how many different processes we could have. What's two the four? 16 15 plus one that's a roundabout way to get to it. So 16 processes max okay Now it says what is the maximum size of the swap area that is supported? well, so it says That because it's a bit weird the physical Frame number should be interpreted as a swap location So there's going to be Up to two to the eight entries because there's eight bits in our physical frame number And then each of these would be a page So a page is also two of the eight So to the eight times two the eight would be two to the 16 To the 16 as long as I can do math So that's like two the six kilobytes because two the ten is a kilobyte Sorry So this is the page size And then this is the number of swap entries so Yeah, two the six kilobytes would be 64 kilobytes Because it says the physical frame number should be interpreted as a swap location So there's just two the eight possible swap locations The page size What's s? Yeah, so it's a bit in the page table entry that just says whether or not that virtual address is currently in swap Yeah, yeah, it's pages in the swap space Yeah, yeah, it's just a bit Yeah, it'd be in the swap file Just because just because it says yeah Sorry No, so that memory it can support is just how many different bytes you can address Physically, yeah Yeah Yeah Yep. Yep. So it's just converting all right Uh processor takes a supports a limited number of physical memory. No crap as a result Okay, this is where it gets really weird. So page tables and floor processes are packed into a frame Yikes So this doesn't quite Have our tricks. So this is not multi-level page tables or anything So what it's saying is on a single page is actually four page tables And then you have to figure it out yourself So here it says process five would use the second chunk if you actually want to implement it It would actually be a disaster, but I guess since we're writing it on paper we can roll with it But it's kind of weird So what then it says what's the maximum amount of virtual memory that is available to each process? So this is where it gets a bit weird so each frame is Or page size is going to be 256 bytes So that means we divide it into four because each of these has four page tables, which is kind of weird Which means If we have this we have 64 bytes In our page table Yeah, one page table is 64 bytes So then it says what's the maximum amount of virtual memory that is available to each process while 64 bytes That is the same as two to the six. No, yeah two to the six So we could have two to the six entries Yeah, we'll always assume byte accessible memory Yeah, so this will be to the six or did I screw up the division packed in frame That's right. Okay Uh Was the maximum amount of virtual memory that is available to each process? So it's essentially would be that times to the eight In the virtual page them Yeah, um Wait one sec. Oh, sorry. I messed up. Yeah, that's where I messed up Okay, so I messed up. So that's how many bytes are in a page table, but yeah Yeah, that's where I screwed up. Okay. Yeah, so there's There's 64 bytes in my page table and then I forgot to keep track of my page table entry size So it's two bytes So that means that if I have 64 bytes in our page table and my entry is two bytes That means I have 32 entries In my page table Which is actually which is why I thought I messed up to the five so Then to figure out the total amount of virtual memory it'd be to the five times to the eight Which would be our page size which is two to the 13 Which would be uh Eight kilobytes Okay, then it says if the processor uses 64 bytes for the tlb Was the maximum number of tlb entries that can be stored in the tlb This is where we will go into the land of completely implausible so This is the maximum. So we have 64 bytes For our tlb Which is also 512 bits Why am I doing bits? Well, they want to make it difficult So in their tlb Each tlb entry the virtual page number or virtual page number. We figured out how many bits that is. So this is five bits Then the physical Frame number would be eight bits Process id is four bits And then all the permissions here are also four bits So if we add that all up how big is our page or sorry how big is our tlb entry? 21 bits Which is yeah, so it's essentially going to be 16 plus five So it's 21 bits, which is how you know this is not feasible to implement so It's saying the maximum number you could theoretically fill out But you couldn't implement this on You could implement this but it would be a disaster because you'd have to shift bytes all the time or shift bits all the time And be kind of terrible, but I mean you could do it if you're super space constrained So this is like 24.3 or something like that. So we'd have to round down So we could have most 24 tlb Entries Max Okay, weird question The 21 is the size of the tlb entry here So five plus eight plus four plus four Yeah, I just changed the it said 40 64 bytes for a tlb. So I just changed it to bits So 512 bits divided by 21 bits you have to round down So I could fit 24 entries if I really wanted to Again kind of weird question, but This gets to the hard part. So you get a just a big old memory dump here. Everyone's favorite So it says the following frame is used to store the page table for processes 0 to 3 Use an outline to show the location of the page table for process Zero So this is like a weird thing where it gets divided into four. So process zero is going to be the first Quarter of this Yeah, so the first four rows so if we so So the whole thing here is going to be 512 bytes or 556 bytes And then we're using this weird thing where Page tables four of four processes are packed into a frame Yeah So this is a frame This is one frame and it's going to have four page tables. So you assume they go in order So this is the page table for process one page table for process two page table for process three or two page table for process three And you can go ahead and sandy check yourself because we said each of them is 64 bytes So there's 64 bytes or also 32 entries So there should be 32 entries here each entry is two bytes So luckily See how they wrote that out each one of those things are two bytes. So Along the top there are eight entries and then we have four rows eight times four is 32 Which is the number of entries we said before So process zero has 32 entries here and these are what they are So Now it says using the table above translate the virtual address is shown below for process zero to the corresponding physical address For each address show the corresponding page table entry and the physical address If the virtual address is valid invalid write fault If the pte is not valid write invalid under the physical address If the page isn't swap write swap x where x is a dislocation And you have to figure out, you know, we have to do it in binary. So Swap swap is the top bit of the first hex character so Luckily enough So let's just divide it so we know our page size is eight bits Which is going to be two hex characters. So we don't have to write this out in binary. Thank god So we can draw a line here so to the right of the line is the offset and to the Left of the line is the virtual page number So the virtual page number is just the entry. So you just count however many entries So they give you the first one. So it's the virtual page number at entry zero or one so This is entry zero. This is entry one So this would be your physical or sorry your page table entry and then To do the translation This bit the least significant bit is A one which means it's valid. So the least significant bit is The valid bit. So basically if it's an odd number, it's valid So we know it's valid. So we can go ahead. This is just which process it is luckily it Lines up with the process. So then we would just this whoops the 54 Is the physical? Frame number. So we would just take that into the physical address and then we keep the offset the same Yeah, sorry So there's four hex values because they're two bytes So this is this table is really weird because it only shows essentially eight entries at the top And then on the left are memory addresses and they are not related Well, they're kind of related because this would be if these were all memory addresses You'd have to multiply each of those by two because they're two bytes there So it's a bit weirder than it's kind of I guess meant to throw you off, but it's kind of an unclear table So there is 16 bytes across which These are all memory addresses on this side But at the top but along the top are just the number of entries which is unrelated So if we count the number of entries, this would start entry eight entry 16 entry 24 If we just counted the number of entries, which is the number of two bytes Yeah, so this entry for element one is actually at a location two Because it starts each entry is two bytes. So you'd have to multiply All right, so next one virtual address one five So you would think by looking at this, you know, oh, we take the one and then we take the five and it's this one well, it's not because you know, again memory addresses on the left and then Just random entry numbers on the top So easiest thing to do one five if we split this out. This is actually entry 21 if we write it out in decimal so This is entry 16 here. So 16 17 18 19 20 21 is this entry So this is entry 21 so the page table entry is ac 0 3 what Yeah, that's the index number. So Yeah, no, it is the virtual page number, which is essentially the index It's number odd. So it is a valid address. So we just go ahead and translate so We take the Physical frame number, which is ac and then we just add the offset from the virtual address So it would translate to address ac b4 All right next one Is a trick So it is virtual address two zero Which would mean it's entry 32 And there are only 32 entries and we start at zero because we like computers So it's not even a valid entry the last entry the last valid entry in the page table is going to be 31 This is asking for 32 So it is outside of our range. So it is invalid all right Next one is entry five so we can just count five Huh? Oh, sorry. I'm supposed to write fault. Yeah fault All right, next one is entry five. So zero one two five So it would be this one so db oh All right in this one The valid bit is not set But the swap bit is set because it's the most significant bit in the last one So eight is one zero zero zero So this means it's in swap And it says to just use the physical uh frame number as the swap location. So you just write swap db Now next one is a a is 10. So this is eight here nine This is entry 10 So it was What was it zero three zero e Oh now e In binary is one one one zero So it means the swap bit is set again. So we just write swap And then use the frame number which is zero three Yeah, no, no just means it's on disk It could be swapped out and there's just a still entry there or something like that Like the entry could be there, but now it's What page it goes to isn't actually valid anymore. So you'd have to flush it or something. Yeah So You're swapping things out from memory, but you could go off to like an ssd or something No, so this is where the page is So this page here is in the swap file somewhere at entry zero three Yeah, the the page is currently on disk So this means it's currently on disk. Yeah May or may not be Not yet the last question is about the tlb If the swap bit is zero, it could just be a valid entry and it could just already be in memory Just be in memory like yeah all right last one is One e which is entry what like 30. So it's the second last one So just to spare some counting it is this one So it is the page table entry is c607 So in 07 it is 0111 So which means it's valid and So we just do the translation. So it would be c6 f zero All right last one quickly Is like hey, here's the current contents of the tlb assume that you know the tlb doesn't miss or anything So let's divide them up So we know that this is the virtual page number This is the physical frame number And this nibble here This is the process id and these are all the permissions So we have to check everything. So first process one reads from virtual address Zero like virtual page number zero three. So we actually have an entry here in our tlb But if we look at the process id column, it's a zero and this is process one So it's actually not in there. So this is just a miss Because it's the wrong process For the next one We check 19 which would be This one So it's a correct It's the correct virtual page. It's the correct process that also matches up And then we check the permissions So in this permissions, it is six Which is even which means the valid bit We go back here the valid bit is zero. So it is a miss Because it was invalid And then quickly The next one is one d for process Zero, which is this last entry here So It maps up the permissions. It's valid. So it's actually a hit It doesn't even say to give the address But if we were to translate the address the address would just be ee uh four nine And then for the last one, which is the last one, which is the most annoying one Is going to be process zero rights to address one b So if we look up that would be This entry So the virtual page number lines up It's the right process id and then We have to look at the permissions So five is zero one zero one We look at this permission table That means that that old bit is one which By looking at this it means it's read only So this one says process zero writes to that address So it's not allowed to do that because that bit is zero. So miss Permission kind of annoying Yeah, yeah, it's just it's basically a cache for page table entries Yeah, it's just a cache So it'd be way better if it was for a multi level page table because then You know, it would save you going multiple levels But for this it's a single level. So it's just Faster the page table entry is already there instead of doing a separate memory access for it Yeah The first one is a miss because It would correspond the closest page is this one Where the virtual page number lines up But the process id for this one is a zero And it says process one So it doesn't line up. So it's not valid Okay, sweet Yeah, but you shouldn't have access to just random memory Well, but if I can like read your bank account or something Okay, what about read your bank account in 10 years? All right, well just remember pulling for you we're all in this