Decipher Garbage Collection Log

Refer to Garbage Collection index page at the following URL:
http://mylearningcafe.blogspot.in/2015/05/garbage-collection-gc.html

Today lets look at analyzing the garbage collection logs.

Why are Garbage Collection (GC) logs important?
Via GC Logs, one can see the usage of the heap and can look at improving the same.
This can help the application throughput immensely.

How does one print GC logs in an application?
We have various flags for GC. They are listed below.

-XX:+PrintGC OR -verbose:GC
The most basic logging. It prints a line for every young GC and every full GC.

Whats young GC and Full GC?
Refer following URL: http://mylearningcafe.blogspot.in/2014/02/serial-vs-parallel-gc.html

The basic GC log will look like:

[GC heap_before_GC -> heap_after_GC (heap_capacity), time_taken_to_clear_heap]
[Full GC heap_before_Full_GC -> heap_after_Full_GC (heap_capacity), time_taken_to_clear_heap]

e.g.

[GC 78786K->32K(168896K), 0.0386790 secs]
[Full GC 1765598K->628983K(1864192K), 3.0560280 secs]

The above implies:

Young GC:

• Heap Memory occupied before GC: 78786K
• Heap Memory after GC: 32K
• Heap Capacity: 168896K
• Time taken to clear heap: 0.0386790 sec

Full GC:

• Heap Memory occupied before GC: 1765598K
• Heap Memory after GC: 628983K
• Heap Capacity: 1864192K
• Time taken to clear heap: 3.0560280 sec

As mentioned, the above is simple GC logging.

-XX:+PrintGCDetails
This parameter gives detailed logging.

[GC [PSYoungGen: young_heap_before_GC -> young_heap_after_GC(young_heap_capacity)] total_heap_before_GC -> total_heap_after_GC (total_heap_capacity), time_taken_to_clear_heap]

[GC [PSYoungGen: 78786K->32K(168896K)] 1844377K->1765630K(2033088K), 0.0386790 secs]

Above is Young GC output in detailed format.

[Full GC [PSYoungGen: young_heap_before_GC -> young_heap_after_GC(young_heap_capacity)] [PSOldGen: Old_heap_before_GC -> Old_heap_after_GC(Old_heap_capacity)] total_heap_before_GC -> total_heap_after_GC (total_heap_capacity) [PSPermGen: Perm_heap_before_GC -> Perm_heap_after_GC(Perm_heap_capacity)], time_taken_to_clear_heap]

[Full GC [PSYoungGen: 32K->0K(168896K)] [PSOldGen: 1765598K->628983K(1864192K)] 1765630K->628983K(2033088K) [PSPermGen: 82932K->82932K(83328K)], 3.0560280 secs]

Above is Full GC output in detailed format.

If one captures this data and wants to plot a chart, you will realize that the date/time is missing.
For the same, lets look at another parameter below.

-XX:+PrintGCTimeStamps and -XX:+PrintGCDateStamps

These paramaters add the date and time to the above mentioned logs.

-XX:+PrintGCTimeStamps will give:

0,185:[GC [PSYoungGen: 78786K->32K(168896K)] 1844377K->1765630K(2033088K), 0.0386790 secs]

Here, 0.185 is the timestamp reflecting the real time passed in seconds since JVM started.

and

-XX:+PrintGCDateStamps will give:
2015-03-03T12:04:17.101-0010:[GC [PSYoungGen: 78786K->32K(168896K)] 1844377K->1765630K(2033088K), 0.0386790 secs]

reflects the full date and time.

Refer to Garbage Collection index page at the following URL:
http://mylearningcafe.blogspot.in/2015/05/garbage-collection-gc.html

Garbage Collection (GC)

Find below links for various Garbage Collection (GC) related topics

• Garbage collection basics
• Serial v/s Parallel GC
• Decipher GC logs

Sorting algorithms in Java

Trying to list down some sorting algorithms in Java:

Merge Sort:
It is a divide and conquer algorithm.
Divide the unsorted list into n sub-lists, each containing 1 element (a list of 1 element is considered sorted).

Refer Merge Sort article for details.

Bubble Sort:
Bubble sort is a simple sorting algorithm that works by:

•     Repeatedly going through the list to be sorted
•     Comparing each pair of adjacent items
•     Swapping them if they are in the wrong order

Refer Bubble Sort article for details.

Quick Sort:
Quick sort is based on the principle of divide and conquer.
Quick sort first divides the large lists into two sub smaller lists, the low elements and the high elements.
It can then recursively sort the sub-lists.

Refer Quick Sort article for details.

Insertion Sort
Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time.

Refer Insertion Sort article for details.

Selection Sort:
Selection sort is a simple algorithm.
It divides the input lists into two parts:

• The sub-list of the items are already sorted, which is built up from left to right at the front(left) of the list.
• The sub-list of the  items remaining to be sorted that occupy the rest of the list.

Refer Selection Sort article for details.

Selection sort in Java

Refer: Main indexed article on sorting.
 
Selection sort is a simple algorithm.

It divides the input lists into two parts:

• The sub-list of the items are already sorted, which is built up from left to right at the front(left) of the list
• The sub-list of the  items remaining to be sorted that occupy the rest of the list.

Initially the sorted sub-list is empty and the unsorted sub-list is the entire input list.
The algorithm proceeds by finding the smallest (or largest depending on the sorting order) element in the unsorted sub-list exchanging it with the leftmost unsorted element (putting in sorted order) and moving the sub-list boundaries one element to the right.

Java code snippet:

Insertion Sort in Java

Refer: Main indexed article on sorting.

Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time.
It is much less efficient on large lists.

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list.
Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there.
It repeats until no input elements remain.

At each array-position, it checks the value there against the largest value in the sorted list (which happens to be next to it, in the previous array-position checked).
If larger, it leaves the element in place and moves to the next.
If smaller, it finds the correct position within the sorted list, shifts all the larger values up to make a space, and inserts into that correct position.

The diagram below shows the algorithm in 2 parts for better understanding.

Part 1.




Part 2



Java code snippet: