Memory management algorithms overview, explanation how garbage collector works in .NET? comparing to other systems.

2. •
•
•
•
•
•

3. •
•
•
•
•

4. •
•
•
Roots

5. •
•
•
Roots

6. •
•
•
Roots

7. +
+
+
-
-

8. •
•
root
1
2
0
1
2
0
1
0
2
3
1

9. •
•
root
1
2
0
1
2
0
1
0
2
3
1

10. •
•
root
1
1
2
1
1
0
2
1

11. •
•
root
1
1
2
1
1
1

12. •
•
root
1
1
2
1
1
1
1
1
1
1

13. +
+
+
-
-

14. •
•
•
•
•
•
old space
root
a
b
new space
c
d

15. •
•
•
•
•
•
old space
root
a
b
new space
c
d

16. •
•
•
•
•
•
old space
b
new space
d
root
a
c

17. •
•
•
•
•
•
new space
old space
root
a
c

18. +
+
+
+
-

19. Tracing
Collection style
Reference
counting
Copying
collections
batch
incremental
copy
long
short
long
Real Time
no
yes
no
Delayed Reclamation
yes
no
no
none
high
low
yes
no
yes
Pause Times
Cost per mutation
Collects cycles

20. Roots
Processes
global
stack
stack
stack
CPU registers

21. Roots
Processes
global
stack
stack
stack
CPU registers

22. Roots
Processes
global
stack
stack
stack
CPU registers

23. •
public class Fin
{
public FileStream fs;
Fin()
{
fs = new FileStream("text.txt", FileMode. Create);
}
~Fin()
{
fs.Close();
}
}

24. •
•
•
•
•
•
•
•

25. a
b
d
g
c
e
h
Finalization
queue
f
i
F-reachable
queue

26. c
d
e
a
b
d
g
h
c
e
h
Finalization
queue
f
i
F-reachable
queue

27. c
d
e
a
b
d
g
h
c
e
h
Finalization
queue
f
i
F-reachable
queue

28. d
a
b
d
h
c
e
c
f
e
h
F-reachable
queue
Finalization
queue

29. d
a
b
d
h
f
e
e
h
F-reachable
queue
Finalization
queue

30. d
a
b
h
f
d
Finalization
queue
h
F-reachable
queue

31. •
•
~Fin()
{
someGlobalVar = this;
}

32. •
•
•
•
•
•
•

33. a
b
c
d
e
d
e
0
a
b
c
0
a
b
1
d
0

34. a
b
d
f
g
h
b
f
d
d
2
g
k
i
h
0
1
a
j
j
k
0
1
a
i
g
i
1
0

35. •
•
•
•

36. •
•
•
public void WriteToFile(string s)
{
TextWriter tw = new StreamWriter("text.txt", true);
tw.Write("new text");
TextWriter tw2 = new StreamWriter("text.txt", true); //???
}

37. •
// For not-sealed classes
protected virtual void Dispose(bool disposing) { }
// For sealed classes
private void Dispose(bool disposing) { }
•
•
•

38. •
•
•
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}

39. void Dispose(bool disposing)
{
if (disposing)
{
// Managed resources
}
// Unmanaged resources
}
•
~Fin()
{
Dispose(false);
}

40. •
using(TextWriter tw = new StreamWriter("text.txt", true))
{
tw.Write("new text");
}

41. •
•
•
•
•
•

42. •
•
•
•

43. •
•
•
•
•

44. •
•
•
"Incremental garbage collection fixes the problem by dividing
the work of a GC into smaller pieces. Rather than do a 500
millisecond garbage collection, an incremental collector might
divide the work into fifty slices, each taking 10ms to complete. In
between the slices, Firefox is free to respond to mouse clicks and
draw animations.“
http://blog.mozilla.org/javascript/2012/08/28/incremental-gc-in-firefox-16/

45. •
•
•
•