Download - Lecture 37: Real-World USE OF Graphs

LECTURE 37:REAL-WORLD USE OF GRAPHS

CSC 213 – Large Scale Programming

Today’s Goals

Consider what new does & how Java works What are traditional means of managing

memory? Why did they change how this was done for

Java? What are the benefits & costs of these

changes? Examine real-world use of graphs & its

benefits How do all of those graph algorithms get

used? Can we take advantage of this knowledge

somehow? What occurs in real-world we have not

covered? And why is beer ALWAYS answer to life’s

problems

Explicit Memory Management

Traditional form of memory management Used a lot, but fallen out of favor

malloc / new Commands used to allocate space for an

object free / delete

Return memory to system using these command

Simple to use

Explicit Memory Management

Traditional form of memory management Used a lot, but fallen out of favor

malloc / new Commands used to allocate space for an

object free / delete

Return memory to system using these command

Simple to use, but tricky to get right Forget to free memory leak free too soon dangling pointer

Dangling Pointers

Node x = new Node(“happy”);

Dangling Pointers

Node x = new Node(“happy”);Node ptr = x;

Dangling Pointers

Node x = new Node(“happy”);Node ptr = x;delete x; // But I’m not dead yet!

Dangling Pointers

Node x = new Node(“happy”);Node ptr = x;delete x; // But I’m not dead yet!Node y = new Node(“sad”);

Dangling Pointers

Node x = new Node(“happy”);Node ptr = x;delete x; // But I’m not dead yet!Node y = new Node(“sad”);cout << ptr.data << endl; // sad

Creates insidious, hard-to-find bugs

Dangling Pointers

Node x = new Node(“happy”);Node ptr = x;delete x; // But I’m not dead yet!Node y = new Node(“sad”);cout << ptr.data << endl; // sad

Solution: Garbage Collection Allocate objects into program’s heap

No relation to heap implementing a priority queue

This heap is simply a “pile of memory” Garbage collector scans objects on

heap Starts at references in program stack &

static fields Finds objects reachable from those program

roots We consider the unreachable objects

“garbage” Cannot be used again, so safe to remove

from heap Need to include free command is

eliminated

No More Dangling Pointers

Node x = new Node(“happy”);


Node x = new Node(“happy”);Node ptr = x;


Node x = new Node(“happy”);Node ptr = x;// x reachable through ptr so cannot

reclaim!



reclaim!Node y = new Node(“sad”);



reclaim!Node y = new Node(“sad”);cout << ptr.data << endl; // happy!

Eliminates one mistake programmers make!

But how do we perform garbage collection?



reclaim!Node y = new Node(“sad”);cout << ptr.data << endl; // happy!

Static & locals are called root references

Must compute objects in their transitive closure

Garbage CollectionHEAP


Remove unmarked objects from the heap


Remove unmarked objects from the heap

New objects allocated into empty spaces

Why Not Always Use GC?

Garbage collection has obvious benefits Eliminates some errors that often occurs Added benefit: also makes programming

easier

Why Not Always Use GC?

Garbage collection has obvious benefits Eliminates some errors that often occurs Added benefit: also makes programming

easier Also easier to update code when GC used

for memory GC also has several drawbacks

Reachable objects could, not will, be used again

More memory needed to hold the extra objects

It takes time to compute reachable objects

Cost of Accessing Memory

How long memory access takes is also important Will make a major difference in time

program takes Imaginary scenario used to consider

this effect:

Cost of Accessing Memory

How long memory access takes is also important Will make a major difference in time

program takes Imaginary scenario used to consider

this effect:I want a beer

Registers and Caches

Inside the CPU, find first levels of memory

At the lowest level, are processor’s registers



At the lowest level, are processor’s registers Very, very fast but… … number of beers held is limited




Use caches at next level for dearest memory




Use caches at next level for dearest memory More space than registers, but… … not as fast (walk across room) Will need more beer if party is good

Horrors!

Processor does its best to keep memory local Caches organized to hold memory needed

soon Makes guesses, since this requires

predicting future Will eventually drink all beer in house

Horrors!

Processor does its best to keep memory local Caches organized to hold memory needed

soon Makes guesses, since this requires

predicting future Will eventually drink all beer in house

30MB is largest cache size at the moment Many programs need more than this What do we do?

When the House Runs Dry…

What do you normally do when all beer gone? Must go to store to get more… … but do not want a DUI so we must walk

to store Processor uses RAM to store data that

cannot fit RAM sizes are much, much larger than

caches 100x slower to access, however

When Store Is Out Of Beer...

Ein Glass Bier, Bitte

Get SCUBA gear ready for WALK to Germany Should find enough beer to handle any

situation But buzz destroyed by the very long wait

per glass If Germany runs out, you're drinking too

much

Walking To Germany Is Slow…

60M 80M 100M 120M 140M 160M 180M1

1.2

1.4

1.6

1.8

2

2.2

2.4pseudoJBB

GenMS

GenImmix

GenMS + Leadered

Heap Size

Tim

e Re

lati

ve to

Gen

MS

+ L

eade

red

at 6

0MB

Maintaining Your Buzz

Prevent long pauses by maintaining locality Repeatedly access those objects in fast

memory Access objects in sequential order they are

in memory Both of properties take advantage of

caching Limit data used to size of cache (temporal

locality) (Spatial locality) Exploit knowing how cache

works Limiting data is not easy (or would

have done it) So taking advantage of spatial locality is

our best bet

Cache Replacement Algorithms When we access memory, add its block

to cache May need to evict a block if the cache

already full 2+1 approaches used to select evicted

block FIFO maintains blocks in Queue and evicts

oldest Track each use and evict block least

recently used (Randomly choose a block to evict)

For good performance want to avoid worst case But what is it?

Cache Replacement Workings

Access Order During Program Execution0 1 2 3 4 5 0 1 0 1 2 5 3 2 4

LRU

FIFO

What Does This Mean?

Large data sets require more thought & care Start with, but do not end at, big-Oh

notation Consider memory costs and how to limit

them Most data structures do not grow this

large STACK, QUEUE, SEQUENCE rarely get above

1GB Using very, very large GRAPH is not typical

Databases are largest data sets anywhere Which data structures & implementations

affected?

For Next Lecture

Remember, tests for your program #3 due Think before submitting; do tests make

sense? Reading on memory hierarchy for

Monday How can we use experience of wanting a

beer? Organize searchable collections to help

performance I am taking students to conference on

Friday Will not be here, since I cannot be in two

places at once

Download - Lecture 37: Real-World USE OF Graphs

Top Related