Procedures

1
Procedures
2
Procedure Definition

• A procedure is a mechanism for abstracting a
  group of related operations into a single
  operation that can be used repeatedly without
  repeating the code
• The group of operations is called the body of the
  procedure
• A procedure is defined by providing a
  specification or interface and a body
• The specification gives the procedure name, a
  list of types and names of parameters, and the
  type of its returned value

3
An Example
void intswap (int x, int y) //
specification // body begins int t
x x y y t // body ends void
intswap (int , int ) // specification only
4
Procedure Activation

• A procedure is called or activated by stating its
  name, together with arguments to the call, which
  correspond to its parameters
• A call to a procedure transfers control to the
  beginning of the body of the called procedure
  (the callee)
• When execution reaches the end of the body,
  control is returned to the caller
• Control can also be returned to the caller before
  reaching the end of the body by using
  return-statements

5
Environments

• A procedure communicates with the rest of the
  program through its parameters and also through
  nonlocal references
• The defining (or static) environment is the
  environment defining the meaning of nonlocal
  references
• The calling (or dynamic) environment is the
  environment defining the meaning of the caller

6
Environments
int a, bint q(int d) int e int p(int
c) int a q(a) main() int b p(a)
a, b globalb main a, c pd, e q
7
Environments

• In static scoping, a procedure can communicate
  with its defining environment through nonlocal
  references or parameters
• In static scoping, a procedure can communicate
  with its calling environment through only
  parameters
• In dynamic scoping, the defining environment is
  the same as the calling environment

8
Parameter Passing

• Pass by value
• Pass by reference
• Pass by value-result
• Pass by name

9
Pass by Value

• Arguments are expressions that are evaluated at
  the time of the call, and their values become the
  values of the parameters during the execution of
  the procedure
• Parameters are viewed as constant values given by
  the values of the arguments, or
• Parameters are viewed as local variables with
  initial value given by the values of the arguments

10
An Example
void init_p(int p) p 0 void
init_ptr(int p) p (int ) malloc(sizeof(int))
void init_p_0(int p ) p0 0 void
append_1(Vector v) v.addElement(new
Integer(1)) void make_new(Vector v) v new
Vector()
error!
error!
11
Pass by Reference

• An argument must in principle be a variable with
  an allocated address. Instead of the value, the
  location of the variable is passed to the
  parameter
• The parameter becomes an alias of the argument.
  Any changes made to the parameter occur to the
  argument as well

12
An Example
int a void inc(int x) x inc(a)void
inc(int x) (x) inc(a)void yuck(int
x, int y) x 2 y 3 a 4 yuck(a, a)
void inc(int x) x inc(2)
an error in C!
ok in Fortran!
13
Pass by Value-Result

• The value of the argument is copied and used in
  the procedure, and then the final value of the
  parameter is copied back out to the location of
  the argument when the procedure exits
• This method is also known as copy-in, copy-out,
  or copy-restore
• A language may offer a pass by result method, in
  which there is no incoming value, but only an
  outgoing value

14
An Example
void p(int x, int y) x y main(
) int a 1 p(a, a)
a 3 for pass by reference
a 2 for pass by value-result
15
Pass by Name

• The semantics of procedures is described by a
  form of textual replacement
• An argument is not evaluated until its actual use
  in the called procedure. The name (or textual
  representation) of the argument replaces the name
  of the corresponding parameter at the point of
  call
• It turns out that pass by name is essentially
  equivalent to the normal order evaluation

16
An Example
int iint a10void p(int x) i x
main( ) i 1 a1 1 a2 2
p(ai) return 0
/ i 1, a2 2 / i / i 2 /
ai / a2 3 /
17
Pass by Name

• The text of an argument at the point of call is
  viewed as a function in its own right, which is
  evaluated every time the corresponding parameter
  name is reached in the called procedure
• The argument will always be evaluated in the
  calling environment, while the called procedure
  will be executed in its defining environment

18
An Example
int iint p(int y) int j y i return j
y int q(void) int j 2 i 1
printf(d\n, p(i j)) main() q( )
return 0
i j ? 3
i j ? 4
19
An Example
int i, jint i_plus_j(void) return i j
int p(int (y) (void)) int j y() i
return j y() int q(void) j 2 i 1
printf(d\n, p(i_plus_j)) main() q( )
return 0
thunk
20
An Example
void intswap(int x, int y) int t x x y y
t intswap(i, ai)
t i i ai ai t
21
Fully Static Environments

• In Fortran 77, function and procedure definitions
  cannot be nested
• Recursion is not allowed
• The locations of all variables are fixed for the
  duration of program execution

22
Fully Static Environments
COMMON areaActivation record of mainActivation
record of S1Activation record of S2
space for local variablesspace for passed
parametersreturn addresstemporary space for
expression evaluation
23
An Example
REAL TABLE(10), MAXVAL READ ,
TABLE(1), TABLE(2) CALL LRGST(TABLE, 2,
MAXVAL) PRINT , MAXVAL END
SUBROUTINE LRGST(A, SIZE, V) INTEGER SIZE
REAL A(SIZE), V INTEGER K V
A(1) DO 10 K 1, SIZE IF (A(K) .GT.
V) V A(K)10 CONTINUE RETURN END
TABLE (1) TABLE (10) MAXVAL Temp
2 K A SIZE V Return addr
24
Stack-Based Environment

• In a block-structured language with recursion,
  activations of procedures can be done in a stack
  manner, with a new activation record created on
  the stack every time a procedure is entered and
  released on exit

25
Stack-Based Environment

• Environment (or frame) pointer points to the
  current activation record
• Control (or dynamic) link points to the calling
  environment, i.e., the activation record of the
  caller
• Access (or static) link points to the defining
  environment, i.e., the activation record where
  nonlocal references are defined

26
Stack-Based Environment
control linkaccess linklocal variables passed
parametersreturn address temporaries
27
An Example
int p(void) int q(void) p( )
main() q( )
main
28
An Example
29
Access Chaining
procedure ex is x procedure p is
procedure q is begin x end
q begin end p begin end ex
ex xp q
nesting depth 2
30
Closure
procedure lastex is procedure p(n integer)
is procedure show is begin if n gt
0 then p(n - 1) end if put(n) new_line
end show begin show end p begin p(1)
end lastex
ltep, ipgt
lastexp show p show
31
Procedure Parameters

• For a procedure parameter, the corresponding
  argument will be a closure ltep, ipgt
• The ep is used to set the access link of the
  called procedure
• The ip points to the code of the called procedure

32
Dynamically Created Procedures

• When procedures can be created dynamically and be
  returned via returned values or reference
  parameters, they become first-class values
• Since the closure of a locally defined procedure
  will have an ep points to the current activation
  record. If that closure is available outside the
  activation of the procedure that created it, the
  ep will point to an activation record that no
  longer exits

33
An Example
type WithdrawProc is access function(x
integer) return integerInsufficientFunds
exceptionfunction makeNewBalance(initBalance
integer) return WithDrawProc is
currentBalance integer function
withdraw(amt integer) return integer is
begin if amt lt currentBalance then
currentbalance currentBalance amt
else raise InsufficientFunds end
if return currentBalance end
withdraw begin curentBalance initBalance
return withdrawaccessend makeNewbalance
34
An Example
withdraw1, withdraw2 WithdrawProcwithdraw1
makeNewBalance(500)withdraw2
makeNewBalance(100) / similar to dangling
reference / newBalance1 withdraw1(100) newBa
lance2 withdraw2(50)
35
Fully Dynamic Environments

• In fully dynamic environment, like scheme, an
  activation record can be removed only if they can
  no longer be reached from within the executing
  program
• Such an environment must perform some kind of
  automatic reclamation of unreachable storage
  called garbage collection
• Two standard methods of garbage collection are
  reference counting and mark and sweep

36
An Example
defining environmentWithdraw1 Withdraw2
The structure of the activations becomestreelike
instead of stacklike
37
Reference Counting

• It (an eager method) reclaims a space as soon as
  it is no longer referenced
• Each block of allocated storage contains an extra
  count field, which stores the number of
  references to the block from other blocks
• Each time a reference is changed, these reference
  counts must be updated
• When the reference count drops to zero, the block
  can be returned to the free list

38
Drawbacks of Reference Counting

• Need extra memory to keep the reference counts
• The effort to maintain the reference counts can
  be fairly large
• Circular references can cause unreferenced memory
  to never be deallocated

39
Maintaining Reference Counts
void decrement(p) p-gtrefcount-- if
(p-gtrefcount 0) for all fields r of p
that are pointers do decrement(r)
deallocate(p) void assign(p, q)
decrement(p) p q q-gtrefcount
40
Circular References
p
p is deallocated
41
Mark and Sweep

• It (a lazy method) puts off reclaiming any
  storage until the allocator runs out of space, at
  which point it looks for all storage that can be
  referenced and removes all unreferenced storage
  back to the free list
• The first pass follows all pointers recursively,
  starting with the symbol table, and marks each of
  block reached with an extra bit
• The second pass then sweeps linearly through
  memory, returning unmarked blocks to the free list

42
Drawbacks of Mark and Sweep

• Need extra space to keep the marks
• The double pass through memory causes a
  significant delay in processing, sometimes as
  much as a few seconds, each time the garbage
  collector is invoked, which can be every few
  minutes
• Two improvements stop and copy, and generational
  garbage collection

43
Stop and Copy

• Splitting memory into two halves and allocating
  storage only from one half at a time
• During the marking pass, all reached blocks are
  copied to the other half
• No extra bit is required. Only one pass is
  required. Compaction is performed automatically

44
Generational Garbage Collection

• A permanent storage area is added to the
  reclamation scheme
• Allocated objects that survive long enough are
  simply copied into permanent space and are never
  deallocated during subsequent storage
  reclamations
• The garbage collector needs to search only a very
  small section of memory for newer storage
  allocations