Download
chapter 8 control ii procedures and environments n.
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 8 - Control II: Procedures and Environments PowerPoint Presentation
Download Presentation
Chapter 8 - Control II: Procedures and Environments

Chapter 8 - Control II: Procedures and Environments

189 Vues Download Presentation
Télécharger la présentation

Chapter 8 - Control II: Procedures and Environments

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Chapter 8 - Control II: Procedures and Environments Louden, 2003

  2. Three major parts of a runtime environment: • Static area allocated at load/startup time. Examples: global/static variables and load-time constants. • Stack area for execution-time data that obeys a last-in first-out lifetime rule. Examples: nested declarations and temporaries. • Heap or dynamically allocated area for "fully dynamic" data, i.e. data that does not obey a LIFO rule. K. Louden, Programming Languages

  3. Procedure Overview • When functions are “first class” data items themselves, they can be dynamically created and used like values just like any other data structure. • Thus, we need to be able to pass functions as arguments • A procedure is called or activated. • Activation record: collection of data needed to maintain a single execution of a procedure. • Worry about local and non-local references. • Static or dynamic environment (depending on scoping) must be accessible. • When a procedure depends only of parameters and fixed language features – closed form. • The code for a function together with its defining environment is called closure – as we can resolve all outstanding non-local environments. K. Louden, Programming Languages

  4. Implementing “Simple” Subprograms • Call Semantics: 1. Save the execution status of the caller (calling environment) 2. Carry out the parameter-passing process by putting the parameters somewhere that the called function can access. 3. Pass the return address to the callee 4. Transfer control to the callee K. Louden, Programming Languages

  5. Implementing “Simple” Subprograms • Return Semantics: 1. If it is a function, move the functional value to a place the caller can get it 2. Restore the execution status of the caller 3. Transfer control back to the caller K. Louden, Programming Languages

  6. Implementing “Simple” Subprograms • Required Storage: Status information of the caller, parameters, return address, and functional value (if it is a function) • The format, or layout, of the noncode part of an executing subprogram is called an activation record • An activation record instance is a concrete example of an activation record (the collection of data for a particular subprogram activation) K. Louden, Programming Languages

  7. An Activation Record for “Simple” Subprograms (no scoping issues) K. Louden, Programming Languages

  8. Code and Activation Records of a Program with “Simple” SubprogramsIf there is no recursion, we can have static activation records.If we have no non-local variables, everything we need is local and easy to find. K. Louden, Programming Languages

  9. Parameter Passing • Aliases may be created • Type checking parameters • a formal reference parameter is a nonlocal variable • the same data object passed for two parameters CALL S(X,X) • With aliasing, interesting problems in optimizations occur. K. Louden, Programming Languages

  10. Models of Parameter Passing K. Louden, Programming Languages

  11. 1. Pass-by-value (in mode) • Typically we copy the value in, but can do with a constant reference pointer. • Parameters are viewed as local variables of the procedure (with initial values given by values of arguments in the call) • Note can still change values outside procedure if we pass a reference. • Disadvantages of copy: • Requires more storage (duplicated space) • Cost of the moves (if the parameter is large) • Disadvantages of constant reference: • Must write-protect in the called subprogram or compiler check that there are no assignments. • Accesses cost more (indirect addressing) K. Louden, Programming Languages

  12. 2. Pass-by-result (out mode) • function return value • Local’s value is passed back to the caller • Physical move is usually used (copy to call stack) • Disadvantages: • If value is passed, time and space • order dependence may be a problem • If return value is an address, when is it evaluated? e.g. procedure sub1(y: int, z: int);{y=0;z=5; } sub1(x, x); • Value of x in the caller depends on order of assignments at the return K. Louden, Programming Languages

  13. OUT only parameters • formal parameter is a local variable with no initial value • copied back at termination of subprogram Pass by result • Explicit function Values: may be considered an extra OUT parameter • return(expr) • value to be returned by assignment to function name • if return is an address (e.g., list[index]), when is it evaluated? time of call? time of return? K. Louden, Programming Languages

  14. 3. Inout mode • Pass by value-result (aka copy-in copy-out or copy-restore) Physical move, both ways • value-result (or pass by copy) • Disadvantages • ordering may be a problem with a call like doit(x,x) • time/space issues • Need to know whether address is computed again before copying back. doit(i,a[i]) K. Louden, Programming Languages

  15. IN OUT parameters • Value-restore. Copy value in on call Copy changed value back on return. • Used to save cost of indirect access. • aliases may be problematic - especially likely if pass same parameter twice. Then if arguments are changed, original values may be changed differently depending on order of change (if value-restore) K. Louden, Programming Languages

  16. 4. In-out mode - pass by reference. Issues: • access is slower (as indirect) • passing is faster • called program can access parameter through alias • Array element collisions: e.g. sub1(a[i], a[j]); /* if i = j */ Also, sub2(a, a[i]); (a different one) • Collision between formals and globals • Root cause of all of these is: The called subprogram is provided wider access to nonlocals than is necessary K. Louden, Programming Languages

  17. IN OUT parameters • transmission by reference formal parameter is local object of type pointerIf expression is passed as an in/out parameter: a temporary location may be passed(and then the copy is changed, not the original) • Disadvantages: • access slower as is indirect (always follow a pointer to access), but passing is fast (only copy a pointer, not a whole structure) • may make inadvertent changes to parameters (if out only was desired) K. Louden, Programming Languages

  18. Parameter Passing Methods 5. Pass-by-name (Unevaluated parameters) • By textual substitution • intended to be an advanced inlining • essentially like late evaluation • Name of t he argument (or its textual substitution at the point of call) replaces the name of the parameter it corresponds to. • Formals are bound to an access method at the time of the call, but actual binding to a value or address takes place at the time of a reference or assignment • Purpose: flexibility of late binding K. Louden, Programming Languages

  19. Pass-by-name Resulting semantics: • If actual is a scalar variable, it is pass-by-reference • If actual is a constant expression, it is pass-by-value • If actual is an array element, it is like nothing else e.g. procedure sub1(x: int; y: int); begin x := 1; Seems like nothing is happening y := 2;with first assignments but it is x := 2; y := 3; end; sub1(i, a[i]); K. Louden, Programming Languages

  20. 5. Pass-by-name (continued) • If actual is an expression with a reference to a variable that is also accessible in the program, it is also like nothing else e.g. (assume k is a global variable) procedure sub1(x: int; y: int; z: int); begin k := 1; y := x;k := 5;z := x; end; sub1(k+1, j, a[i]); Thunks: pass by name arguments are implemented by little procedure which evaluate the arguments. Presumably the image was of little machines that “thunked” into place each time they were needed. K. Louden, Programming Languages

  21. Parameter Passing (In Mode) • Pass-by-name: text for argument is passed to subprogram and expanded in each place parameter is used • Roughly same as using macros • Note, you can’t evaluate late without having “code” to execute • You also need to know a context for evaluating non-local variables • Achieves late binding K. Louden, Programming Languages

  22. Pass-by-name Example integer INDEX= 1; integer array ARRAY[1:2] procedure UPDATE (PARAM); integer PARAM begin PARAM := 3; INDEX := INDEX + 1; PARAM := 5; end UPDATE(ARRAY[INDEX]); K. Louden, Programming Languages

  23. Pass-by-name Example • Previous code puts 3 in ARRAY[1] and 5 in ARRAY[2] • How is this accomplished if the compiled code must work for ANY argument that is passed? • PARAM must be something that has a value, but can be x, Array[x+y], Array[2*t[6*x]+7] • How can you generate code for UPDATE when you don’t know what is passed? • If pass by name argument appears on left hand side, need to be able to compute the address. • If pass by name argument appears on right hand side (of assignment), need to be able to compute a value. K. Louden, Programming Languages

  24. New interest in functional languages means more interest in delayed evaluation. • Very flexible, but inefficient. Difficult to implement. Confusing to read/write. • Some simple operations are not possible with pass by name. • Lazy evaluation is another form of late binding. Only evaluate when it becomes necessary. • Substitute name or expression (in calling environment) for formal parameter • The name location binding is delayed until (and established fresh each time) the formal parameter is encountered. • Implemented by passing parameter-less subprograms (thunks) rather than variable name. An expression needs to be evaluated IN the proper environment. Don't have mechanism to do that other than thru procedure call. • Whenever formal parameter is referenced, a call is made to thunk, which evaluates the parameter in the proper (caller) environment and returns proper resulting value (or location) K. Louden, Programming Languages

  25. Example: procedure R(var i,j: integer); begin var m:boolean; m := true; i := i + 1; j := j + 1; write(i,j); end; m := 2; for(i=0;i<10;i++) c[i]=10*i; R(m,c[m]); • pass by reference: adds 1 to m and c[2]Pass by name: adds 1 to m and c[3] K. Louden, Programming Languages

  26. Example for Pass by Name b1: begin real x,y; y := 0.0; procedure G(t): name t; begin integer w; integer x; w := 10; y := 20; x := 50 print t x:= 0; print t end G; b2: begin real y; y := 0.5; x := 1.0; call G(y-x) end end thunk() return(y-x) end; K. Louden, Programming Languages

  27. Parameter Passing Methods • Disadvantages of pass by name: • Very inefficient references • Too tricky; hard to read and understand K. Louden, Programming Languages

  28. Parameter Passing Methods • Multidimensional Arrays as Parameters • If a multidimensional array is passed to a subprogram and the subprogram is separately compiled, the compiler needs to know the declared size of that array to build the storage mapping function • Programmer is required to include the declared sizes of all but the first subscript in the actual parameter • This disallows writing flexible subprograms • Solution: run time descriptor K. Louden, Programming Languages

  29. Parameter Passing Methods • Design Considerations for Parameter Passing 1. Efficiency 2. One-way or two-way • These two are in conflict with one another! • Good programming => limited access to variables, which means one-way whenever possible • Efficiency => pass by reference is fastest way to pass structures of significant size • Also, functions should not allow reference parameters K. Louden, Programming Languages

  30. Languages and Environments • Languages differ on where activation records must go in the environment: • Fortran is static: all data, including activation records, are statically allocated. (Each function has only one activation record—no recursion!) • Functional languages (Scheme,ML) and some OO languages (Smalltalk) are heap-oriented: all (or almost all) data, including activation records, are allocated dynamically. • Most languages are in between: data can go anywhere (depending on its properties); activation records go on the stack. K. Louden, Programming Languages

  31. x y w Simple stack-based allocation • Described in Chapter 5. • Nested declarations are added to the stack as their code blocks are entered, and removed as their code blocks are exited. • Example: Stack at Point 1:{ int x; int y; { int z; } { int w; // Point 1 }} • Note ,z has been removed at point 1 as have exited scope K. Louden, Programming Languages

  32. Example (C): main →q →p int x; void p( int y) { int i = x; char c; ... } void q ( int a) { int x; p(1); } main() { q(2); return 0; } K. Louden, Programming Languages

  33. © 2003 Brooks/Cole - Thomson Learning™ Activation record of p: K. Louden, Programming Languages

  34. © 2003 Brooks/Cole - Thomson Learning™ Environment stack during exec of p: main →q →p(stack is shown growing down) Note: the ep in this picture actually points to the "bottom" of the frame, as do the control links (which are stored old ep values), so ep  top of stack. K. Louden, Programming Languages

  35. Local variable access using the ep • In a typical language with a stack-based runtime environment, the local declarations in a procedure are fixed at compile-time, both in size and in sequence. • This information can be used to speed up accesses to local variables, by precomputing these locations as offsets from the ep. • Then the local frame need not have a name-based lookup operation (unlike the symbol table). • In fact, names can be dispensed with altogether. • The next slide shows how that would look for the procedure p of slide 7. K. Louden, Programming Languages

  36. Non-local variable access • Requires that the environment be able to identify frames representing enclosing scopes. • Using the control link results in dynamic scope (and also kills the fixed-offset property as you are not sure which method will contain the x. Thus, you can’t depend on a fixed location). • If procedures can't be nested (C, C++, Java), the enclosing scope is always locatable by other means: it is either global (accessed directly) or belongs to the current object. • If procedures can be nested, to maintain lexical scope a new link must be added to each frame: the access link, pointing to the activation of the defining environment of each procedure. K. Louden, Programming Languages

  37. Example (Ada-like) q→r → p → z → z: 1 procedure q is • x,u: integer • procedure p (y: integer) is • i: integer := x; • procedure z(t:float) returns float is • m: float; • begin • if (t >5) return z(t/2); • return t+m/i*y + u/x; • end z; • begin ... • end p; • procedure r (u:integer) is • x: float; • begin • p(1);... • end r; • begin • r; • end q; K. Louden, Programming Languages

  38. © 2003 Brooks/Cole - Thomson Learning™ Environment during exec of p: K. Louden, Programming Languages

  39. Nested Subprograms • The process of locating a nonlocal reference: 1. Find the correct activation record instance 2. Determine the correct offset within that activation record instance May need to follow several links (access chaining) The number of links is known from compile time. If used stack of symbol tables, can count how many tables you had to search to find it. If used individual stacks for each value, you can record the nesting depth of each variable. K. Louden, Programming Languages

  40. Procedure values as pointer pairs • With nested procedures in lexically scoped languages requiring an access link, when a procedure is called, this access link must be available at the point of call. One way it can be is for the procedure itself to record its access link (necessary if procedures can be parameters). • Then each procedure becomes a pair of pointers: a code pointer (called the instruction pointer or ip in the text), and an environment pointer (ep in the text) pointing to the definition environment of the procedure (which will become the access link during a call). • Such an <ep,ip> pair is sometimes called a closure. K. Louden, Programming Languages

  41. Fully dynamic environments • Languages with lambdas or where functions can be created locally and returned from a call (ML, Scheme). • Activation records cannot in general be popped after a call. Thus, activations no longer behave as LIFO structures and must be allocated in the heap. • Control links make little sense, since each control link might have to point far back in the stack. • Access links and closures still make perfect sense, however. K. Louden, Programming Languages

  42. Implementing Subprograms in ALGOL-like Languages • The collection of dynamic links in the stack at a given time is called the dynamic chain, or call chain • Local variables can be accessed by their offset from the beginning of the activation record. This offset is called the local_offset • The local_offset of a local variable can be determined by the compiler • Assuming all stack positions are the same size, the first local variable declared has an offset of three plus the number of parameters, e.g., in main, the local_offset of Y in A is 3 K. Louden, Programming Languages

  43. The Process of Locating a Nonlocal Reference • Finding the offset is easy • Finding the correct activation record instance: • Static semantic rules guarantee that all nonlocal variables that can be referenced have been allocated in some activation record instance that is on the stack when the reference is made K. Louden, Programming Languages

  44. Nested Subprograms • Technique 1 - Static Chains • A static chain is a chain of static links that connects certain activation record instances • The static link in an activation record instance for subprogram A points to one of the activation record instances of A's static parent • The static chain from an activation record instance connects it to all of its static ancestors K. Louden, Programming Languages

  45. Static Chains (continued) • To find the declaration for a reference to a nonlocal variable: • You could chase the static chain until the activation record instance (ari) that has the variable is found, searching each ari as it is found, if variable names were stored in the ari • Def: static_depth is an integer associated with a static scope whose value is the depth of nesting of that scope K. Louden, Programming Languages

  46. Static Chains Show the static/dynamic chains when main →C →A →B →C main ----- static_depth = 0 A ----- static_depth = 1 B ----- static_depth = 2 C ----- static_depth = 1 K. Louden, Programming Languages

  47. Static Chains (continued) • Def: The chain_offset or nesting_depth of a nonlocal reference is the difference between the static_depth of the reference and that of the scope where it is declared • A reference can be represented by the pair: (chain_offset, local_offset) where local_offset is the offset in the activation record of the variable being referenced K. Louden, Programming Languages

  48. Nested Subprograms • Static Chain Maintenance • At the call : • The activation record instance must be built • The dynamic link is just the old stack top pointer • The static link must point to the most recent ari of the static parent (in most situations) • Two Methods to set static chain: 1. Search the dynamic chain until the first ari for the static parent is found--easy, but slow K. Louden, Programming Languages

  49. Nested Subprograms 2. Treat procedure calls and definitions like variable references and definitions (have the compiler compute the nesting depth, or number of enclosing scopes between the caller and the procedure that declared the called procedure; store this nesting depth and send it with the call) • e.g. Look at MAIN_2 and the stack contents. At the call to SUB1 in SUB3, this nesting depth is 1, which is sent to SUB1 with the call. The static link in the new ari for SUB1 is set to point to the ari that is pointed to by the second static link in the static chain from the ari for SUB3 K. Louden, Programming Languages

  50. Nested Subprograms • Evaluation of the Static Chain Method • Problems: 1. A nonlocal reference is slow if the number of scopes between the reference and the declaration of the referenced variable is large 2. Time-critical code is difficult, because the costs of nonlocal references are not equal, and can change with code upgrades and fixes K. Louden, Programming Languages