Title: Names, Scopes and Bindings
1Names, Scopes and Bindings
2Binding Times
- Compile time.
- Mapping of HLL constructs to machine code.
- Layout of static data in memory.
- Link time.
- Resolves intermodule references.
- Load time.
- Machine addresses assigned.
- Run time.
- Bindings of values to variables.
3Importance of Binding Times
- Early binding times
- Efficiency
- Compiled languages
- Later binding times
- Flexibility
- Interpreted languages
4Binding-related Events
- Creation of objects
- Creation of bindings
- References to variables, subroutines, types,
- Temporary deactivation/reactivation of bindings
- Destruction of bindings
- Destruction of objects
5Storage Allocation
- Static objects get fixed absolute address
- Stack objects allocated on the stack in
connection with subroutine calls - Heap objects allocated/deallocated at arbitrary
times - Explicitly by the programmer
- Implicitly by the garbage collector
6Static Objects
- Global variables.
- Variables local to a subroutine, but retain value
across invocations. - Constant literals.
- Tables for run-time support (e.g. debugging, type
checking, etc.). - Space for subroutines, incl. local variables, in
language with no recursion.
7Stack-based Allocation
- Space for subroutines in a language that permits
recursion (stack frame or activation record). - Arguments, local variables.
- Return values.
- Subroutine calling sequence.
- Caller code.
- Callee code.
- Prologue.
- Epilogue.
8Stack Frame
- Specified at compile time.
- Offsets of objects within a frame.
- Frame pointer (register pointing to a known
location of the current stack frame). - Stack pointer (register pointing to the first
unused location on the stack). - Specified at run time.
- The absolute location of stack frame in memory.
9Stack Frame Example
10Heap-based Allocation
- Heap region of storage in which blocks can be
allocated/deallocated at arbitrary times. - Storage management
- Free list linked list of free blocks.
- In each allocation, search for a block of
adequate size. - First fit grab first block that is large enough.
- Best fit grab smallest block that is large
enough.
11Heap Fragmentation Problem
Internal fragmentation part of a block is
unused External fragmentation unused space
consists of many small blocks Which approach,
first fit or best fit, results in lower external
fragmentation?
12Cost of Heap-based Allocation
- Single free list linear cost in the number of
free blocks. - Separate free lists for blocks of different
sizes. - Buddy system.
- If block of size 2k is unavailable, split a block
of size 2k1. - If block of size 2k is deallocated, it may be
coalesced with the other block (buddy). - Fibonacci heap.
- To eliminate external fragmentation, heap can be
compacted.
13Heap-based Deallocation
- Explicitly by the programmer.
- Efficient.
- May lead to very nasty bugs.
- Dangling pointers/references (deallocate too
soon). - Memory leaks (deallocate too late).
- Automatically by the garbage collector.
14Scope Rules
- Scope of a binding a program region (textually)
in which binding is active. - Scope a program region of maximal size where no
bindings change. - Scoping can be
- Lexical or static (bindings known at compile
time). - Dynamic (bindings depend on flow of execution at
run time).
15Static Scope
- Current binding for name the one encountered
most recently in top-to-bottom scan of the
program text. - Nested subroutines
- Modules
16Local variables in Scheme
- (let ((x 2) (y 3)) ( x y))
- (let ((x 2) (y 3)) (let ((x 7)
(z ( x y))) ( z x)))
17Nested Functions in Scheme
- (define (test x y) (let ((fn (lambda (a b)
( a b)))) (fn ( x y) ( x y)))) - (define (test x y) (define (fn a b) ( a
b)) (fn ( x y) ( x y))) - (test 2 3) gt ???
18Nested Subroutines in Pascal
Visible P2, P4 within P1 P3 within P2 F1 within
P4 Can F1 call P2?P4 call F1? P2 call F1? Which
X In F1? In P4? In P2?
19Static Chains
Nested calls A, E, B, D, C Static link to the
frame of the most recent invocation of the
lexically surrounding subroutine
20Information Hiding
- Make objects and algorithms invisible to portions
of the software system that do not need them. - Information hiding
- Static variables in C (permanent state)
- Module (effectively a single instance of class)
- Module type (effectively a class with no
inheritance) - Class (module type inheritance)
21Static variables in C
22Modules in Modula-2
Notice Push, pop visible to each other Push,
pop visible to modules that import thems, top
not visible outside stack module
Main program
23Module types
Multiple instances of a given abstraction Classes
module types inheritance Every instance of
a module type or class has its own copy of the
module or class variables
24Data abstraction in Scheme (I)
A set is a collection of distinct
objects. Represent set as a list. (define
(element-of-set? x set) (cond ((null? set)
false) ((equal? x (car set)) true)
(else (element-of-set? x (cdr
set))))) (define (adjoin-set x set) (if
(element-of-set? x set) set
(cons x set))) (define (intersection-set set1
set2) (cond ((or (null? set1) (null? set2))
()) ((element-of-set? (car set1)
set2) (cons (car set1)
(intersection-set (cdr set1) set2)))
(else (intersection-set (cdr set1)
set2)))) What is the drawback of the above? Is
it true data abstraction?
25Data abstraction in Scheme (II)
- What is the drawback of the above? Is it true
data abstraction? - Set object is immutable.This can be fixed by
defining adjoin-set as a mutation on its
argument). - Possible to access list representation directly.
- Use local state of procedures to hide the state
of the object.
26Data abstraction in Scheme (III)
(define (make-account balance) (define
(withdraw amount) (if (gt balance amount)
(begin (set! balance (- balance amount))
balance) "Insufficient
funds")) (define (deposit amount) (set!
balance ( balance amount)) balance)
(define (dispatch m) (cond ((eq? m 'withdraw)
withdraw) ((eq? m 'deposit) deposit)
(else (error "Unknown request -
MAKE-ACCOUNT" m))))
dispatch) (define acc (make-account 50)((acc
deposit) 40) gt ???((acc withdraw) 60) gt
???
27Dynamic Scope
- The current binding for a given name is the one
encountered most recently during execution, and
not yet destroyed by returning from its scope.
28Dynamic scope example
What does the program print? Under static
scoping? 1 regardless of value
read Under dynamic scoping? 2 if
value read is gt0 1 if value read is lt
0 Dynamic scoping is usually a bad idea
29Static scope implementationSymbol Tables
- Symbol table as dictionarymaps names to
information the compiler knows about them (scope
number, type). - Scope representation
- enter_scope and leave_scope ops
- Each scope gets a serial number
- Scope stack scopes in the current referencing
environment. - Scope number
- Whether scope is closed
30Hash table
Scope stack
2(T)
find the error in the figure!
1(globals)
4(P1)
3(M)
5(P2)
31Looking up a name
hardcopy
- Scan hash chain looking for the name
- For each matching entry, scan down scope stack to
see if its scope is visible - Imports and exports are made visible outside
their normal scope by creating additional entries
for them, which point to real entries.
32Algorithm for symbol table look-up operation
33Dynamic Scope implementation
A-list
single stack of bindings
Central reference tbl
stack of entries for each name
34Shallow Deep binding
- When subroutine is passed as a parameter, when is
the referencing environment bound? - Shallow binding when the routine is called
- Deep binding when the routine is first passed as
a parameter. - Important in both dynamic and static scoping.
35Example
Most appropriate for older_than deep binding
(to get global threshold) print_person shallow
binding (to get locally set line_length) (dyna
mic scoping assumed)
threshold integer
36Subroutine closures
- In deep binding, a closure is a bundle of
- A referencing environment
- Reference to the subroutine
- Deep binding is
- an option in dynamically scoped langs.
- The default in statically scoped langs.
37First- and second-class subroutines
- First class subroutines
- Passed as parameter
- Returned from a subroutine
- Assigned into a variable
- Second class subroutines
- Passed as parameter only
- Third class subroutines
- None of the above
38Overloading
- A name that can refer to more than one object in
a given scop is overloaded. - Overloaded arithmetic operators
- Coercion compiler automatically converts an
object into another type when required. - Subroutine with polymorphic parameters
(unconverted). - Single body of code.
- Behaviour is customized.
- Generic subroutines (templates).
- separate, similar, not identical, copies of code