digression on stack and heaps cs-502 (emc) fall 20091 a short digression on stacks and heaps cs-502,...
Post on 19-Dec-2015
219 Views
Preview:
TRANSCRIPT
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 1
A Short Digression onStacks and Heaps
CS-502, Operating SystemsFall 2009 (EMC)
(Slides include materials from Modern Operating Systems, 3rd ed., by Andrew Tanenbaum and from Operating System Concepts, 7th ed., by Silbershatz, Galvin, & Gagne)
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 2
Heads Up
• This topic is not covered explicitly in the textbooks
• It’s something you are supposed to know …
• … but that often slips through the cracks!
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 3
The Stack (from C background)
• The place where arguments of a function call are stored
• The place where registers of the calling function are saved
• The place where local data of called function is allocated
• Automatic data
• The place where called function leaves result for calling function
• Supports recursive function calls• …
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 4
Introduction: The “Stack”
• Imagine the following program:–int factorial(int n){
if (n <= 1)
return (1);
else
int y = factorial(n-1);
return (y * n);
}
• Imagine also the caller:–int x = factorial(100);
• What does compiled code look like?
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 5
Compiled code: the caller
int x = factorial(100);
• Put the value “100” somewhere that factorial function can find
• Put the current program counter somewhere so that factorial function can return to the right place in calling function
• Provide a place to put the result, so that calling function can find it
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 6
Compiled code: factorial function
• Save the caller’s registers somewhere• Get the argument n from the agreed-upon place• Set aside some memory for local variables and
intermediate results – i.e., y, n - 1
• Do whatever factorial was programmed to do
• Put the result where the caller can find it• Restore the caller’s registers• Transfer back to the program counter saved by the
caller
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 7
Question: Where is “somewhere”?
• So that caller can provide as many arguments as needed (within reason)?
• So that called routine can decide at run-time how much temporary space is needed?
• So that called routine can call any other routine, potentially recursively?
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 8
Answer: a “Stack”
• Stack – a data structure in which items are added and removed in last-in, first-out order.
• Calling program• Push arguments & return address onto stack
• After return, pop result off stack
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 9
“Stack” (continued)
• Called routine• Push registers and return address onto stack
• Push temporary storage space onto stack
• Do work of the routine
• Pop registers and temporary storage off stack
• Leave result on stack
• Return to address left by calling routine
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 10
Stack (continued)
• Definition: context – the region of the stack that provides the execution environment of a particular call to a function
• Implementation• Usually, a linear piece of memory and a stack
pointer contained in a (designated) register• Occasionally, a linked list
• Recursion• Stack discipline allows multiple contexts for the
same function in the stack at the same time
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 11
Stacks in Modern Systems
• All modern programming languages require a stack
• Fortran and Cobol did not (non-recursive)
• All modern processors provide a designated stack pointer register
• All modern process address spaces provide room for a stack
• Able to grow to a large size
• May grow upward or downward
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 12
Process Address Space (Typical)
0x00000000
0xFFFFFFFF
Virtual
address space
program code(text)
static data
heap(dynamically allocated)
stack(dynamically allocated)
PC
SP
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 13
Stacks in Multi-threaded Environments
• Every thread requires its own stack• Separate from all other stacks
• Each stack may grow separately
• Address space must be big enough to accommodate stacks for all threads
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 14
Stacks in Multi-threaded Address Space
0x00000000
0xFFFFFFFF
Virtual
address space
code(text)
static data
heap
thread 1 stack
PC (T2)
SP (T2)thread 2 stack
thread 3 stack
SP (T1)
SP (T3)
PC (T1)
PC (T3)
SP
PC
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 15
Heap
• A place for allocating memory that is not part of last-in, first-out discipline
• I.e., dynamically allocated data structures that survive function calls
• E.g., strings in C• new objects in C++, Java, etc.• Anything allocated with malloc() or calloc()
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 16
Process Address Space (Typical)
0x00000000
0xFFFFFFFF
Virtual
address space
program code(text)
static data
heap(dynamically allocated)
stack(dynamically allocated)
PC
SP
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 17
Dynamically Allocating from Heap
• malloc() – POSIX standard function• Allocates a chunk of memory of desired size
• Remembers size
• Returns pointer
• free () – POSIX standard function• Returns previously allocated chunk to heap for
reallocation
• Assumes that pointer is correct!
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 18
Dynamically Allocating from Heap
• malloc() – POSIX standard function• Allocates a chunk of memory of desired size
• Remembers size
• Returns pointer
• free () – POSIX standard function• Returns previously allocated chunk to heap for
reallocation
• Assumes that pointer is correct!
• Storage leak – failure to free something
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 19
Heaps in Modern Systems
• Many modern programming languages require a heap
• C++, Java, etc.• NOT Fortran
• Typical process environment• Heap grows toward stack — but never shrinks!
• Multi-threaded environments• All threads share the same heap• Data structures may be passed from one thread to
another.
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 20
Heap in Multi-threaded Address Space
0x00000000
0xFFFFFFFF
Virtual
address space
code(text)
static data
heap
thread 1 stack
PC (T2)
SP (T2)thread 2 stack
thread 3 stack
SP (T1)
SP (T3)
PC (T1)
PC (T3)
SP
PC
Heap
Digression on Stack and Heaps
CS-502 (EMC) Fall 2009 21
Stacks in Multi-threaded Address Space
0x00000000
0xFFFFFFFF
Virtual
address space
code(text)
static data
heap
thread 1 stack
PC (T2)
SP (T2)thread 2 stack
thread 3 stack
SP (T1)
SP (T3)
PC (T1)
PC (T3)
SP
PC
What’s this?
top related