JVM Memory Managemnt and Garbage Collection Flashcards

Question

What is sweep phase?

Answer 1

In sweep phase, the heap is traversed to find gaps between live objects and gaps are recorded in freel list. That space is then available for new object allocation.

Answer 2

It is similar to disk defragmentation. When there are small holes between objects, the performance of object allocation suffers. So during compaction all objects are moved together to create contiguous section of used and free memory.

Answer 3

Uses simple mark-sweep-compact approach for young and old generation. Uses only single thread.

Answer 4

Uses N parallel threads to do Young gen collection and serially in Old generation. N is equal to number of CPU cores in system.

Answer 5

Same as Parallel new GC but it uses multiple threads for both young and old collection.

Answer 6

It is referred to as concurrent low pause collector. CMS works on Old generation and algorithm for new generation is same as parallel collector. Suitable for responsive applications which cannot afford high pause times.

Answer 7

Available from Java 7, to replace CMS in long run. It is parallel, concurrent and incrementally low pause collector. There is no concept of young or old gen. It divides heap in multiple equal regions. It first collects regions with least live data, so "Garbage first" - Meant for multiprocessor machines with large memories

Answer 8

Because it divides heap into equal sized regions. When GC is invoked it collects region with lesser live objects, so it is called garbage first.

Answer 9

Activate serial GC

Answer 10

Activate parallel new GC

Answer 11

Activate old parallel GC which uses parallel threads for both old and new collection.

Answer 12

Activate CMS collector

Answer 13

Number of threads used by Parallel GC

Answer 14

Activate G1 GC

Answer 15

Number of CMS threads

Answer 16

Overall memory utilization is increasing continuously and memory is not reaching to base level even after garbage collection.

Answer 17

Rate at which the application is allocating new objects. Number of young generation collections provides information on it. The higher the number, the more the churn rate.

Answer 18

It negatively impacts response time because minor GC is triggered frequently. Also the old gen fills quickly because young generation cannot cope with quantity of objects.

Answer 19

GC pressure occurs when churn rate is high and objects are pre maturely tenured. This indicates sizing issue of heap or too high churn rate.

Answer 20

Old generation fluctuates greatly, then objects are being copied unnecessarily from young generation. Either young is too small, churn rate is too high.

Answer 21

For diagnosing performance issues with GC, heap sizing. Does not need any flags to be enabled. Included in JDK by default. jstat -gc

Answer 22

Provides heap information - Information specific to GC algorithm, threads - Heap configuration provided at command line - Heap usage, capacity, free. Region wise details are provided.

Answer 23

Introduced in Java 8 and should be preferred over jmap. Used to send diagnostic command requests to the JVM, which are useful for diagnosing application.

Answer 24

Takes a heap dump (hprof)

Answer 25

Takes a heap dump in hprof format.

Answer 26

Heap analysis tool provides convinient way to browse object topology in heap snapshot. It parses binary heap dump created using jcmd. Useful for finding memory leaks.

Answer 27

- Some global map where the reference of object is being hold and not unregistered when unused - An object has registered an anonymously created listener and did not unregister than listener. So even though the main object is not referenced but the listener is still holding reference to this. - Classloader leak

Answer 28

Analyses the heap profile and starts a web server on which various queries can be performed using OQL (Object query language)

Answer 29

Is a tool for heap and CPU profiling shipped with JDK. It is useful for analysing performance, lock contention, memory leaks and other issues.

Answer 30

GUI tool that can do CPU sampling, Memory sampling, run garbage collections, analyze heap errors, take snapshots and more.

Answer 31

We need to enable JMX remote ports to connect to remote machine and view CPU utilization. It is also possible to generate thread dump and heap dump on remote machine.

Answer 32

Takes heap dump if out of memory error occurs while running application. This will create .hprof file

Answer 33

Using CPU sampling of VisualVM. It will show which methods are taking most CPU.

Answer 34

Mark phase marks the objects that are still alive. Sweep phase adds all dead objects to freelist and compact phase to compact memory after unused objects have been removed.

Answer 35

There are two spaces from and to. Marking phase occurs in from space. All the objects that are live are then moved to to space with compaction. So there is no different compaction phase.

Answer 36

- Object survives certain number of garbage collections | - Survivor space gets full

Answer 37

Objects larger than n bytes are allocated directly in Old gen

Answer 38

In multi-threaded environment multiple threads will allocate memory and there is one pointer. So to do that we would need synchronization. But that is slow. So to improve performance each thread gets its own buffer in Eden space where it can allocate. So no locking is required and allocation is really fast.

Answer 39

A reference to any object from - stack frame (represents running functions. So any objects being referenced from stack frame must be live references) - static variables (statics are global and so any objects that are referenced by statics will also be global and so must be kept live) - JNI, synchronization Garbage collection uses these live roots to mark other live objects that are being referenced by these roots.

Answer 40

When an object in old generation is referencing an object in new generation, the minor garbage collection will not know that object in young is being referred to from old gen. To do that GC would have to scan the old gen. And that defeats the purpose of generational collector. So to overcome that limitation we need card table.

Answer 41

- When a write to a reference to a young gen object happens it goes through write barrier - Write barrier triggers code in JVM - That method updates entry in table called cardtable - One entry per 512 bytes of memory - Minor GC scans table looking for any change data - Load that memory and follow reference and marked to be in use

Answer 42

Minor GC cycle uses CardTable to take care of objects which are referred to from objects in old gen.

Answer 43

Yes, it is stop the world and a mark and sweep collector.

Answer 44

- Initial Mark (stop the world) follow root references - Concurrent Mark (concurrent) traverse graph looking for live objects. Any new allocations made are considered alive - Remark (stop the world) Find objects created after concurrent phase stopped - Concurrent Sweep (concurrent) collect objects - Resetting (concurrent) reset for next run

Answer 45

Compacting collector

Answer 46

jstat -gc prints YGC and FGC which is young garbage collection count and full garbage collection count.

Answer 47

VisualGC is a plugin for VisualVM which provides depth of information regarding garbage collection.

Answer 48

Java references are by default strong references

Answer 49

SoftReference, WeakReference, PhantomReference

Answer 50

Soft reference will not be garbage collected on normal times, but will be GCed if there is memory pressure.

Answer 51

Weak reference will never keep object alive, when GC runs and there is no soft or weak reference pointing to that object but only a weak reference, then it will be garbage collected.

Answer 52

Strong > Soft Reference > Weak Reference > Phantom Reference

Answer 53

Soft Reference, because they are only collected when there is GC pressure.

Answer 54

Weak reference. In conjunction with WeakHashMap can also be used.

Answer 55

To interact with Garbage collector.

Answer 56

NO. Because it's all up to garbage collector to which objects it will collect. We cannot control if we need LRU, LFU kind of caching strategies.

Answer 57

Java reference types Soft, Weak and Phantom take constructor arguments as ReferenceQueue. When all strong references to an object are cleared then the reference object is added to the reference queue. This is useful for associating some cleanup stuff.

Answer 58

The more live objects there are, the slower GC cycle will be. The more objects die, the faster garbage collection is.

Answer 59

Memory fragmentation issue. If there are random sized holes in memory, allocation of new objects takes more time because need to find a suitable sized hole for the object.

Answer 60

Compaction. Most GC algorithms do compaction. This eradicates the need for free lists. But downside is that compaction is not concurrent in most GCs and so application is suspended during that time, causing throughput to go down.

Answer 61

Throughput applications. Like batch processing applications where response time is not as important.

Answer 62

Response time sensitive applications. Which need as low pause times as possible.

Answer 63

- Memory fragmentation - More complicated algorithm and more cpu cycles wasted - Much fine tuning is required and more flags to work with.

Answer 64

- Don't run compaction on each GC cycle - Set threshold for compaction that 50% memory fragmented then do it. - Also don't compact whole memory only till the time we achieve desired threshold like 50%

Answer 65

Copying strategy is used. Copying alive objects and moving them to other area and declaring old area as empty. This is much faster and simpler than sweeping and compaction. But it counts on most of the objects dying in young. The advantage is no fragmentation.

Answer 66

When the application is executing a high number of transactions. If young generation is too small, the objects are tenured pre maturely to old. If young is too large, many objects stay alive and the GC cycle will take too long.

Answer 67

Yes. Minor GC is full stop the world event. Can be done paralelly using parallel collector. So too frequent minor GCs can also grind application down to its knees.

Answer 68

verbose:gc

Answer 69

- The young gen is too small - there's high churn rate - too much transactional memory usage

Answer 70

Use a concurrent GC, and let it handle spillover. But spill over should not be too great. In that case we need to reduce/optimize transactional memory usage of application.

Answer 71

Need to tune both concurrent GC thresholds and the size of old generation so that average fill rate is not more than 75%. 25% is needed by concurrent GC. If old is too full, concurrent GC will not be able to free enough memory and lead to real Full GC. Stop the world!!

Answer 72

- Mutable static fields and collections - Thread local variables - Forgetting to unregister a listener or unsubscribing - Bi directional references (Like Node in an XML document internally holds reference to container document object)

Answer 73

Transactional memory usage describes how much memory a transaction keeps alive. Too many transactions and temporary objects will be tenured into old gen.

Answer 74

The more concurrency you expect in production, the lower transactional memory application should use.

Answer 75

- Response time - Throughput - Availability

Answer 76

No. With averaging you lose fluctuations over longer time. While smaller averages taken over small number of measurements are imprecise. You lose peak values.

Answer 77

With average, peak response time should also be maintained. We maintained 1 min peak response time, 10 mins, 1 hour peak.

Answer 78

Yes. Median does not fabricate the value artificially. It is the middle value. So is close to actual reality.

Answer 79

Percentile is most precise. If 95th percentile of application response time is 2 ms, then 95% of requests are served in 2ms or less. But it is difficult to calculate. More data is required as compared to average.

Answer 80

JVM starts logging GC times and details of following format 0.291: [GC (Allocation Failure) [PSYoungGen: 33280K->5088K(38400K)] 33280K->24360K(125952K), 0.0365286 secs] [Times: user=0.11 sys=0.02, real=0.04 secs]

Answer 81

6528K is the space in the young generation occupied by objects at the start of the ParNew collection. Not all those objects are necessarily alive. 702K is the space occupied by live objects at the end of the ParNew collection. 6528K is the total space in the young generation. 0.0130227 is the pause duration for the ParNew collection. 469764K is the space occupied by objects in the young generation and the old (CMS) generation before the collection starts. 465500K is the space occupied by live objects in the young generation and all objects in the old (CMS) generation. For a ParNew collection, only the liveness of the objects in the young generation is known so the objects in the old (CMS) generation may be live or dead. 522488K is the total space in the heap. ``` [Times: user=0.05 sys=0.00, real=0.01 secs] is like the output of time(1) command. The ratio user / real give you an approximation for the speed up you're getting from the parallel execution of the ParNew collection. The sys time can be an indicator of system activity that is slowing down the collection. For example if paging is occurring, sys will be high. ```

Answer 82

1. 2015-05-26T16:23:07.321-0200: 64.42 – Time the GC event started, both clock time and relative to the time from the JVM start. For the following phases the same notion is used throughout the event and is thus skipped for brevity. 2. CMS Initial Mark – Phase of the collection – “Initial Mark” in this occasion – that is collecting all GC Roots. 3. 10812086K – Currently used Old Generation. 4. (11901376K) – Total available memory in the Old Generation. 5. 10887844K – Currently used heap 6. (12514816K) – Total available heap 7. 0.0001997 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] – Duration of the phase, measured also in user, system and real time.

Answer 83

1. CMS-concurrent-mark – Phase of the collection – “Concurrent Mark” in this occasion – that is traversing the Old Generation and marking all live objects. 2. 035/0.035 secs – Duration of the phase, showing elapsed time and wall clock time correspondingly. 3. [Times: user=0.07 sys=0.00, real=0.03 secs] – “Times” section is less meaningful for concurrent phases as it is measured from the start of the concurrent marking and includes more than just the work done for the concurrent marking.

Answer 84

1. CMS-concurrent-preclean – Phase of the collection – “Concurrent Preclean” in this occasion – accounting for references being changed during previous marking phase. 2. 0.016/0.016 secs – Duration of the phase, showing elapsed time and wall clock time correspondingly. 3. [Times: user=0.02 sys=0.00, real=0.02 secs] – The “Times” section is less meaningful for concurrent phases as it is measured from the start of the concurrent marking and includes more than just the work done for the concurrent marking.

Answer 85

1. CMS-concurrent-abortable-preclean – Phase of the collection “Concurrent Abortable Preclean” in this occasion 2. 0.167/1.074 secs – Duration of the phase, showing elapsed and wall clock time respectively. It is interesting to note that the user time reported is a lot smaller than clock time. Usually we have seen that real time is less than user time, meaning that some work was done in parallel and so elapsed clock time is less than used CPU time. Here we have done a little amount of work – for 0.167 seconds of CPU time, and garbage collector threads just waited for something for almost a second, not doing any work. 3. [Times: user=0.20 sys=0.00, real=1.07 secs] – The “Times” section is less meaningful for concurrent phases, as it is measured from the start of the concurrent marking and includes more than just the work done for the concurrent marking.

Answer 86

A concurrent phase that is not stopping the application’s threads. This one attempts to take as much work off the shoulders of the stop-the-world Final Remark as possible. The exact duration of this phase depends on a number of factors, since it iterates doing the same thing until one of the abortion conditions (such as the number of iterations, amount of useful work done, elapsed wall clock time, etc) is met.

Answer 87

1. 2015-05-26T16:23:08.447-0200: 65.550 – Time the GC event started, both clock time and relative to the time from the JVM start. 2. CMS Final Remark – Phase of the collection – “Final Remark” in this occasion – that is marking all live objects in the Old Generation, including the references that were created/modified during previous concurrent marking phases. 3. YG occupancy: 387920 K (613440 K) – Current occupancy and capacity of the Young Generation. 4. [Rescan (parallel) , 0.0085125 secs] – The “Rescan” completes the marking of live objects while the application is stopped. In this case the rescan was done in parallel and took 0.0085125 seconds. 5. weak refs processing, 0.0000243 secs]65.559 – First of the sub-phases that is processing weak references along with the duration and timestamp of the phase. 6. class unloading, 0.0013120 secs]65.560 – Next sub-phase that is unloading the unused classes, with the duration and timestamp of the phase. 7. scrub string table, 0.0001759 secs – Final sub-phase that is cleaning up symbol and string tables which hold class-level metadata and internalized string respectively. Clock time of the pause is also included. 8. 10812086K(11901376K) – Occupancy and the capacity of the Old Generation after the phase. 9. 11200006K(12514816K) – Usage and the capacity of the total heap after the phase. 10. 0.0110730 secs – Duration of the phase. 11. [Times: user=0.06 sys=0.00, real=0.01 secs] – Duration of the pause, measured in user, system and real time categories.

Answer 88

This is the second and last stop-the-world phase during the event. The goal of this stop-the-world phase is to finalize marking all live objects in the Old Generation. This means traversing the Old Generation starting from the roots determined in the same way as during the Initial Mark plus the so-called "dirty" objects, i.e. the ones that had modifications to their fields during the concurrent phases. Usually CMS tries to run final remark phase when Young Generation is as empty as possible in order to eliminate the possibility of several stop-the-world phases happening back-to-back

Answer 89

1. CMS-concurrent-sweep – Phase of the collection “Concurrent Sweep” in this occasion, sweeping unmarked and thus unused objects to reclaim space. 2. 0.027/0.027 secs – Duration of the phase showing elapsed time and wall clock time correspondingly. 3. [Times: user=0.03 sys=0.00, real=0.03 secs] – “Times” section is less meaningful on concurrent phases, as it is measured from the start of the concurrent marking and includes more than just the work done for the concurrent marking

Answer 90

1. CMS-concurrent-reset – The phase of the collection – “Concurrent Reset” in this occasion – that is resetting inner data structures of the CMS algorithm and preparing for the next collection. 2. 0.012/0.012 secs – Duration of the the phase, measuring elapsed and wall clock time respectively. 3. [Times: user=0.01 sys=0.00, real=0.01 secs] – The “Times” section is less meaningful on concurrent phases, as it is measured from the start of the concurrent marking and includes more than just the work done for the concurrent marking.