Memory Management with Java and C++

Understanding
Memory Management
and Garbage Collection
Java and C++
Mohammad Shaker
FIT of Damascus - AI dept.
MohammadShakerGtr@gmail.com
Programming Languages

Bad Pointers
• When a pointer is first allocated, it does
not have a pointee.
• The pointer is “uninitialized” or simply
"bad".
• every pointer starts out with a bad
value.
• There is nothing automatic that gives
a pointer a valid pointee.

Bad Pointers

IT IS NOT NULL!

Bad Pointers – Faster?!
• Most languages make it easy to omit
this important step.
• The run-time checks are also a reason
why such languages always run at
least a little slower than a compiled
language like C or C++!

Bad Pointers - Example
void BadPointer() {
int* p; // allocate the pointer, but not the pointee
*p = 42; // this dereference is a serious runtime error
}

Pointer Rules Summary
• A pointer stores a reference to its pointee. The
pointee, in turn, stores something useful.
• The dereference operation on a pointer accesses its
pointee. A pointer may only be dereferenced after
it has been assigned to refer to a pointee. Most
pointer bugs involve violating this one rule.
• Allocating a pointer does not automatically assign it
to refer to a pointee. Assigning the pointer to refer
to a specific pointee is a separate operation which
is easy to forget.
• Assignment between two pointers makes them refer
to the same pointee which introduces sharing.

Large Locals Example
void X() {
int a = 1;
int b = 2;
// T1
Y(a);
// T3
Y(b);
// T5
}

void Y(int p) {
int q;
q = p + 2;
// T2 (first time through)
// T4 (second time through)
}

A bit harder - Bill Gates By Value
void B(int worth) {
worth = worth + 1;
// T2
}
void A() {
int netWorth;
netWorth = 55; // T1
B(netWorth);
// T3 -- B() did not change netWorth
}

A bit harder - Bill Gates By Reference
void B(int &worth) {
worth = worth + 1;
// T2
}
void A() {
int netWorth;
B(netWorth);
}

A bit harder - Bill Gates By Reference
void B(int *worth) {
*worth = *worth + 1;
// T2
}
void A() {
int netWorth;
B(&netWorth);
}

Heap!
• "Heap" memory, also known as
"dynamic" memory.
• an alternative to local stack Memory.

Facts
• Local memory is quite automatic — it is
allocated automatically on function call
and it is deallocated automatically when
a function exits.
• Heap Lifetime
– Because the programmer now controls
exactly when memory is allocated and
deallocated, it is possible to build a data
structure in memory, and return that data
structure to the caller. This was never possible
with local memory which was automatically
deallocated when the function exited.

Heap - Allocation
• Allocate 3 GIF images in the heap
each of which takes 1024 bytes of
memory.

Heap - Deallocation
• Deallocating Gif2 image

• both values and the variables are allocated memory.
However, each assignment copies into the variable’s block,
not the contents of the value block, but instead its address

null.toString();
• we get a NullPointerException (Java)
• we can determine whether the value
of a pointer variable is null or not, and
hence, whether we can access its
member.

• Multiple pointers sharing a value

Point p1 = new ACartesianPoint(50, 50);
Point p2 = p1;
p1.setX(100);
System.out.println(p2.getX());

• When p1 is assigned to p2, the pointer stored
in p1 is copied into p2, not the object itself.
Both variables share the same object, and thus, the
code will print 100 and not 50, as you might expect.

Object Oriented Memory
Management
(Java and C++)

Foreknowledge
• A program address space:
– Code area
– Heap (Dynamic Memory Area)
– Execution Stack

Foreknowledge
• Code area
– where code to be executed is stored
• Heap
– store variables and objects allocated
dynamically
– accessed with no restrictions
• Execution Stack
– perform computation
– store local variables
– perform function call management

accessed with a LIFO policy (Last In First Out)

C++ Specific
• C++ has several other memory areas
• C++ the entire code is loaded into
code area, and neglect dynamic
loading.

Activation Record (AR)
void f(){
g();
}
void g(){
h();
}
void h(){
k();
}

Scope Activation Record (SAR)
is put every time a new block is encountered

Scope Activation Record (SAR)
• Contains:
– Local variables (declared inside the
block)
– The Static Link SL (a.k.a SAR link)
a pointer to the SAR of the
immediate enclosing block; used to acce
ss local variables of outer blocks from the
current block.

References and Pointers
conceptually the SAME

Classes and Objects
Objects are instances of classes

Classes and Objects
Objects are instances of classes
(Objects are classes in action)

C++ again
• In C++ classes are truly user defined ty
pes. Objects are treated as any other
variable and are allocated:
– On the stack, as regular local variables
– On the heap, like in Java

Java example

int[] hello = new int[5];
// reference hello is on stack, the object is on the
// heap.

hello[0] = 2;
// Java puts this value directly in same slot and doesn't
// create a wrapping object.

From: http://stackoverflow.com/questions/10820787/how-does-java-treat-primitive-type-arrays

Java: Why are wrapper classes needed?
http://stackoverflow.com/questions/2134798/java-why-are-wrapper-classes-needed

Java example
public class CoffeeMaker {
public CoffeeMaker(){}
}
..
..
CoffeeMaker aCoffeeMaker;
aCoffeeMaker = new CoffeeMaker();
int sugar = 4;
Integer sugarObject = new Integer(3);

Java example
• Java objects can be accessed just
through reference variables, that hold
the address of objects in heap.

C++ example
class CoffeeMaker {
public:
CoffeeMaker();
virtual ~CoffeeMaker();
};

// ..
CoffeeMaker *aPtrCoffeeMaker = new CoffeeMaker();
CoffeeMaker &aRefCoffeeMaker = aCoffeeMaker;
aRefCoffeeMaker = *aPtrCoffeeMaker; // dangerous!
int sugar = 4;
int *ptrSuger = new int;
int &aRefSugar = sugar;

Issues for objects in memory (Java)
• Objects with no references pointing to
them are considered eligible for
automatic garbage collection by the
system, which runs periodically and
performs the real destruction of the
objects.
• GC is not directly under control of the
programmer.

Issues for objects in memory (C++)
• After an object has been created on
the heap (with the new directive) it
survives until someone destroys it
explicitly using the delete directive.
• This could lead to memory leaks
– if the programmer forgets to delete
objects no longer needed, they remain
on the heap as wasted space

Methods (Java)
public class CoffeeMaker {
public void prepareCoffee() {}
public void prepareCoffeeSweet(int sugarAm){}
void main(...) {
aCoffeeMaker = new CoffeeMaker();
aCoffeeMaker.prepareCoffee();
}
}

Methods (C++)
class CoffeeMaker {
public:
void prepareCoffee() {}
void prepareCoffeeSweet(int sugarAm){}
void main(...) {
CoffeeMaker *aPtrCoffeeMaker;
aPtrCoffeeMaker = new CoffeeMaker;
aPtrCoffeeMaker-> prepareCoffee();
}
}

Understanding
Garbage Collection

Read!
• http://www.simple-talk.com/dotnet/.net-framework/understanding-
garbage-collection-in-.net/
• http://en.wikibooks.org/wiki/C_Programming/Memory_management
• (.pdf) Garbage Collection: Automatic Memory Management in the
Microsoft .NET Framework

Memory Management with Java and C++

More Related Content

Memory Management with Java and C++