The Basics What is memory management? Programs contain Objects - - PowerPoint PPT Presentation

the basics what is memory management
SMART_READER_LITE
LIVE PREVIEW

The Basics What is memory management? Programs contain Objects - - PowerPoint PPT Presentation

The Basics What is memory management? Programs contain Objects Data Occupy memory Runtime system must allocate and reclaim memory for program in an efficient manner Why is this important? Why is this hard? Why is


slide-1
SLIDE 1

The Basics

slide-2
SLIDE 2

What is memory management?

 Programs contain

 Objects  Data  Occupy memory

 Runtime system must allocate and reclaim memory for

program in an efficient manner

 Why is this important?  Why is this hard?  Why is this interesting?

2

slide-3
SLIDE 3

Allocation and Reclamation

 Allocation

 Objects dynamically allocated on HEAP  malloc(), new()

 Reclamation

 Manual/Explicit

 free()  delete()

 Automated

 Garbage collection (GC)

3

slide-4
SLIDE 4

Explicit memory management challenges

 Consumes software development time

 new  allocate storage for new object  delete  reclaim storage

 Dangling pointers (reclaim too soon)

4

Foo* p = new Foo(); Foo* q = p; delete p; p->DoSomething(); p = NULL; q->ProcessFoo();

  • Statically undecidable
  • Problem for developers
slide-5
SLIDE 5

Explicit memory management challenges

 Memory leak (never reclaim)

5

#include <stdlib.h> void f(void){ void* s; s = malloc(50); return; } int main(void){ while (1) f(); return 0; }

slide-6
SLIDE 6

Explicit memory management pluses

 Efficiency can be very high  Puts the programmer in control

6

slide-7
SLIDE 7

Automated memory management

 Runtime system automatically

 Detects dead objects (garbage detection)  Reclaims dead objects (garbage reclamation)  Garbage collection

 Preserves software development time

 Relieves programmer burden  Less prone to errors

 Utilized by most modern OOP and scripting

languages

 Python, Java, C#, php

7

slide-8
SLIDE 8

Garbage collection challenges

 Occurs an unpredictable

times

 Duration is unbounded  Performance efficiency

issues

8

public void f(){ startLaser(); Obj o = new Obj(); stopLaser(); } public static void main(…){ while (true) f(); } Time

GC, Bad for Real- Time

slide-9
SLIDE 9

Runtime system performs GC

 E.g. Java virtual machine (JVM)

 Software execution engine that executes your Java

programs

 Java interpreter that converts byte code into OS specific

commands

 Handles related tasks

 Memory management (GC implemented in JVM)  Security  Multithreading

9

slide-10
SLIDE 10

Major concerns

 Explicit memory management

 Reclaiming objects at the right time

 Garbage collection

 Discriminating live objects from garbage

 Both

 Fast allocation  Fast reclamation  Low fragmentation

10

slide-11
SLIDE 11

Layout of a program in memory

11

stack heap Uninitialized data (bss) Initialized data Text / code High address Low address Command line args and environment variables Initialized to 0 by exec Read from program file by exec

slide-12
SLIDE 12

Determining object liveness

 Live objects are needed in the computation

 Now or in the future

 Prove that an object is not live (dead) and reclaim its

storage

 Reclaim dead objects soon, after it is last used  How do we estimate liveness in practice?

 Approximate liveness by reachability from outside the

heap

 Unreachable objects are garbage (reclaim storage)  Reachable objects are live and must not be reclaimed

12

slide-13
SLIDE 13

Identifying garbage

13

 reference counting

(reachability)

 An integer is associated

with every object, summing

 Stack references  Heap references

 Objects with reference

count of zero are dead

stack heap 1 2 2 1 1 1

slide-14
SLIDE 14

Problems with reference counting

14

  • Standard problem is that
  • bjects in cycles (and

those touched by such

  • bjects) cannot be

collected (reclaimed)

  • Overhead of counting

can be high

stack heap 1 2 1 1 1 1

slide-15
SLIDE 15

Identifying garbage

 Tracing (reachability)  Trace reachability from root set

 Processor registers  Program stack  Global variables

 Objects traced are reachable  All other objects are unreachable (garbage)

15

slide-16
SLIDE 16

The marking phase

 To find the dead objects, use the process of calculatus

eliminatus

 Find all live objects  All others are dead

16

slide-17
SLIDE 17

The marking phase

17

  • To discover the dead
  • bjects, we

– Find live objects

stack heap

  • Pointers from the stack

to the heap make objects live

slide-18
SLIDE 18

The marking phase

18

  • To discover the dead
  • bjects, we

– Find live objects

  • Pointers from the stack

to the heap make objects live

  • These objects make
  • ther objects live

stack heap

slide-19
SLIDE 19

The sweep phase

19

  • To discover the dead
  • bjects, we

– Find live objects – Sweep all others away as dead

stack heap

slide-20
SLIDE 20

Mark and sweep: Tracing example

20

  • To discover the dead
  • bjects, we

– Find live objects – Sweep all others away as dead – Perhaps compact the heap – Problem: – Mark phase can take unbounded time

stack heap