def test_gc_datastore(self):
"""Test storage & retrival of GC entries in datastore"""
yg_gc = parsegc.generate_yg_gc_entry("100.25", "100.25", "ParNew", "3",
"2", "8", "0.12345", "8192",
"5120", "16384", "3.12345", "1.5",
"2.0", "3.1")
full_gc = parsegc.generate_full_gc_entry("200.5", "200.5", "Tenured",
"20", "10", "40", "0.23456",
"8192", "5120", "16384",
"200", "100", "400", "3.1234",
"1.9", "0.05", "3.11")
# Items should be written to & returned from the store
# ordered by timestamp
gc_data = [yg_gc, full_gc]
log_key = LogData(filename="test_gc_datastore.tmp",
notes="notes").put()
gc_datastore.store_data(log_key, gc_data)
results = gc_datastore.get_data(log_key)
self.assertEqual(results, gc_data)
# Uncomment below to help debug failures
"""
def test_generate_stats(self):
"""Test the generation of stats result set"""
yg_gc1 = parsegc.generate_yg_gc_entry("50.0", "50.0", "ParNew", "2",
"1", "4", "0.12345", "2048",
"1024", "4096", "2.12345", "1.0",
"1.50", "2.1")
yg_gc2 = parsegc.generate_yg_gc_entry("100.25", "100.25", "ParNew",
"3", "2", "8", "0.12345", "8192",
"5120", "16384", "3.12345",
"1.5", "2.0", "3.1")
full_gc = parsegc.generate_full_gc_entry("200.5", "200.5", "Tenured",
"20", "10", "40", "0.23456",
"8192", "5120", "16384",
"200", "100", "400", "3.1234",
"1.9", "0.05", "3.11")
system_gc = parsegc.generate_full_gc_entry("250.75", "250.75",
"Tenured", "30", "20", "80",
"0.23456", "8192", "4096",
"8192", "300", "200", "800",
"4.0912", "1.98", "2.1",
"4.09", "System")
gc_data = [yg_gc1, yg_gc2, full_gc, system_gc]
results = SummaryStats(gc_data).stats
expected = {}
expected['Total Events'] = len(gc_data)
expected['Elapsed Time'] = '200.750 secs'
expected['Time spent in Full GC'] = '7.215 secs'
expected['Time spent in YG GC'] = '5.247 secs'
expected['Heap Start / End (Peak)'] = '4 MB / 8 MB (16 MB)'
expected['YG Start / End (Peak)'] = '4 KB / 8 KB (8 KB)'
expected['Tenured Start / End (Peak)'] = '40 KB / 80 KB (80 KB)'
expected['Perm Start / End (Peak)'] = '400 KB / 800 KB (800 KB)'
expected['Heap Growth'] = '4 MB'
expected['YG Growth'] = '4 KB'
expected['Tenured Growth'] = '40 KB'
expected['Perm Growth'] = '400 KB'
expected['Avg YG Reclaimed'] = '1 KB'
expected['Avg Tenured Reclaimed'] = '10 KB'
self.assertEqual(results, expected)
def test_gc_datastore(self):
"""Test storage & retrival of GC entries in datastore"""
yg_gc = parsegc.generate_yg_gc_entry(
"100.25",
"100.25",
"ParNew",
"3",
"2",
"8",
"0.12345",
"8192",
"5120",
"16384",
"3.12345",
"1.5",
"2.0",
"3.1")
full_gc = parsegc.generate_full_gc_entry(
"200.5",
"200.5",
"Tenured",
"20",
"10",
"40",
"0.23456",
"8192",
"5120",
"16384",
"200",
"100",
"400",
"3.1234",
"1.9",
"0.05",
"3.11")
# Items should be written to & returned from the store
# ordered by timestamp
gc_data = [yg_gc, full_gc]
log_key = LogData(
filename="test_gc_datastore.tmp",
notes="notes").put()
gc_datastore.store_data(log_key, gc_data)
results = gc_datastore.get_data(log_key)
self.assertEqual(results, gc_data)
# Uncomment below to help debug failures
"""
def test_young_ps_old_ps_parse(self):
"""Multi-threaded YG collector with throughput collector
-XX:+UseParallelGC, auto-enabled with -XX:+UseParallelOldGC
"""
result = self.parser.parse(PARALLEL_ENTRY1)
expected = parsegc.generate_yg_gc_entry(
"2.590",
None,
"PSYoungGen",
"32768",
"26736",
"57344",
None,
"82018",
"75986",
"140416",
"0.0292595",
"0.08",
"0.02",
"0.03",
)
self.assertEqual(result, expected)
def test_yg_copy_old_msc_parse(self):
"""Single threaded YG copy collector with serial garbage collector
-XX:+UseSerialGC
"""
result = self.parser.parse(SERIAL_ENTRY1)
expected = parsegc.generate_yg_gc_entry(
"47.100",
"47.100",
"DefNew",
"25472",
"1143",
"25472",
"0.0103151",
"66774",
"45257",
"81968",
"0.0103716",
"0.01",
"0.00",
"0.01",
)
self.assertEqual(result, expected)
yg_result2 = self.parser.parse(SERIAL_YG1)
yg_expected2 = parsegc.generate_yg_gc_entry(
"1.321",
"1.321",
"DefNew",
"80256",
"9984",
"90240",
"0.2542700",
"200471",
"200470",
"290600",
"0.2543095",
"0.22",
"0.04",
"0.26",
)
self.assertEqual(yg_result2, yg_expected2)
# TODO SERIAL_YG2 entry
full_result = self.parser.parse(SERIAL_FULL)
full_expected = parsegc.generate_full_gc_entry(
"26.256",
"26.256",
"Tenured",
"349568",
"349568",
"349568",
"1.3431030",
"506815",
"506815",
"506816",
"4607",
"4607",
"21248",
"1.3431456",
"1.31",
"0.03",
"1.34",
)
self.assertEqual(full_result, full_expected)
system_result = self.parser.parse(SERIAL_SYSTEM)
system_expected = parsegc.generate_full_gc_entry(
"11.576",
"11.576",
"Tenured",
"0",
"336",
"43712",
"0.0123789",
"1747",
"336",
"63360",
"4612",
"4612",
"21248",
"0.0132219",
"0.01",
"0.00",
"0.01",
"System",
)
self.assertEqual(system_result, system_expected)
def test_young_ps_old_ps(self):
"""Young ParallelScavenge with old ParallelScavenge MarkSweep
-XX:+UseParallelGC -XX:+UseParallelOldGC, turn adaptive sizeing on/off with -XX:+UseAdaptiveSizePolicy
"""
yg_result = self.parser.parse(PARALLEL_MARKSWEEP_ADAPTIVE_YG1)
yg_expected = parsegc.generate_yg_gc_entry(
"4.607",
None,
"PSYoungGen",
"83708",
"58240",
"116480",
None,
"351227",
"351398",
"466048",
"0.2748461",
"0.93",
"0.04",
"0.27",
)
self.assertEqual(yg_result, yg_expected)
yg_result2 = self.parser.parse(PARALLEL_MARKSWEEP_NON_ADAPTIVE_YG1)
yg_expected2 = parsegc.generate_yg_gc_entry(
"0.285",
None,
"PSYoungGen",
"16448",
"2688",
"19136",
None,
"55510",
"54822",
"71296",
"0.0370065",
"0.13",
"0.01",
"0.03",
)
self.assertEqual(yg_result2, yg_expected2)
full_result = self.parser.parse(PARALLEL_MARKSWEEP_ADAPTIVE_FULL)
full_expected = parsegc.generate_full_gc_entry(
"5.257",
None,
"ParOldGen",
"349566",
"349567",
"349568",
None,
"466046",
"407805",
"466048",
"4574",
"4574",
"21248",
"1.8929788",
"6.03",
"0.17",
"1.89",
)
# [PSYoungGen: 116480K->58237K(116480K)]
self.assertEqual(full_result, full_expected)
full_result2 = self.parser.parse(PARALLEL_MARKSWEEP_NON_ADAPTIVE_FULL)
full_expected2 = parsegc.generate_full_gc_entry(
"0.322",
None,
"ParOldGen",
"52134",
"52156",
"52160",
None,
"54822",
"54738",
"71296",
"4572",
"4570",
"21248",
"0.1916334",
"0.54",
"0.02",
"0.20",
)
# [PSYoungGen: 2688K->2581K(19136K)]
self.assertEqual(full_result2, full_expected2)
system_result = self.parser.parse(PARALLEL_MARKSWEEP_ADAPTIVE_SYSTEM)
system_expected = parsegc.generate_full_gc_entry(
"10.295",
None,
"ParOldGen",
"0",
"336",
"43712",
None,
"448",
"336",
"62848",
"4612",
"4611",
"21248",
"0.0106136",
"0.02",
"0.00",
"0.02",
"System",
)
# [PSYoungGen: 448K->0K(19136K)]
self.assertEqual(system_result, system_expected)
system_result2 = self.parser.parse(PARALLEL_MARKSWEEP_NON_ADAPTIVE_SYSTEM)
system_expected2 = parsegc.generate_full_gc_entry(
"10.207",
None,
"ParOldGen",
"0",
"336",
"43712",
None,
"448",
"336",
"62848",
"4612",
"4611",
"21248",
"0.0090976",
"0.01",
"0.00",
"0.01",
"System",
)
# [PSYoungGen: 448K->0K(19136K)]
self.assertEqual(system_result2, system_expected2)
def test_yg_copy_old_cms(self):
"""Young copy collector with old ConcurrentMarkSweep
-XX:+UseConcMarkSweepGC -XX:-UseParNewGC
"""
yg_result = self.parser.parse(COPY_CMS_YG1)
yg_expected = parsegc.generate_yg_gc_entry(
"1.438",
"1.438",
"DefNew",
"19136",
"2111",
"19136",
"0.1023744",
"191163",
"191162",
"208192",
"0.1024165",
"0.10",
"0.01",
"0.10",
)
self.assertEqual(yg_result, yg_expected)
full_result = self.parser.parse(COPY_CMS_FULL)
full_expected = parsegc.generate_full_gc_entry(
"6.497",
"6.497",
"CMS",
"503039",
"503040",
"503040",
"4.9805391",
"522175",
"522156",
"522176",
"4619",
"4619",
"21248",
"4.9934847",
"2.45",
"0.21",
"4.99",
)
self.assertEqual(full_result, full_expected)
system_result = self.parser.parse(COPY_CMS_SYSTEM)
system_expected = parsegc.generate_full_gc_entry(
"10.377",
"10.377",
"CMS",
"0",
"340",
"63872",
"0.0161677",
"1735",
"340",
"83008",
"4614",
"4612",
"21248",
"0.0162435",
"0.02",
"0.00",
"0.02",
"System",
)
self.assertEqual(system_result, system_expected)
def test_yg_parnew_old_cms_parse(self):
"""Multi-threaded YG collector with concurrent old generation
collector (CMS)
-XX:+UseParNewGC, auto-enabled with -XX:+UseConcMarkSweepGC
"""
result = self.parser.parse(PAR_NEW_ENTRY1)
expected = parsegc.generate_yg_gc_entry(
"29.063",
"29.063",
"ParNew",
"471872",
"50601",
"471872",
"0.1122560",
"2294220",
"1911156",
"4141888",
"0.1127720",
"2.47",
"0.09",
"0.12",
)
self.assertEqual(result, expected)
yg_result = self.parser.parse(PARNEW_CMS_YG1)
yg_expected = parsegc.generate_yg_gc_entry(
"2.225",
"2.225",
"ParNew",
"19134",
"2110",
"19136",
"0.0619736",
"395443",
"395442",
"412864",
"0.0620169",
"0.21",
"0.01",
"0.06",
)
self.assertEqual(yg_result, yg_expected)
full_result = self.parser.parse(PARNEW_CMS_FULL)
full_expected = parsegc.generate_full_gc_entry(
"12.850",
"12.850",
"CMS",
"458751",
"458751",
"458752",
"2.2371750",
"517759",
"517722",
"517760",
"4619",
"4609",
"21248",
"2.2372395",
"2.17",
"0.05",
"2.23",
)
self.assertEqual(full_result, full_expected)
system_result = self.parser.parse(PARNEW_CMS_SYSTEM)
system_expected = parsegc.generate_full_gc_entry(
"10.160",
"10.479",
"CMS",
"0",
"340",
"63872",
"0.0206751",
"1735",
"340",
"83008",
"4614",
"4612",
"21248",
"0.0207745",
"0.02",
"0.00",
"0.34",
"System",
)
self.assertEqual(system_result, system_expected)
def test_yg_parnew_old_msc_parse(self):
"""Multi-threaded YG collector with old MarkSweepCompact collector
-XX:+UseParNewGC
"""
yg_result = self.parser.parse(PARNEW_MSC_YG2)
yg_expected = parsegc.generate_yg_gc_entry(
"1.025",
"1.025",
"ParNew",
"35840",
"4480",
"40320",
"0.0930836",
"89536",
"88976",
"129816",
"0.0931276",
"0.25",
"0.03",
"0.10",
)
self.assertEqual(yg_result, yg_expected)
full_result = self.parser.parse(PARNEW_MSC_FULL)
full_expected = parsegc.generate_full_gc_entry(
"32.438",
"32.438",
"Tenured",
"349567",
"349567",
"349568",
"1.6792855",
"506815",
"506815",
"506816",
"4574",
"4574",
"21248",
"1.6793288",
"1.62",
"0.05",
"1.68",
)
self.assertEqual(full_result, full_expected)
system_result = self.parser.parse(PARNEW_MSC_SYSTEM)
system_expected = parsegc.generate_full_gc_entry(
"11.033",
"11.033",
"Tenured",
"0",
"336",
"43712",
"0.0099557",
"1747",
"336",
"63360",
"4612",
"4612",
"21248",
"0.0108454",
"0.00",
"0.00",
"0.01",
"System",
)
self.assertEqual(system_result, system_expected)
def test_generate_stats(self):
"""Test the generation of stats result set"""
yg_gc1 = parsegc.generate_yg_gc_entry(
"50.0",
"50.0",
"ParNew",
"2",
"1",
"4",
"0.12345",
"2048",
"1024",
"4096",
"2.12345",
"1.0",
"1.50",
"2.1")
yg_gc2 = parsegc.generate_yg_gc_entry(
"100.25",
"100.25",
"ParNew",
"3",
"2",
"8",
"0.12345",
"8192",
"5120",
"16384",
"3.12345",
"1.5",
"2.0",
"3.1")
full_gc = parsegc.generate_full_gc_entry(
"200.5",
"200.5",
"Tenured",
"20",
"10",
"40",
"0.23456",
"8192",
"5120",
"16384",
"200",
"100",
"400",
"3.1234",
"1.9",
"0.05",
"3.11")
system_gc = parsegc.generate_full_gc_entry(
"250.75",
"250.75",
"Tenured",
"30",
"20",
"80",
"0.23456",
"8192",
"4096",
"8192",
"300",
"200",
"800",
"4.0912",
"1.98",
"2.1",
"4.09",
"System")
gc_data = [yg_gc1, yg_gc2, full_gc, system_gc]
results = SummaryStats(gc_data).stats
expected = {}
expected['Total Events'] = len(gc_data)
expected['Elapsed Time'] = '200.750 secs'
expected['Time spent in Full GC'] = '7.215 secs'
expected['Time spent in YG GC'] = '5.247 secs'
expected['Heap Start / End (Peak)'] = '4 MB / 8 MB (16 MB)'
expected['YG Start / End (Peak)'] = '4 KB / 8 KB (8 KB)'
expected['Tenured Start / End (Peak)'] = '40 KB / 80 KB (80 KB)'
expected['Perm Start / End (Peak)'] = '400 KB / 800 KB (800 KB)'
expected['Heap Growth'] = '4 MB'
expected['YG Growth'] = '4 KB'
expected['Tenured Growth'] = '40 KB'
expected['Perm Growth'] = '400 KB'
expected['Avg YG Reclaimed'] = '1 KB'
expected['Avg Tenured Reclaimed'] = '10 KB'
self.assertEqual(results, expected)