CSE 3302 Notes 5: Memory Management

Transcription

1 CSE 0 Notes 5: Memory Management (Last updated 10/7/15 1:6 PM) References: Gabbrielli-Martini: 5 Wirth: IMPLEMENTING SIMPLE SUBPROGRAMS Historical FORTRAN and COBOL Simple = no recursion static allocation minimal call-by-value call-by-reference for anything non-trivial If program starts, it will have enough memory Gabbrielli, figure one activation record per subprogram Layout of activation record (a.r., stack frame), register conventions mandated by vendor Who saves registers? - caller or callee? 5.. IMPLEMENTING SUBPROGRAMS WITH RUN-TIME STACK PL/0 Calling Sequence: Caller cal l,a: call procedure a (absolute address) at level l cal: begin {generate new block mark} s[t + 1] := base(l); { static link for nested procs } s[t + ] := b; { dynamic link to caller proc } s[t + ] := p; { return address } b := t + 1; { new base of stack frame p := a { new program counter } Dynamic link is needed for C; Pascal and PL/0 also need static (i.e. lexical scope) link for immediate containing procedure.

2 Called Pascal-S jmp over any instructions for any nested procedures int 0,a : increment t-register by a { a includes slots for cal } Return Sequence Called int: t := t + a; { allocate stack frame including sl, dl, ra } opr 0,a : execute operation a (=0 here) Caller does nothing special opr: case a of {operator} 0: begin {return} t := b - 1; { discard stack frame } p := s[t + ]; { return to caller } b := s[t + ]; { old base address } Interpreter addressing is done using display array to avoid cost of base function. 5.. REFERENCING STACK-DYNAMIC LOCAL VARIABLES FOR NESTED SUBPROGRAMS A nested subprogram may potentially reference local variables for subprograms that contain it. Two difficulties (that also interact): 1. Calls among nested subprograms at same level.. Recursion For a given variable (under lexical/static scoping), the most recent invocation of each containing subprogram is the one whose activation record is needed. (The outermost scope is level 0. Nested scopes have increasing level numbers.) There is exactly one activation record per level in the (ascending) static chain. PL/0 Assumption - non-local data is rarely accessed, simple solution is sufficient Referencing is based on: Compiler computes level difference to put into lod, sto, and cal instructions cal instruction sets saved static link (s[t + 1]) to point at next level a.r.

3 Level difference is used with loop to follow static links: instruction = packed record f: fct; {function code} l: 0..levmax; {level} a: {0..amax} integer {displacement address} function base(l: integer): integer; var b1: integer; begin b1 := b; {find base l levels down} while l > 0 do begin b1 := s[b1]; l := l - 1 base := b1 end {base}; To help with optimizing code, compilers may use a sequence of indirections. 0 var a; 1 1 procedure b; 1 1 var c,d; procedure e; var f,g,h; begin 4 a:=1; 6 c:=; 8 d:=; 10 f:=4; 1 g:=5; 14 h:=6; 16 call e; 17 call b begin 0 a:=7; c:=8; 4 call e; 5 call b begin 8 a:=9; 0 if 0=1 then call b 5 end. start pl/0 end pl/0 0 jmp 0 7 These jmp s get compiled in block with gen(jmp,0,0), but are patched 1 jmp 0 19 when the start addresses are known. (Just before statement is called in block.) jmp 0 int 0 6 code for e 4 lit sto 5 a 6 lit 0 7 sto 1 c 8 lit 0 9 sto 1 4 d 10 lit sto 0 f 1 lit sto 0 4 g 14 lit sto 0 5 h 16 cal 1 e 17 cal 1 b 18 opr 0 0 return 19 int 0 5 code for b 0 lit sto 1 5 a lit 0 8 sto 0 c 4 cal 0 e 5 cal 1 19 b 6 opr 0 0 return 7 int 0 6 code for unnamed driver 8 lit sto 0 5 a 0 lit lit 0 1 opr 0 8 = jpc cal 0 19 b 5 opr 0 0 return

4 0 var aout,result; b=1 p=9 initial result 1 procedure a(ain); var bout; 0 ret adr procedure b(bin); 0 d.l. var cout; b=8 p=9 after call to a 1 0 bout procedure c(cin); 11 1 ain ret adr 4 begin 9 1 d.l. 5 cout:=cin+8; 8 1 s.l. 9 result:=ain+bin+cin result 15 4 int 0 4 code for c 5 lod 0 cin 6 lit ret adr 7 opr d.l. 8 sto 1 4 cout 9 lod ain b=1 p=19 after call to b 10 lod 1 bin 17 0 cout 11 opr bin 1 lod 0 cin 15 ret adr 1 opr d.l. 14 lit s.l. 15 opr bout 16 sto 6 result 11 1 ain 17 opr 0 0 return 10 4 ret adr 18 begin 9 1 d.l. 19 call c(4); 8 1 s.l. bout:=bin+cout 7 0 result 5 18 int 0 5 code for b 19 int 0 push args(s) for c 0 lit ret adr 1 int 0-4 -(+number of args) 0 d.l. cal 0 4 c lod 0 bin b=18 p=5 after call to c 4 lod 0 4 cout 1 4 cin 5 opr ret adr 6 sto 1 4 bout 19 1 d.l. 7 opr 0 0 return 18 1 s.l cout 8 begin 16 bin 9 call b(); 15 ret adr aout:=ain+bout 14 8 d.l s.l. 8 int 0 5 code for a 1 0 bout 9 int 0 push args(s) for b 11 1 ain 0 lit ret adr 1 int 0-4 -(+number of args) 9 1 d.l. cal 0 18 b 8 1 s.l. lod 0 ain 7 0 result 4 lod 0 4 bout 5 opr sto 1 5 aout 7 opr 0 0 return 0 ret adr 8 0 d.l. 8 begin 9 call a(1); 4 out:=aout; 45 out:=result 46 end. start pl/ end pl 8 int 0 7 code for unnamed driver 9 int 0 push args(s) for a 40 lit int 0-4 -(+number of args) 4 cal 0 8 a 4 lod 0 5 aout 44 wro lod 0 6 result 46 wro opr 0 0 return 4

5 0 procedure iloop(i); 41 int 0 4 lit 0 0 procedure jloop(j); 4 int cal 0 4 kloop procedure kloop(k); 45 lod 0 j 4 46 lit begin 47 opr 0 8 = 5 k:=k+1; 48 jpc out:=i+j+k; 49 int 0 15 if k< then 50 lod 1 i 18 call kloop(k); 51 int 0-4 if k= then 5 cal 1 iloop 6 call jloop(j) 5 opr 0 0 return int 0 4 kloop code 54 begin 5 lod 0 k 55 i:=i+100; 6 lit if i<00 then 7 opr call jloop(0) 8 sto 0 k 67 9 lod i 54 int 0 4 iloop code 10 lod 1 j 55 lod 0 i 11 opr lit lod 0 k 57 opr opr sto 0 i 14 wro lod 0 i 15 lod 0 k 60 lit lit 0 61 opr 0 10 < 17 opr 0 10 < 6 jpc jpc 0 6 int 0 19 int 0 64 lit lod 0 k 65 int int cal 0 jloop cal 1 4 kloop 67 opr 0 0 return lod 0 k 68 4 lit 0 68 begin 5 opr 0 8 = 69 call iloop(0) 6 jpc end. 7 int 0 68 int lod 1 j 69 int 0 9 int lit cal jloop 71 int opr 0 0 return 7 cal 0 54 iloop 7 opr 0 0 return begin b=6 p=15 (after out:=i+j+k;) j:=j+10; 65 k ******** 7 if j<0 then 64 ret adr 40 call kloop(0); 6 58 d.l. 45 if j=0 then 6 54 s.l. 48 call iloop(i) 61 1 k ret adr int 0 4 jloop code d.l. lod 0 j s.l. 4 lit j ******** 5 opr ret adr 6 sto 0 j d.l. 7 lod 0 j 54 8 s.l. 8 lit k 9 opr 0 10 < 5 ret adr 40 jpc d.l s.l k ret adr 47 4 d.l s.l j ret adr 4 8 d.l. 4 8 s.l i ******** 40 5 ret adr 9 4 d.l. 8 1 s.l. 7 0 j 6 1 ret adr 5 0 d.l. 4 6 s.l. k ret adr 1 6 d.l. 0 s.l. 9 1 k 8 45 ret adr 7 d.l. 6 s.l. 5 0 j 4 1 ret adr 18 d.l. 6 s.l. 1 k 0 ret adr d.l s.l k ret adr d.l s.l j 1 67 ret adr 11 6 d.l s.l i 8 7 ret adr 7 1 d.l. 6 1 s.l. 0 ret adr 0 d.l. start pl/ Heap(-Dynamic) Allocation Most flexible temporally (Historical) Pascal implementation - same space as stack, Buddy systems - maintain available blocks of size k for various k (aside - use Fibonacci sequence with arbitrary starting pair to approach ratio)

6 One or many free lists? 6 Many - Start with list of closest adequate size, continuing through lists for larger sizes until non-empty list is found Fragmentation One - ordered or unordered by size?, first fit or best fit? External - unallocated space between allocated blocks Internal - extra space inside allocated block Compaction is a possible when pointer flexibility is restricted for purposes of garbage collection Implementing Display as Alternative to Traversing Static Chain Concepts: Gabbrielli Makes no assumption regarding locality of references Instructions include absolute level and offset No static chain traversals... since number of scope levels is small, each access references the display. Trivial implementations use expensive approach of rebuilding the entire display for each call (just use the base loop). (Caches on modern machines lessen the performance advantage of displays) Every call saves and modifies one slot of the display. Every return restores one slot of the display. pl0.display..js at has details - see base, cal and return processing for differences Pascal-S aside (section 4 of report) Every call saves and modifies one slot of the display. Returns on callee side do not restore any display slots. A nested caller for an outer procedure will restore as many display slots as levels - after return