This is a topic that many people are looking for. thevoltreport.com is a channel providing useful information about learning, life, digital marketing and online courses …. it will help you have an overview and solid multi-faceted knowledge . Today, thevoltreport.com would like to introduce to you EP5, Tracking RAM and Page File Exhaustion: How IT Pros (SHOULD) Troubleshoot Slow PCs and Servers. Following along are instructions in the video below:
hey folks this is Chris with Microsoft aka Big Daddy nines welcome to another exciting episode of the performance series in the last episode weve been were talking quite a bit about disk performance and how to troubleshoot that so I think weve got that one pretty well beat down so in this video were gonna move on to the next topic which is going to be memory now memory is a big subject and its going to take more than one episode to cover this and theres a lot of different ways to talk about memory because theres real memory and then theres fake memory and when we talk about real memory were talking about memory you can buy at a store and when we talk about fake memory were actually talking about two different types of things there are the pieces of fake memory that you might think of as a working space for a process to do stuff and reserve memory and things like that and thats called the virtual address space its also an area where the kernel can do stuff and we we look at those as virtual by its or virtual address space and youll notice in here of all the little categories we have theres no virtual stuff in here and theres no kernel stuff at all really this is just all user mode type things and well be covering all of the virtual fake memory stuff in another episode what were going to be talking about today is real memory and page file and the combination of the two and how we can go about determining when were out of memory what does that mean a Reata of RAM or we had a ram and page file and if we are how do we go about finding out that were now out of that or that we ran out last night maybe and were looking at some counters now and then B who took it who took my memory right and what kind of memory did they take so thats thats the point of todays episode so well kind of first off were looking at resource monitor right here if youre having trouble live dont use perfmon get in here and look at the problem from this perspective right now were looking at a healthy box with two gigs of memory and from the views here you can see that we have some funky sounding words and maybe some of you are familiar so maybe you may not be familiar for instance what is a commit and what is a working set and what are shareable bytes and what our private bytes so these turn into really important counters and strangely the counters do deviate in terminology as to how well look at them but they dont deviate really much in purpose and obviously youve seen the pretty little graph down here at the bottom what does this stuff mean right in use modified stand by free Im gonna torture you with a whole lot of SuperDuper deep details about this but basically the green part is in use this is stuff that is currently being used by Windows actively if I fire up notepad for instance its going to need a little bit of this in use memory and modified is in this orange area modified data is just stuff that it doesnt really exist anywhere other than in memory modified bytes or you have some people call them dirty bytes but thats not a very good description in my opinion you got the standby list so a standby list is a result of the fact that the virtual memory manager in Windows hates reading things off the hard drive because its slow and so once it goes and pulls something off the hard drive it will typically not send it back so if I opened notepad and then I closed notepad notepad would not be in here in the act of running programs and I wouldnt be able to find it see how its grayed out its not really here anymore if I looked in task manager you wouldnt see it under details at all there is no notepad running right now there notepad is still in memory because unless I start running low on memory the virtual memory manager doesnt have any reason to go and start actually clearing out and right now weve got tons of available RAM you can see that right here when we zoom into available memory this is an important piece because the available memory is the actual amount of memory thats available not free from a quick perspective free when you look at it makes it look like hey thats how much free memory we have now you actually have way more than the free amount available why is that different the reason that the available is a combination of standby and freeze because this is in fact memory available to windows if if windows needs to fire up some big hefty program when you open up that program if theres not enough in free memory itll just sacrifice some of the stuff in the standby list and again the standby list is just full of stuff that either Windows thinks youre gonna open or stuff you have opened and closed and its gone ahead and prefetched that and put it into RAM so things feel like they load faster so it doesnt have to go read stuff off the hard drive its both basically a cache and that is not actively running programs in most cases so anyway thats your standby list and your free memory and thats what this little graph down here it signifies but what what you need to pick up from this whole thing is available megabytes is this right here 11:25 thats what thats what were standing at right now on this virtual machine as far as free memory as far as trying to figure out from a performance perspective what it was that maybe ran us out of memory well remember that step one is really trying to figure out what we ran out of right so or what bottleneck does because youre typically looking at a performance counter from perfmon after the fact youre not going to use as we discussed in previous episodes the performance manotaur monitor grid here live you would use other tools for that task manager for instance to go and figure out your primary indicators of a memory bottle neck there are a couple of really good counters that were going to start with and were going to do another one of these performance counters manually created and well take a look at the memory object so well come in here to the MS and under memory once again there are no instances because theres just one memory so theres a bunch of counters down here only a few of them are what were going to really be using in this episode because theyre the most important ones so available megabytes right here that Ive got commented out highlighted rather is the amount of RAM thats left I get so frustrated sometimes because I read all the time and blogs and and even performance books that have been written where somebody says the best way to tell if youre running out of RAM is pages per second and that is ridiculous why would I look at pages per second on you know my page file or just paging in general hard page faults and try to determine if Im out of memory based on that when I have a counter right here tells me exactly how much memory Ive got this right here available bytes is exactly the same as looking at resource monitor at the available RAM here right and if I was looking on the graph over here used physical memory thats the measure of just RAM okay so that is just Ram there are a couple of other important counters well go ahead and dump em in so we can talk about them percent of committed bytes in use thats RAM and page file because obviously if you have stuff that is in memory and then later gets paged out if you have measure that can tell you how many committed bytes you have altogether that will cover both the page file usage the committed bytes of all the processes in other word so thatll cover both the RAM and the page file because when a process is committing memory that doesnt necessarily mean that that memory is always still in RAM if its been paged out if the virtual memory manager has cleared some space out well well see that in the process performance counter that well be talking about later but before I get too deep into the weeds here trying to just keep it simple this is quite simply a counter that measures the total amount of RAM and the total amount of of page file and how much is currently being used in a percentage counter right so we know 100% means weve used it all up right 10% means that we have 10% of our RAM and page file another couple of important counters that are exactly related to that is the commit limits and an commit bite committed kept with that comment limit and committed bytes these are actually the same thing as the commitment of committed bytes in use its just these are actually the number counters so ones a measure of the percent of total whereas commit limit is the max and committed bytes is where were at right now I want to go ahead and chunk those three in there and Ill explain right now the reason that I like to have the commit limit even though I already have that pretty little percentage counter itll tell me everything I like to know if the page file is expanding if the commit limit changes typically it goes up that means you know if I had four gigs of RAM and I have a two gig page file my commit limit is two gigs it is six gigs sorry I cant seem to do math four plus two equals not to its six so commit limit would be sitting at six gigabytes right and if I had you know three gigs currently being used the committed bytes in use counter the percentage counter right here this would show at 50% obviously right but what happens if I start running out of the you know the commit charge gets near 100% well if the system is configured to do so it might actually give me a bigger page file right so that would cause the commit limit to go up and itll cause the percentage counter to kind of fluctuate were gonna demo that here in a little bit so I can show you what that actually looks like live and well also look at it while were doing doing this well have the performance caning running at the same time right so available megabytes we talked about percent committed bytes and use committed limit committed bytes those are really your key performance indicators for whether or not youve run out of memory or not and I mean the real memory stuff Im not talking about the fake virtual address space stuff were going to get to that a little bit later you could go ahead and get your pages per second and dump that in here but as I mentioned before its not SuperDuper important to is discussion because you know its its really not a good measure of whether or not youre running out of memory or
not right so another thing that is kind of interesting I wouldnt throw it in there just just because people like to see it and well go up here to the page file object oops I apologize I know that Im sitting here in every episode looking for very obvious counters okay so page file dot sis thats sitting on C Drive percent of usage thatll tell us where were at as far as the percentage uses this is not a good primary indicator of performance what what thatll just tell you is whether or not you are indeed using your page file people are always saying well are we are we actually putting things in the page file or not well if you have this counter running you can go back and see if there are in fact things that are going in there in most cases people will be shocked to know how little the page file actually gets used and we need to stop and talk about this little guy right here page file is not an extension of RAM and I know a lot of people already know this but theyre youd be shocked at how many people do not realize that if you have four gigs of RAM and you make a two gig page file people think you now have six total gigs of memory that is usable like somehow you get to the end of the four gigs and we have just as continuing address space beyond that that that just keeps on running as overflow thats not how it works okay theres a little guy running in memory in a kernel of the OS called the virtual memory manager and what hes doing is when he starts seeing you run out of physical RAM he will start taking the least recently accessed pages in memory and start to trim that working set of the process out of RAM some of that stuff will probably not make it into the page file some of it would so to give you an example if I fire up notepad write myself a little note I put maybe you know some text in there like hey pick up milk on the way home right because for some reason Im not you one note Im using no patent and then I minimize it and then four days goes by and I havent touched notepad cents its just been minimized sitting on my desk and on day three a virus scanner kicks off and consumes all of the physical RAM to do a quick scan and the virtual memory manager needed space its very possible that the notepad itself the binaries the executables the you know the DLL files handles hooks everything that notepad uses to do its thing isnt actually in physical memory anymore its very possible that that actually has no has been trimmed out of the working set that doesnt go in the page file because it already exists on the harddrive notepad.exe is on the harddrive there is no reason to go and put another copy of notepad.exe into a page file it just becomes kind of a mapped instance it says hey these addresses used to live here but theyre not here anymore go find it there and thats what a hard page fault is our page fault is going and getting something off the disk maybe because its the first time youve opened it and yes that will and beed called cause pages per second to fly or its hey this used to be in RAM its not here anymore I got a hard page fault I have to go and resolve that fault by going to the drive the hard disk and picking these bits back up and paging them up into RAM so that I can execute it because the processors on your system will never actually execute code off the hard drive or the page file now where did the go get milk on the way home note that I wrote thats this piece right here thats at least one of the things hoops it disappeared the modified data that we saw before that was in the orange that that stuff is not in the hard drive and if notepad had been minimized for days and we were running out of RAM and the virtual memory manager needed space he would take go get milk and page it into the page file thats the sort of thing that goes in the page file and then strangely if you are now sitting with a lot of available memory what would probably happen in a lot of cases is the virtual memory manager might come back later and go ahead and forwardly resolve that that hard page fault for you and pull it back up into RAM because he he sees that hes got some free memory and its something you might run again because its sitting on your desktop and minimized and pull it back up bit of a stretch there into this discussion and to the feeds and the speeds of how all this stuff works but its important to understand that the the stuff that is on the page in the page file isnt going to be anything that already exists in you know Minh the hard drive and its not going to make extra copies of stuff right its gonna be modified data that doesnt exist anywhere else and so anyway hey digress so theres another thing here that you might be worried about you know like ok thats great Chris youve gotten me my key indicators available megabytes percent of committed bytes and use if those are running low and my server was slow I saw these I know Ram or ramen page file I had a memory contention what do I do now okay so thats always step 2 right now were going to go figure out who goes and steals our stuff when they ran out of things okay so we go to processes right process analysis of memory for just going and getting you know who took my memory is obviously going to be in the process there it is the process object and like before we drop it down and we go and look for our stuff so there are two counters here that can measure what it is that took my memory up depending on what you ran out of if you ran out of available bytes then the counter you use is the working set counter if committed bytes is what she ran out of or started running low on then the counter private bytes is what you need right so we would do all instances add that in then weve got private bytes remember the counter path the instances every one and the counters that were throwing in here are private bytes and working set and so those are two measurements that simply tell you whether or not this was the process who went and sucked up all your all your memory and those are the counters were going to get alright so were going to go ahead and toss in five sample intervals because were gonna be playing with this thing pretty quickly go ahead next next finish and start that thing up and lets take a look at some of the things that we can do I want to be using a little program called test limit and Im gonna have a resource monitor running in the background and were going to talk about a couple of these different conditions and what they will look like test limit youll notice theres when you pull down test limit theres both a 32-bit and a 64-bit were just going to play with a 32-bit one and if I throw a question mark out here itll show you some of the things you can do the ones that are the most important here for our test first and foremost is the seconds elapsed – e because if you just run this thing raw itll suck up all your memory so fast you wont even be able to see it coming your box will be locked up and youll have to reboot it and you if you ever want to do this just for practicing thats thats not the one to do so the the other piece two pieces to test are our stuff here is a virtual lock so the virtual lock means Im going to start using RAM and locking my pages in RAM processes can do this they can they can do this virtual lock and they can cause the operating system not to be able to page them out and if they cant be paged out and theyre leaking then the only thing youre going to run out of is RAM not RAM and page file so were gonna do a test of that and were also going to be linking memory with the – M oops all right so those will be the two things we do now which one to do first probably the more common and thats just gonna be leaking memory so well do a test limit and were gonna do a – M and lets just do 10 megabytes at a time so we can have plenty of time to catch this and study it and look what it does to the OS as it goes and then were going to do the the – e and well just tell it to every one second come through here so this is gonna spawn a process and its leaking private bytes at ten megabytes at a time your your private bytes counter that we threw in is the best memory leak encounter you have for a process unless your system only ran out of RAM and not RAM and page file so youll see this be your most used counter that yours where the heck is that there it is test limit so Im gonna go ahead and check that box that throws them up at the top so he doesnt go away all right so lets look and see what whats going on with a system right now you can see the commit charge is already starting to kind of raise up a little bit and we can we can bump that up to a slightly higher but if we need to because its not obviously leaking very fast here and we can see that the committed bytes are going up and I can already tell I used the wrong switch sorry all hes doing is committing memory right now hes not actually writing it so lets lets stop and talk about that for a second so what hes doing is can asking the operating system to commit memory but hes not actually touching anything and the operating system is really really smart any time a process starts looking for memory either as a reservation or a commit and well talk about in the next episode when we get into fake memory and maybe like two episodes from now depending on how long this takes when you start talking about fake memory you can reserve memory and then you can also do something else called commit the memory which means that is going to be taking the commit charge at least from a performance perspective of Windows and what itll do is itll say as long as I got this stuff to give I will give it to you but its not actually taking anything in the working set and its not taking anything from a private bytes perspective used physical memory is not going up Im kind of glad I
made this mistake so that we can make this distinction now while were taking a look at it the only thing were running out is the committed bytes right and those are bytes that the OS says yes I can give you this memory yes I can give you this memory and itll continue to allow that process until the OS has nothing to give so if youve ever been in a condition where the system runs out of committed memory and starts throwing in memory errors but you had plenty of physical memory available this is this is that can go so this thing is continuing to do its its leak here you can see its still kind of getting closer and closer to the top the the current commit charges is continuing to go up a little bit and as it continues to leak well will see this commit limit or this committed by its getting up close to the total amount that the Box has because remember that you know the you know the commit charge in Windows is a little bit more than I think its I think it was two gigs initially so there theres exactly what I was looking for now Im gonna go and Im going to stop this counter were going to talk about what just happened okay so what you see here is all of a sudden he got almost to the top and then suddenly this dropped down so what happened just then as I guarantee if we look at the commit limit whats going to happen in our perf counters well see that it went up why did it go up it went up because the page file just got bigger this thing was trying to honor commit requests but it wasnt actually touching Ram this is important distinction that we have to understand here is that you can have reserved memory totally different discussion Reserve memory wont normally affect the operating system and you wont even really see it happening in these counters its a different set of counters that will pull for those that can cause a process to crash but not the OS then we have committed bites but not actually touching any memory and the operating system will refuse to actually put things in memory if you dont have anything really to put all hes doing is saying hey I need 300 Megs of RAM oh here you go heres 300 Megs of RAM but he doesnt really touch physical memory for that it just takes the program out and makes him think hes getting that more on that later then he can turn around and commit it that actually does have an impact to the system so what I forgot to do is instead of just using the leak memory we need to leak and touch memory this dash D right here so were gonna lick leak the memory this time but were actually gonna put dirty data in it were gonna actually have touchable data so now were getting this process going up were gonna go find our test limit again because obviously its a new version of test limit so here he is so well go ahead and throw him up at the top so here we go so now you can see we are in fact having an impact on the system you see that were going up here for megabytes is over standby list is getting consumed and youll notice that this graph is starting to move over towards the side a little bit as hes taking more but this time were actually taking private bytes and were taking working set and were taking committed bytes all at the same time and as it gets bigger and bigger and bigger were gonna start seeing that were used physical memory is going up and the commit charge is going up and this is important to recognize visually now and your pretty little resource monitor and we can even look at task manager as well performance and see memory is going up and up and up committed bytes are going up and up and up down down here at the description on the bottom right and we can see that weve got so much in use and available is going down and down and down so depending on what tool youre using these are the two youre probably the most familiar with the one were going to be talking about what it looks like obviously later is gonna be what it looks like the same way in perfmon so again lets talk about what the what the process test limit is actually doing right now he is going out he is reserving memory and as he is reserving that memory he is then committing and writing that memory meaning that the virtual memory manager is in fact having to take real RAM and back the data that is being written were running very quickly low on resources the used physical memory if you can see on the top graph up here is almost 200% and I apologize if Ive been pointing at things with my mouse I realized that the mouse is still not showing up correctly in the in the capture window here thats thats just because its a VM and I need to figure out somehow or some way to put a mouse pointer which Im sure itll be just as annoying but hey anyway okay so used physical memory is kind of topped out over 90% at this point in time theres a very small amount of memory that is still available and youll see the commit charge on this is continuing to increase and youll see that were still about equal on the on the amount of committed bytes by this process and the working set and private bytes okay just as I was saying that have now diverged so this is the part I was getting at as you see this this is starting to thrash over here on the little graph where it goes from green to blue note that it is starting to thrash around a bit it goes up a little bit it goes down a little bit it goes up a little bit it goes down that means things are being paged this virtual memory manager has gone through and paged out all these other processes as much as it possibly can and now its having to consume the very process thats getting there thats why theres a divergence between the committed bytes and the working set / private bytes that are going on here because there is that much of that process that have already been paged out the OS over here on the graph and commit charge the second one down youll see has now taken a dip that means we have now increased the size of the page file a bit and we are now consuming what is left of that as we come back over here to the process counter we see no were now over almost two gigs of memory that have been consumed whereas the working set which is once again the measure of physical RAM that that process is taking up is still at about 1.1 gigs so were now thrashing you see the used physical memory is almost at maximum and you can see that its kind of jumping up and down there weve taken another hot down here and commit charge meaning we have it again had to increase the size of the page file and we are continuing over here back at the process counter to see whats going on is were at two point almost three gigabytes of memory that has been taken out we can see that right here yeah right there 2.3 just surpassing that threshold and we we maintain it about 1.2 gigs of physical memory because thats all the system has to give and were continuing to leak memory when were leaking memory probably to the point now or if I try to run processes Ill try to right-click here and just go to get anything to launch its going to be very sluggish the whole system is and duress it is badly in need of resources and Ive clicked twice now and Im not getting anything off this there we go so if I were to like open up like the disk management which is fairly resource intensive its its gonna sit here and its lagging its having a little bit of trouble at the same time or graph you can see were still taking some memory and the virtual memory manager immediately pages stuff so pretty much everything that could be paged out at this point has been paged out everything on every other process that can be pulled out of memory has been moved out of place so that this little guy can continue doing his thing and steal as much as he can from the operating system and now the virtual memory manager is only able to survive because hes continuing to throw chunks and huge big old chunks of of memory into the page file to keep the system up and to keep it alive this would be what would happen on any system where you have a system managed page file and the system has the ability to increase the page file if we had limited the page file on this thing their disk managements finally starting to load if we had actually limited the page file we would have run completely out of resources earlier than this and so thats probably what were gonna try out here in a little bit eventually the system will no longer be able to to page stuff out because well run out of resources to be able to do that so we should be able to visually be able to see what you know the page file looks like if I can get system to even come up as you see the situation just keeps getting worse and worse and this is why you want to use the counter private bytes because a whole lot of this process does not even exist in I wouldnt mean to go to system protection its okay they all bring up the same dialog box it doesnt really matter so we got advanced we go to performance we go to advanced and well see that we have already taken the total paging size for all drives up to 3.6 gigs of memory and thats because this is a you know an automatically managed page size and so he sees that he has 20 gigs available so hes gonna consume disk space for quite some time before we completely and totally kill this system so he will continue in this state until he cannot continue to commit memory and so well go ahead and kill this now and well let this system breathe a little bit give the four gigs back and youll see we immediately see a drop in the commit charge and physical ram drops back off and the hard fall ups and everything else that were going on have kind of released but our standby list has been completely gutted out free memory is available everywhere because everything that was in the standby list got consumed but what can now happen is youll see prefetch is coming back and loading some programs back up for me all of the stuff that we had running that it thought would be important to us that it had to sacrifice as it has disciples available and it has resources available now its going to turn around and its gonna
start to reload those back in because it knows that I open outlook on this box a lot it knows I open word a lot on this box and so its its going to go ahead and start loading things like that back up for me and so in the system settings keep hitting system protection go into advanced and then settings and then advanced and then change and then were going to turn off the automatic page file size were gonna do a custom size well say you can start with 200 megabytes and Ill give you up to one gigabyte and well go ahead and set that well click okay were gonna go ahead and say well restart here in a minute yeah thats fine and later and so this was lets see we called that memory this was one well analyze in a moment and you know take a look at what we do with with that and so lets just because were gonna do a few of these lets go ahead and practice our skills on templates and lets make a memory mmm template and lets do a new data collector set and well call those memory tests to write from a template system performance browse out grab that sucker off the desktop and then well have a another one that we can next next finish but before we do that lets take a look at what this looked like in perfmon so go and kill that not green button go ahead and hit log files ad go out to the this PC C Drive / flogs man memory Davis data collector set one time range you can see one very long cuz its just the amount we had there so lets look at all these counters and see what they did all right percent of committed bytes and loop use and commit limit lets just start with those guys and kind of look so you can see the difference here Im going to turn my highlighter on and well go ahead and highlight percent of committed bytes and use we can see during this process we went up and we got into a thrashing example this is a absolute textbook scenario of what thrashing looks like and the other one we threw in here was the commit limit Im going to go ahead and scale that counter so we can get it in here this is a very important thing to realize as well so youll see these are exactly lined up with each other right every time that we dropped in our percent of committed by its looking like the system was doing a good job recovering what was really happening was we were increasing the size of the page file so every one of these youll see that we see a sympathetic correlative counter and thats why I like to have my percent of committed bytes and my commit limit in here that way I know where you know what happened to this box right so what happened we had a process that went through and sucked up a bunch of our resources and the system had to adjust for that as we went along so lets lets dump those out and take a look at some other interesting things here so the available megabytes will see scale that one two and see that we were here and we went down to there and then towards the end when we stopped the process we went back up so in this case we ran out of RAM and we ran out of page file so lets go back in and also oops lets go here and look at that pages per second that everybody thinks is a great counter youll see that we are in fact seeing some paging going on lets lets scale that in so we can fit it on the graph so you can see the further we went the more we were having to page we were resolving things that were being requested the hard page phone so soft page faults arent measured with this counter but this means we were looking for things they werent available so we had to go and resolve them from desk so pages per second you betcha it is a good indicator that you are out of memory but it is not the indicator you want to use in fact its its mostly there because its kind of interesting to look at I dont know why I keep clicking that okay so lets lets take a look here pages committed by its okay so just to show you the difference in these I think its very important we put that both on here so weve got the commit limit and committed bytes lets scale those and put them in here and youll see that this these two counters once again make the percent of committed bytes in use so it should not be too terribly surprising to you that the two of them kind of working together gave you a very exacting picture of what was in the counter but sometimes these are a bit more useful you can see the committed bytes continue to go up whereas the percentage looked like it was kind of waffling there and thats because this kept having to increase so committed bytes you can see is a very distinctive leak there this is a textbook 100% charted leak right here so lets go ahead and dump those out and lets go look at the paging file because I said that that was kind of an interesting thing to look at as far as usage goes you can see that we werent really using very much in the page file but towards the end of this we were and in fact if we then go in and dump in our percent of committed bytes and use youre going to see a pretty interesting little pattern there right yeah thats fairly obvious right so at this point we know for sure we run out of RAM and page file and now we need to know who done it right so we we we talked about something that ran completely out of RAM that was working set but we ran out of RAM and page file so we need to start with the private bytes of all the instances and we need to dump them in here go get total as we talked about in previous lessons delete it at this point we would not scale these counters even though theres a bunch of them glued to the top remember when they are the same counter never scale them otherwise youll wind up with a whole lot of counters that are bigger than smaller counters even though you dont want your bigger your little counters to be bigger than your big counters all scaling does is tell this thing to make it fit on the graph so were gonna instead make the graph fit the counters always keep those two separated in your mind so we go ahead and hit that okay we still not all the way on hit that were still not all the way on we hit that still no we got them all now all right so it looks like Id say 40,000 was the top so instead of a hundred thousand lets replace that with 40,000 click OK and weve got a very good indication of whats going on we might even maybe bump that by another five and there weve got it so weve got the highlighter on we can just come in here and click and find the process that that caused the problem and we can immediately see the test limit was the offending process that sucked up all of the private mites and caused a memory leak on this server and created this this issue for us so youll notice that private bytes actually were leaking in that first instance because private bytes this is very important and this is what Im going to leave us with before we move on to part 2 of this or I should say series its actually going to be the next episode private bytes measures not just the private bytes that you see here in our resource monitor right we see private it also measures committed bytes so its important to know that this is a great counter to to pick up what might have run your server aground right so I will take all of the other counters for this one and well go ahead and dump him out because we know hes the bad guy and Ill show you what the other counter looked like because it becomes very interesting here in a little bit so we go get test limit test limits test limits knock test manager just dump it in there and youll see that he did not so the first test this is really important guys I hope you hope youre catching this the first let me let me even go so far as to take this counter and take the red and make it big and bold and then well highlight the other counter so the first test was in red remember we we we ran up using test limit we ran up committed bites but never touched any memory we never touched any Ram which is why the red line doesnt go anywhere because we committing memory does not actually suck Ram off a box and in this case we can see that it did now why you might be asking yourself why does it kind of taper off well let me highlight that other guy so when I switch between these two nice blue and a thick line and say okay alright so why did that happen well the reason is because he was only able to take this much RAM right so if we if we look at that limit right about there thats as much RAM as the box had to give and so that was as much as he was able to give out at any given time so thats why the committed bytes you know in a in an instance where you have not run out of just Ram but run out of RAM and page file this is a terrific counter to have because you can see this thing is leakin and it makes it a very obvious fine for which one was the bad guy so in the next episode what were gonna do is were going to talk about processes that are just Ram and in episodes after that well be talking about virtual address space and how thats important to you both from a perspective of memory and troubleshooting from a kernel and user mode perspective so those will be the next parts in this series where were continuing to talk about RAM and so for now anyway guys its been Chris with Microsoft and as always I thank you for watching if you did find anything about this useful or interesting please take a second give it a quick like that helps other people to find this video feel free to also to subscribe to my channel that helps you if you actually found this interesting to be notified when there are any additional videos that I upload in the future we have a blog its at 9z comm and its super easy to remember that address its just the last number followed by the last letter com my blogs also got links to my facebook my LinkedIn my Twitter and my TechNet blog so anyway again as always thanks a ton for listening everybody you
slow computer, server performance, troubleshooting, perfmon, slow pc, performance monitor, Random-access Memory (Computer Peripheral), Paging
Thank you for watching all the articles on the topic EP5, Tracking RAM and Page File Exhaustion: How IT Pros (SHOULD) Troubleshoot Slow PCs and Servers. All shares of thevoltreport.com are very good. We hope you are satisfied with the article. For any questions, please leave a comment below. Hopefully you guys support our website even more.