Save Caller Required with airSlate SignNow

Save esign caller

hi I'm Matthew today we're going to be talking about color and Kali save registers so the reason we need to have color and Kali save registers is because when you're writing functions in C your arm or whatever you only have a limited number of registers on a typical CPU of 32 registers and not even all of those are going to use for storing data so when you're writing a function you want to be able to use all those registers but you don't know which registers may have been used by the function that calls your function you also don't know if your function calls another function if that other function may need to use some of those same registers so color and Colley's save is an agreement between everybody who writes are more like writes C or C compilers to use specific registers in specific ways and to assign whose job it is to save the value in a register to memory and then restore it at the end so that if I'm writing a function that uses the same register as a function that I call Aveling that I have in my register will be saved to memory before the function that I call runs it will do whatever it needs to and then my value will be restored to memory once the function returns back to my function so again it's more so about whose job it is to store the value and register to data and then restore it in a caller say register the registers that we signify our caller save it's the function that calls another functions job to save the value to memory in a register and then restore it at the end if it will need that value after the function call and then in a call we save register it is the job of the function that is called to save the value that was in a register before its function executed and then restore it right before returns if it needs that register and so I'm going to go through an example of having color and Kali save registers and how many times specific variables would be voted and stored from memory under a specific function call so now we're going to go over an example of a sample program here where we're going to keep track of the number of times each of the variables is saved under both color save and Kelis it so first let's assume that all of our variables are stored in color safe registers we have these three variables a b and c that are in main and then main calls this function foo which has an argument that is passed in when an argument is passed in as a function parameter it does count as a local variable within that function for what we're doing these color calling save problems and so this function foo has two variables Arg and X and so if we first assume all of our registers are color saved that means we only need to save them when they're live across a function call so it's start off in main here we go and we see when the first function call is the first function we call is foo we call foo with bar now which variables do we need to save across that function call among a B and C so we do after this function call use the value of a again eventually and we're never going to be completely reassigning the value of eight before we use the value of a so a needs to be saved at least once over this code to food we do use the value of B immediately after without reassigning it so we also need to say B over this call to foo but the value of C we immediately reassign the value C after foo returns so we don't need to save the bail you'll see that we had and restored after the function is call since we're just going to be completely reassigning it afterwards so we don't need to say C in this case so it takes care of this foo function now it's going to this printf function you need to do color saving every single time you call a function even if it's not a function that you defined and so we have this printf function which variables are live over that function call a again we use the value of a again after the function is called and we don't completely reassign it in the meantime be we never actually used the value of being at in this program so it doesn't matter if we save and restore the value that we had we don't care about its value anymore so we don't need to bother call these color saving it I wrote these over here but I'm going to start writing them over here now because I have more room save a and then see I do need to have the bellow you see again because I immediately start using the value C as it wasn't as well so one saved for C across this prints f1 say for egg and I'm let's say for a heater one safer be here so this is the telly as it stands right now and now we enter this while loop so now we actually need to worry about what the values of a and C bar a we can assume is initialized to zero and actually I suppose it doesn't matter what the value is we really only care about the value of C because that's what's controlling our while loop C we set equal to foo of B and foo if it has a positive number we'll have it and then return that value so this stage of the program C is equal to five and what this loop is actually going to do is it will send C equal to C meaning that it would have it again it would run once when C is equal to five good run once when C is equal to run once when C is equal to one and then it would return zero it would see that C is equal to zero and it would exit the loop so this loop is going to be run three times and in this loop we call two different functions so whatever it saves in stores we do saves the source whatever saves and low as we do in one execution we can just multiply by free one we're telling them all up so printf initially we need to worry about whether or not we're saving without of a and the value of C over that function call we are going to using the value of C afterwards and we are going to be using the a afterwards so both AMC need to be saved across this function call and then down here we don't need to save the value of C because we immediately reassign the value of C after this function returns but we do need to save a because the value of a is used afterwards we're going to eventually be returning a to so every time this one executes we save a twice and we say C once over these function calls so and we execute three times so we're going to be adding on six more tallies to a and we're going to be adding three more talents to C and this is eight so overall we're going to storing a eight tons be one time and C four times so now it's tally up how many times the variables with the color safe under working into food food remember is called four times over the course of this entire program ones here with an argument of ten and then once with an argument of five once with Mike - once with a negative one so every time we execute this function we're going to be inputting a positive number here as Arg ten five - mmm one and so we're always going to get to this part of the if statement where R is greater than zero and we're just going to run these lines of code this line and this line of code at the top and so among these two variables that we have we only have one function call that we need to worry about whether we're saving the value of them over and so do we use the value of Arg after this function call yes because we use it as part of what we're son to X so every time we run this function we need to save Arg over this printf statement but we don't need to save the value of x because right now can printf statement we reassign the value of x without ever actually using the value of x in the meantime so we never need to save the value of x and Arg we need to save four times and so overall in this program you would save a safe through sort a eight times the same resort beat one time saving restore see four times saving restore are four times and you wouldn't save and restore tax at all if all of them were stored at color safe registers and I would through on to the call be saved part of this problem if we assume that all of our variables were in called leave save registers it actually becomes a lot simpler you only need to do call be saving at the very beginning of a function and then you would restore the variables at the very end of the function so you only have one save in store per variable per function call and it's even easier when you're in Maine it's a thing about Maine that you need to remember is that you never need to call these save variables in Maine because you can assume that Maine is the first function that was called by the operating system so there are no other functions that would have called name that would need their variables Kaali saved so when we're running Maine none of a B and C need to be Kaali saved because we are in Maine so all of those would be 0 if this was some function other than me all of those would just be saved once for the one time with the function which is called and now we move on to foo-foo we call again four times over the course of this entire program and it would Kali saves both Argan x one time at the beginning and one tyranny at the end again it's just the number whatever our variables are declared within this function all of them will have one call the same one colleagues restore at the end and so we call through four times so hard is going to be saving restored for x and x is going to save restored four times at the beginning and then they'll be restored immediately at the end and now what's assumed so this is the answer to the problem of call me saving registers you'll have a total of eight lives and stories over the whole program instead of total of 17 loads and stories of the whole program so overall it seems like Kali saving it's better in general especially when we're working in Maine because we never need to call me save variables in Maine no matter how many functions we call it the meantime now it's assumed that our CPU only had two Kali save registers and two color safe registers that limitation only applies per function because again the point of Kali and Culver City is that we can reuse whatever registers we want when we go into a different function so when we're limited when we have a question that tells us that we're limited in the number of color e---coli save registers that we have we only need to apply that limitation to a single function at a time and so if we're just looking at ABC ABC and we need to decide to distribute them between only two colors save registers and to Kali saver to students we want to put as many implements we can need to call these save registers because we don't need to store them at all but we can't store all of them because we only have to call these a bunch of students so we need to decide one of them that can go on a Colo save register and the best candidate for that is being because we would only need to save B once and then we can put a and C in Kali save registers and then if we're looking at foo the variables in foo we probably want to put X in a caller say register because we never needed to store it when we were doing color and in this case it doesn't really matter if we put Arne in a caller or call we say register and since it was for loads and stores in either case so let's just put it in a color say about to start and call it a day so at minimum if you had only two colors say to call me saver to stores you could get down to a case where you only save and restore five times over the course of this entire program and that is a general overview of color Kali saving hopefully they'll give you a good idea of what you need to do when you have to tackle these sorts of problems in homeworks and exams