ICS 142 Klefstad

Run-time Environments

Outline Introduction Language Issues that Affect Storage Organization and Allocation Storage Organization Compile-Time Layout of Local Data Efficient Storage-Allocation Strategies Dynamic Storage Management Parameter Passing Symbol Tables

Introduction

attributes of variables
- scope - when a variable is accessible
- lifetime - when a variable has storage
- type - the class of values a variable may have
- value - the particular value at one time
subprogram
- EG a procedure or function
activation
- EG a procedure or function call

activation trees
- each node represents an activation of a subprogram
- the root represents the activation of the main program
- parent a calls child b
- left sibling a is called before right sibling b
control stack
- depth first search of activation tree simulates program control flow
- stack is used to keep track of live subprogram activations

activation record
- a block of storage which holds all info needed by a single unit activation
- may contain
  - return value (for functions)
  - actual parameters
  - return address
  - (optional) dynamic link
  - (optional) static link or display
  - saved machine status and saved registers
  - local data
  - temporaries

Language Issues that Affect Storage Organization and Allocation

recursion
lifetime of variables
parameter passing modes
non-local references

% . procedures as parameters

dynamic storage allocation and deallocation
multi-tasking

Storage Organization

typically divided into five areas
- code segment
  - for unit instructions
- initialized data segment
  - for global and static data
- uninitialized data segment
  - also called bss -- block started by symbol
- stack
  - for semi-static and semi-dynamic variables
- heap
  - for dynamic variables
  - for activation records which cannot be allocated on the stack
    - EG Ada tasks
- (Draw picture)

Compile-Time Layout of Local Data

typically storage is
- blocks of contiguous bytes
- byte addressable
- (8 points) bits per byte
- some number of bytes (typically 4) per word
- multibyte objects are stored in consecutive bytes
- address of object is the address of the first byte
- type determines the size of an object
the offset of a local data object
- the difference between the address of the object and the address of the activation record
- EG
```
VOID foo (INT i) { CHAR c; DOUBLE d; FLOAT f[10]; ... }
```

alignment
- some data objects (such as integers) must begin on a word boundary

padding

space left unused due to alignment

STRUCT foo { DOUBLE d; CHAR c;} f;
SIZEOF (foo) == ??? /* Several possible answers. */
SIZEOF f >= SIZEOF f.d + SIZEOF f.c;

packing
- layout of data which leaves no padding
- EG
```
PACKED ARRAY [1..80] OF CHAR;
```

Efficient Storage-Allocation Strategies

static allocation (EG FORTRAN)
- names are bound to storage at compile-time
- no need for run-time allocation
- values are retained across subprogram activations
- size of data object must be known at compile-time
- non-reentrant disallows recursive subroutines
- limits dynamic data structures

stack allocation (EG Pascal, C)

based on the control stack model
activation records are pushed upon activation and popped upon completion

calling sequence (hypothetical)

push evaluated actual parameters
jump to routine, push return address
save registers to be used
push local variable space / initialize

return sequence (hypothetical)

pop local variable space
restore registers
load return value (in register or on stack)
branch back to caller (pop return address)

stack allocation (continued)
- local blocks
  - two options
    - allocate block activation-record at each block entry
    - allocate maximum space required at subprogram activation
- semi-dynamic variables are given a descriptor in the AR
  - fixed-size discriptor in the AR contains
```
TYPE semi_dynamic_variable_descriptor IS
  RECORD
    base: pointer_to_memory;
    size: integer;
  END RECORD;
```
  - at run-time
    - storage is pushed onto the stack above the AR
    - the base pointer is set to the base of this storage

heap allocation
- used when lifetimes of data objects or ARs do not fit the stack model
- EG
  - dynamic variables
  - Ada tasks
- heap allocation is less efficient than stack allocation
  - EG compare alloca versus malloc

Dynamic Storage Management

part of run-time support

language facilities for dynamic storage management

Pascal
```
NEW, DISPOSE
```
C
```
MALLOC, FREE
```

Ada

NEW, garbage collection, unchecked_deallocation

C++
```
NEW, DELETE
```
Lisp
```
CONS, garbage collection
```

dynamic memory allocation techniques
- first fit
- best fit
- optimal fit
- fast fit
- available list
- buddy system
implicit deallocation
- reference count
- marking techniques

Parameter Passing

call-by-value (call-by-copy: value)
- copy value of actual to storage on the stack
- reference stack object directly
copy-restore (call-by-copy: value-result)
- copy value of stack object back to actual in the return sequence
call-by-reference (or call-by-sharing)
- pass a pointer to object
- each reference in subroutine is implicitly indirect
call-by-name
- pass a parameterless subroutine which returns address of object
  - called a thunk
- OR substitute the subprogram in-line like a macro definition