csc 213 – large scale programming. today’s goals consider what new does & how java works ...
TRANSCRIPT
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”);
No More Dangling Pointers
Node x = new Node(“happy”);
Node ptr = x;
No More Dangling Pointers
Node x = new Node(“happy”);
Node ptr = x;
// x reachable through ptr so cannot reclaim!
No More Dangling Pointers
Node x = new Node(“happy”);
Node ptr = x;
// x reachable through ptr so cannot reclaim!
Node y = new Node(“sad”);
No More Dangling Pointers
Node x = new Node(“happy”);
Node ptr = x;
// x reachable through ptr so cannot reclaim!
Node y = new Node(“sad”);
cout << ptr.data << endl; // happy!
Eliminates one mistake programmers make!
But how do we perform garbage collection?
No More Dangling Pointers
Node x = new Node(“happy”);
Node ptr = x;
// x reachable through ptr so cannot 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 CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Static & locals are called root references
Must compute objects in their transitive closure
Garbage CollectionH
EA
P
Garbage CollectionH
EA
P
Remove unmarked objects from the heap
Garbage CollectionH
EA
P
Remove unmarked objects from the heap
Garbage CollectionH
EA
P
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
Registers and Caches
Inside the CPU, find first levels of memory
At the lowest level, are processor’s registers
Registers and Caches
Inside the CPU, find first levels of memory
At the lowest level, are processor’s registers Very, very fast but… … number of beers held is limited
Registers and Caches
Inside the CPU, find first levels of memory
At the lowest level, are processor’s registers
Use caches at next level for dearest memory
Registers and Caches
Inside the CPU, find first levels of memory
At the lowest level, are processor’s registers
Use caches at next level for dearest memory
Registers and Caches
Inside the CPU, find first levels of memory
At the lowest level, are processor’s registers
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
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...
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.4
pseudoJBB
GenMS
GenImmix
GenMS + Leadered
Heap Size
Tim
e R
ela
tive t
o G
en
MS
+ L
ead
ere
d
at
60
MB
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