A short digression stacks and heaps
Download
1 / 21

A Short Digression Stacks and Heaps - PowerPoint PPT Presentation


  • 94 Views
  • Uploaded on

A Short Digression Stacks and Heaps. CS-502, Operating Systems Fall 2007 (Slides include materials from Operating System Concepts , 7 th ed., by Silbershatz, Galvin, & Gagne and from Modern Operating Systems , 2 nd ed., by Tanenbaum). Digression: the “Stack”.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' A Short Digression Stacks and Heaps' - keilah


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
A short digression stacks and heaps

A Short DigressionStacks and Heaps

CS-502, Operating SystemsFall 2007

(Slides include materials from Operating System Concepts, 7th ed., by Silbershatz, Galvin, & Gagne and from Modern Operating Systems, 2nd ed., by Tanenbaum)

Stacks and Heaps


Digression the stack
Digression: 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?

Stacks and Heaps


Compiled code the caller
Compiled code: the caller

int x = factorial(100);

  • Put the value “100” somewhere that factorial can find

  • Put the current program counter somewhere so that factorial can return to the right place in caller

  • Provide a place to put the result, so that caller can find it

Stacks and Heaps


Compiled code factorial function
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 it 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

Stacks and Heaps


Question where is somewhere
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?

Stacks and Heaps


Answer a stack
Answer: a “Stack”

  • Stack – a linear 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

Stacks and Heaps


Stack continued
“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

Stacks and Heaps


Stack continued1
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 (fixed) register

    • Occasionally, a linked list

  • Recursion

    • Stack discipline allows multiple contexts for the same function in the stack at the same time

  • Stacks and Heaps


    Stacks in modern systems
    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

  • Stacks and Heaps


    Process address space typical

    0xFFFFFFFF

    stack

    (dynamically allocated)

    SP

    heap

    (dynamically allocated)

    Virtual

    address space

    static data

    program code

    (text)

    PC

    0x00000000

    Process Address Space (Typical)

    See also Silbershatz, figure 3.1

    Stacks and Heaps


    Stacks in multi threaded environments
    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

    Stacks and Heaps


    Stacks in multi threaded address space
    Stacks in Multi-threaded Address Space

    thread 1 stack

    SP (T1)

    0xFFFFFFFF

    thread 2 stack

    SP

    SP (T2)

    thread 3 stack

    SP (T3)

    Virtual

    address space

    heap

    static data

    0x00000000

    PC

    code

    (text)

    PC (T2)

    PC (T1)

    PC (T3)

    Stacks and Heaps


    Stacks in multi threaded environments1
    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

  • Some small or RT operating systems are equivalent to multi-threaded environments

  • Stacks and Heaps


    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.

    Stacks and Heaps


    Process address space typical1

    0xFFFFFFFF

    stack

    (dynamically allocated)

    SP

    heap

    (dynamically allocated)

    Virtual

    address space

    static data

    program code

    (text)

    PC

    0x00000000

    Process Address Space (Typical)

    See also Silbershatz, figure 3.1

    Stacks and Heaps


    Dynamically allocating from heap
    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!

  • Stacks and Heaps


    Dynamically allocating from heap1
    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

  • Stacks and Heaps


    Heaps in modern systems
    Heaps in Modern Systems

    • Many modern programming languages require a heap

      • C++, Java, etc.

      • NOT Fortran

  • Typical process environment

    • Grows toward stack

  • Multi-threaded environments

    • All threads share the same heap

    • Data structures may be passed from one thread to another.

  • Stacks and Heaps


    Heap in multi threaded address space

    Heap

    Heap in Multi-threaded Address Space

    thread 1 stack

    SP (T1)

    0xFFFFFFFF

    thread 2 stack

    SP

    SP (T2)

    thread 3 stack

    SP (T3)

    Virtual

    address space

    heap

    static data

    0x00000000

    PC

    code

    (text)

    PC (T2)

    PC (T1)

    PC (T3)

    Stacks and Heaps


    Stacks in multi threaded address space1

    What’s this?

    Stacks in Multi-threaded Address Space

    thread 1 stack

    SP (T1)

    0xFFFFFFFF

    thread 2 stack

    SP

    SP (T2)

    thread 3 stack

    SP (T3)

    Virtual

    address space

    heap

    static data

    0x00000000

    PC

    code

    (text)

    PC (T2)

    PC (T1)

    PC (T3)

    Stacks and Heaps


    Questions

    Questions?

    Stacks and Heaps


    ad