--- old/src/cpu/ppc/vm/vm_version_ppc.cpp	2019-09-02 18:06:29.207474900 +0300
+++ new/src/cpu/ppc/vm/vm_version_ppc.cpp	2019-09-02 18:06:28.604306300 +0300
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
- * Copyright 2012, 2018 SAP AG. All rights reserved.
+ * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019 SAP SE. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -250,6 +250,71 @@
   if (FLAG_IS_DEFAULT(UseMontgomerySquareIntrinsic)) {
     UseMontgomerySquareIntrinsic = true;
   }
+
+  check_virtualizations();
+}
+
+void VM_Version::check_virtualizations() {
+#if defined(_AIX)
+  int rc = 0;
+  perfstat_partition_total_t pinfo;
+  rc = perfstat_partition_total(NULL, &pinfo, sizeof(perfstat_partition_total_t), 1);
+  if (rc == 1) {
+    Abstract_VM_Version::_detected_virtualization = PowerVM;
+  }
+#else
+  const char* info_file = "/proc/ppc64/lparcfg";
+  // system_type=...qemu indicates PowerKVM
+  // e.g. system_type=IBM pSeries (emulated by qemu)
+  char line[500];
+  FILE* fp = fopen(info_file, "r");
+  if (fp == NULL) {
+    return;
+  }
+  const char* system_type="system_type=";  // in case this line contains qemu, it is KVM
+  const char* num_lpars="NumLpars="; // in case of non-KVM : if this line is found it is PowerVM
+  bool num_lpars_found = false;
+
+  while (fgets(line, sizeof(line), fp) != NULL) {
+    if (strncmp(line, system_type, strlen(system_type)) == 0) {
+      if (strstr(line, "qemu") != 0) {
+        Abstract_VM_Version::_detected_virtualization = PowerKVM;
+        fclose(fp);
+        return;
+      }
+    }
+    if (strncmp(line, num_lpars, strlen(num_lpars)) == 0) {
+      num_lpars_found = true;
+    }
+  }
+  if (num_lpars_found) {
+    Abstract_VM_Version::_detected_virtualization = PowerVM;
+  } else {
+    Abstract_VM_Version::_detected_virtualization = PowerFullPartitionMode;
+  }
+  fclose(fp);
+#endif
+}
+
+void VM_Version::print_platform_virtualization_info(outputStream* st) {
+  const char* info_file = "/proc/ppc64/lparcfg";
+  const char* kw[] = { "system_type=", // qemu indicates PowerKVM
+                       "partition_entitled_capacity=", // entitled processor capacity percentage
+                       "partition_max_entitled_capacity=",
+                       "capacity_weight=", // partition CPU weight
+                       "partition_active_processors=",
+                       "partition_potential_processors=",
+                       "entitled_proc_capacity_available=",
+                       "capped=", // 0 - uncapped, 1 - vcpus capped at entitled processor capacity percentage
+                       "shared_processor_mode=", // (non)dedicated partition
+                       "system_potential_processors=",
+                       "pool=", // CPU-pool number
+                       "pool_capacity=",
+                       "NumLpars=", // on non-KVM machines, NumLpars is not found for full partition mode machines
+                       NULL };
+  if (!print_matching_lines_from_file(info_file, st, kw)) {
+    st->print_cr("  <%s Not Available>", info_file);
+  }
 }
 
 void VM_Version::print_features() {
--- old/src/cpu/ppc/vm/vm_version_ppc.hpp	2019-09-02 18:06:33.900089300 +0300
+++ new/src/cpu/ppc/vm/vm_version_ppc.hpp	2019-09-02 18:06:33.287158600 +0300
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
- * Copyright 2012, 2018 SAP AG. All rights reserved.
+ * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019 SAP SE. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -83,6 +83,10 @@
 public:
   // Initialization
   static void initialize();
+  static void check_virtualizations();
+
+  // Override Abstract_VM_Version implementation
+  static void print_platform_virtualization_info(outputStream*);
 
   static bool is_determine_features_test_running() { return _is_determine_features_test_running; }
   // CPU instruction support
--- old/src/cpu/x86/vm/vm_version_x86.cpp	2019-09-02 18:06:38.729342600 +0300
+++ new/src/cpu/x86/vm/vm_version_x86.cpp	2019-09-02 18:06:38.105681100 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1092,6 +1092,65 @@
 #endif // !PRODUCT
 }
 
+void VM_Version::print_platform_virtualization_info(outputStream* st) {
+  VirtualizationType vrt = VM_Version::get_detected_virtualization();
+  if (vrt == XenHVM) {
+    st->print_cr("Xen hardware-assisted virtualization detected");
+  } else if (vrt == KVM) {
+    st->print_cr("KVM virtualization detected");
+  } else if (vrt == VMWare) {
+    st->print_cr("VMWare virtualization detected");
+  } else if (vrt == HyperV) {
+    st->print_cr("HyperV virtualization detected");
+  }
+}
+
+void VM_Version::check_virt_cpuid(uint32_t idx, uint32_t *regs) {
+// TODO support 32 bit
+#if defined(_LP64)
+#if defined(_MSC_VER)
+  // Allocate space for the code
+  const int code_size = 100;
+  ResourceMark rm;
+  CodeBuffer cb("detect_virt", code_size, 0);
+  MacroAssembler* a = new MacroAssembler(&cb);
+  address code = a->pc();
+  void (*test)(uint32_t idx, uint32_t *regs) = (void(*)(uint32_t idx, uint32_t *regs))code;
+
+  a->movq(r9, rbx); // save nonvolatile register
+
+  // next line would not work on 32-bit
+  a->movq(rax, c_rarg0 /* rcx */);
+  a->movq(r8, c_rarg1 /* rdx */);
+  a->cpuid();
+  a->movl(Address(r8,  0), rax);
+  a->movl(Address(r8,  4), rbx);
+  a->movl(Address(r8,  8), rcx);
+  a->movl(Address(r8, 12), rdx);
+
+  a->movq(rbx, r9); // restore nonvolatile register
+  a->ret(0);
+
+  uint32_t *code_end = (uint32_t *)a->pc();
+  a->flush();
+
+  // execute code
+  (*test)(idx, regs);
+#elif defined(__GNUC__)
+  __asm__ volatile (
+     "        cpuid;"
+     "        mov %%eax,(%1);"
+     "        mov %%ebx,4(%1);"
+     "        mov %%ecx,8(%1);"
+     "        mov %%edx,12(%1);"
+     : "+a" (idx)
+     : "S" (regs)
+     : "ebx", "ecx", "edx", "memory" );
+#endif
+#endif
+}
+
+
 bool VM_Version::use_biased_locking() {
 #if INCLUDE_RTM_OPT
   // RTM locking is most useful when there is high lock contention and
@@ -1113,6 +1172,54 @@
   return UseBiasedLocking;
 }
 
+// On Xen, the cpuid instruction returns
+//  eax / registers[0]: Version of Xen
+//  ebx / registers[1]: chars 'XenV'
+//  ecx / registers[2]: chars 'MMXe'
+//  edx / registers[3]: chars 'nVMM'
+//
+// On KVM / VMWare / MS Hyper-V, the cpuid instruction returns
+//  ebx / registers[1]: chars 'KVMK' / 'VMwa' / 'Micr'
+//  ecx / registers[2]: chars 'VMKV' / 'reVM' / 'osof'
+//  edx / registers[3]: chars 'M'    / 'ware' / 't Hv'
+//
+// more information :
+// https://kb.vmware.com/s/article/1009458
+//
+void VM_Version::check_virtualizations() {
+#if defined(_LP64)
+  uint32_t registers[4];
+  char signature[13];
+  uint32_t base;
+  signature[12] = '\0';
+  memset((void*)registers, 0, 4*sizeof(uint32_t));
+
+  for (base = 0x40000000; base < 0x40010000; base += 0x100) {
+    check_virt_cpuid(base, registers);
+
+    *(uint32_t *)(signature + 0) = registers[1];
+    *(uint32_t *)(signature + 4) = registers[2];
+    *(uint32_t *)(signature + 8) = registers[3];
+
+    if (strncmp("VMwareVMware", signature, 12) == 0) {
+      Abstract_VM_Version::_detected_virtualization = VMWare;
+    }
+
+    if (strncmp("Microsoft Hv", signature, 12) == 0) {
+      Abstract_VM_Version::_detected_virtualization = HyperV;
+    }
+
+    if (strncmp("KVMKVMKVM", signature, 9) == 0) {
+      Abstract_VM_Version::_detected_virtualization = KVM;
+    }
+
+    if (strncmp("XenVMMXenVMM", signature, 12) == 0) {
+      Abstract_VM_Version::_detected_virtualization = XenHVM;
+    }
+  }
+#endif
+}
+
 void VM_Version::initialize() {
   ResourceMark rm;
   // Making this stub must be FIRST use of assembler
@@ -1127,4 +1234,7 @@
                                      g.generate_get_cpu_info());
 
   get_processor_features();
+  if (cpu_family() > 4) { // it supports CPUID
+    check_virtualizations();
+  }
 }
--- old/src/cpu/x86/vm/vm_version_x86.hpp	2019-09-02 18:06:43.650339600 +0300
+++ new/src/cpu/x86/vm/vm_version_x86.hpp	2019-09-02 18:06:42.995443700 +0300
@@ -533,6 +533,9 @@
   static void initialize();
 
   // Override Abstract_VM_Version implementation
+  static void print_platform_virtualization_info(outputStream*);
+
+  // Override Abstract_VM_Version implementation
   static bool use_biased_locking();
 
   // Asserts
@@ -751,6 +754,11 @@
     intx count = PrefetchFieldsAhead;
     return count >= 0 ? count : 1;
   }
+
+  // support functions for virtualization detection
+private:
+  static void check_virt_cpuid(uint32_t idx, uint32_t *regs);
+  static void check_virtualizations();
 };
 
 #endif // CPU_X86_VM_VM_VERSION_X86_HPP
--- old/src/os/linux/vm/os_linux.cpp	2019-09-02 18:06:49.649819300 +0300
+++ new/src/os/linux/vm/os_linux.cpp	2019-09-02 18:06:48.829002900 +0300
@@ -59,6 +59,7 @@
 #include "runtime/thread.inline.hpp"
 #include "runtime/threadCritical.hpp"
 #include "runtime/timer.hpp"
+#include "runtime/vm_version.hpp"
 #include "services/attachListener.hpp"
 #include "services/memTracker.hpp"
 #include "services/runtimeService.hpp"
@@ -2212,6 +2213,8 @@
   os::Linux::print_full_memory_info(st);
 
   os::Linux::print_container_info(st);
+
+  VM_Version::print_platform_virtualization_info(st);
 }
 
 // Try to identify popular distros.
--- old/src/os/windows/vm/os_windows.cpp	2019-09-02 18:06:56.261254300 +0300
+++ new/src/os/windows/vm/os_windows.cpp	2019-09-02 18:06:55.571217600 +0300
@@ -1721,6 +1721,10 @@
   st->print("OS:");
 
   os::win32::print_windows_version(st);
+
+#ifdef _LP64
+  VM_Version::print_platform_virtualization_info(st);
+#endif
 }
 
 void os::win32::print_windows_version(outputStream* st) {
--- old/src/share/vm/classfile/dictionary.hpp	2019-09-02 18:07:03.860346200 +0300
+++ new/src/share/vm/classfile/dictionary.hpp	2019-09-02 18:07:02.971207500 +0300
@@ -129,6 +129,7 @@
   void reorder_dictionary();
 
   ProtectionDomainCacheEntry* cache_get(oop protection_domain);
+  ProtectionDomainCacheTable* pd_cache_table() { return _pd_cache_table; }
 
   void print(bool details = true);
   void verify();
--- old/src/share/vm/classfile/symbolTable.cpp	2019-09-02 18:07:09.861775900 +0300
+++ new/src/share/vm/classfile/symbolTable.cpp	2019-09-02 18:07:09.156126700 +0300
@@ -482,6 +482,9 @@
   return true;
 }
 
+TableStatistics SymbolTable::get_table_statistics() {
+  return the_table()->statistics_calculate();
+}
 
 void SymbolTable::verify() {
   for (int i = 0; i < the_table()->table_size(); ++i) {
@@ -926,6 +929,10 @@
   }
 }
 
+TableStatistics StringTable::get_table_statistics() {
+  return the_table()->statistics_calculate();
+}
+
 // This verification is part of Universe::verify() and needs to be quick.
 // See StringTable::verify_and_compare() below for exhaustive verification.
 void StringTable::verify() {
--- old/src/share/vm/classfile/symbolTable.hpp	2019-09-02 18:07:14.990663800 +0300
+++ new/src/share/vm/classfile/symbolTable.hpp	2019-09-02 18:07:14.355286800 +0300
@@ -139,6 +139,8 @@
   // The symbol table
   static SymbolTable* the_table() { return _the_table; }
 
+  TableStatistics get_table_statistics();
+
   // Size of one bucket in the string table.  Used when checking for rollover.
   static uint bucket_size() { return sizeof(HashtableBucket<mtSymbol>); }
 
@@ -294,6 +296,7 @@
 public:
   // The string table
   static StringTable* the_table() { return _the_table; }
+  TableStatistics get_table_statistics();
 
   // Size of one bucket in the string table.  Used when checking for rollover.
   static uint bucket_size() { return sizeof(HashtableBucket<mtSymbol>); }
--- old/src/share/vm/classfile/systemDictionary.cpp	2019-09-02 18:07:19.994619700 +0300
+++ new/src/share/vm/classfile/systemDictionary.cpp	2019-09-02 18:07:19.320206100 +0300
@@ -2724,6 +2724,21 @@
   constraints()->verify(dictionary(), placeholders());
 }
 
+TableStatistics SystemDictionary::placeholders_statistics() {
+  MutexLocker ml(SystemDictionary_lock);
+  return placeholders()->statistics_calculate();
+}
+
+TableStatistics SystemDictionary::loader_constraints_statistics() {
+  MutexLocker ml(SystemDictionary_lock);
+  return constraints()->statistics_calculate();
+}
+
+TableStatistics SystemDictionary::protection_domain_cache_statistics() {
+  MutexLocker ml(SystemDictionary_lock);
+  return dictionary()->pd_cache_table()->statistics_calculate();
+}
+
 #ifndef PRODUCT
 
 // statistics code
--- old/src/share/vm/classfile/systemDictionary.hpp	2019-09-02 18:07:25.126433900 +0300
+++ new/src/share/vm/classfile/systemDictionary.hpp	2019-09-02 18:07:24.525219200 +0300
@@ -709,6 +709,11 @@
 
   static bool _has_loadClassInternal;
   static bool _has_checkPackageAccess;
+
+public:
+  static TableStatistics placeholders_statistics();
+  static TableStatistics loader_constraints_statistics();
+  static TableStatistics protection_domain_cache_statistics();
 };
 
 #endif // SHARE_VM_CLASSFILE_SYSTEMDICTIONARY_HPP
--- old/src/share/vm/jfr/metadata/metadata.xml	2019-09-02 18:07:29.529179800 +0300
+++ new/src/share/vm/jfr/metadata/metadata.xml	2019-09-02 18:07:28.962118800 +0300
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <!--
- Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
  This code is free software; you can redistribute it and/or modify it
@@ -614,6 +614,10 @@
     <Field type="string" name="osVersion" label="OS Version" />
   </Event>
 
+  <Event name="VirtualizationInformation" category="Operating System" label="Virtualization Information" period="endChunk">
+    <Field type="string" name="name" label="Name" />
+  </Event>
+
   <Event name="InitialSystemProperty" category="Java Virtual Machine" label="Initial System Property" description="System Property at JVM start" period="endChunk">
     <Field type="string" name="key" label="Key" />
     <Field type="string" name="value" label="Value" />
@@ -691,6 +695,66 @@
       description="Total size of all allocated metaspace blocks for anonymous classes (each chunk has several blocks)" />
   </Event>
 
+  <Event name="SymbolTableStatistics" category="Java Virtual Machine, Runtime, Tables" label="Symbol Table Statistics" period="everyChunk">
+    <Field type="ulong" name="bucketCount" label="Bucket Count" description="Number of buckets" />
+    <Field type="ulong" name="entryCount" label="Entry Count" description="Number of all entries" />
+    <Field type="ulong" contentType="bytes" name="totalFootprint" label="Total Footprint" description="Total memory footprint (the table itself plus all of the entries)" />
+    <Field type="ulong" name="bucketCountMaximum" label="Maximum Bucket Count" description="The maximum bucket length (entries in a single bucket)" />
+    <Field type="float" name="bucketCountAverage" label="Average Bucket Count" description="The average bucket length" />
+    <Field type="float" name="bucketCountVariance" label="Bucket Count Variance" description="How far bucket lengths are spread out from their average value" />
+    <Field type="float" name="bucketCountStandardDeviation" label="Bucket Count Standard Deviation" description="How far bucket lengths are spread out from their mean (expected) value" />
+    <Field type="float" name="insertionRate" label="Insertion Rate" description="How many items were added since last event (per second)" />
+    <Field type="float" name="removalRate" label="Removal Rate" description="How many items were removed since last event (per second)" />
+  </Event>
+
+  <Event name="StringTableStatistics" category="Java Virtual Machine, Runtime, Tables" label="String Table Statistics" period="everyChunk">
+    <Field type="ulong" name="bucketCount" label="Bucket Count" description="Number of buckets" />
+    <Field type="ulong" name="entryCount" label="Entry Count" description="Number of all entries" />
+    <Field type="ulong" contentType="bytes" name="totalFootprint" label="Total Footprint" description="Total memory footprint (the table itself plus all of the entries)" />
+    <Field type="ulong" name="bucketCountMaximum" label="Maximum Bucket Count" description="The maximum bucket length (entries in a single bucket)" />
+    <Field type="float" name="bucketCountAverage" label="Average Bucket Count" description="The average bucket length" />
+    <Field type="float" name="bucketCountVariance" label="Bucket Count Variance" description="How far bucket lengths are spread out from their average value" />
+    <Field type="float" name="bucketCountStandardDeviation" label="Bucket Count Standard Deviation" description="How far bucket lengths are spread out from their mean (expected) value" />
+    <Field type="float" name="insertionRate" label="Insertion Rate" description="How many items were added since last event (per second)" />
+    <Field type="float" name="removalRate" label="Removal Rate" description="How many items were removed since last event (per second)" />
+  </Event>
+
+  <Event name="PlaceholderTableStatistics" category="Java Virtual Machine, Runtime, Tables" label="Placeholder Table Statistics" period="everyChunk">
+    <Field type="ulong" name="bucketCount" label="Bucket Count" description="Number of buckets" />
+    <Field type="ulong" name="entryCount" label="Entry Count" description="Number of all entries" />
+    <Field type="ulong" contentType="bytes" name="totalFootprint" label="Total Footprint" description="Total memory footprint (the table itself plus all of the entries)" />
+    <Field type="ulong" name="bucketCountMaximum" label="Maximum Bucket Count" description="The maximum bucket length (entries in a single bucket)" />
+    <Field type="float" name="bucketCountAverage" label="Average Bucket Count" description="The average bucket length" />
+    <Field type="float" name="bucketCountVariance" label="Bucket Count Variance" description="How far bucket lengths are spread out from their average value" />
+    <Field type="float" name="bucketCountStandardDeviation" label="Bucket Count Standard Deviation" description="How far bucket lengths are spread out from their mean (expected) value" />
+    <Field type="float" name="insertionRate" label="Insertion Rate" description="How many items were added since last event (per second)" />
+    <Field type="float" name="removalRate" label="Removal Rate" description="How many items were removed since last event (per second)" />
+  </Event>
+
+  <Event name="LoaderConstraintsTableStatistics" category="Java Virtual Machine, Runtime, Tables" label="Loader Constraints Table Statistics" period="everyChunk">
+    <Field type="ulong" name="bucketCount" label="Bucket Count" />
+    <Field type="ulong" name="entryCount" label="Entry Count" description="Number of all entries" />
+    <Field type="ulong" contentType="bytes" name="totalFootprint" label="Total Footprint" description="Total memory footprint (the table itself plus all of the entries)" />
+    <Field type="ulong" name="bucketCountMaximum" label="Maximum Bucket Count" description="The maximum bucket length (entries in a single bucket)" />
+    <Field type="float" name="bucketCountAverage" label="Average Bucket Count" description="The average bucket length" />
+    <Field type="float" name="bucketCountVariance" label="Bucket Count Variance" description="How far bucket lengths are spread out from their average value" />
+    <Field type="float" name="bucketCountStandardDeviation" label="Bucket Count Standard Deviation" description="How far bucket lengths are spread out from their mean (expected) value" />
+    <Field type="float" name="insertionRate" label="Insertion Rate" description="How many items were added since last event (per second)" />
+    <Field type="float" name="removalRate" label="Removal Rate" description="How many items were removed since last event (per second)" />
+  </Event>
+
+  <Event name="ProtectionDomainCacheTableStatistics" category="Java Virtual Machine, Runtime, Tables" label="Protection Domain Cache Table Statistics" period="everyChunk">
+    <Field type="ulong" name="bucketCount" label="Bucket Count" description="Number of buckets" />
+    <Field type="ulong" name="entryCount" label="Entry Count" description="Number of all entries" />
+    <Field type="ulong" contentType="bytes" name="totalFootprint" label="Total Footprint" description="Total memory footprint (the table itself plus all of the entries)" />
+    <Field type="ulong" name="bucketCountMaximum" label="Maximum Bucket Count" description="The maximum bucket length (entries in a single bucket)" />
+    <Field type="float" name="bucketCountAverage" label="Average Bucket Count" description="The average bucket length" />
+    <Field type="float" name="bucketCountVariance" label="Bucket Count Variance" description="How far bucket lengths are spread out from their average value" />
+    <Field type="float" name="bucketCountStandardDeviation" label="Bucket Count Standard Deviation" description="How far bucket lengths are spread out from their mean (expected) value" />
+    <Field type="float" name="insertionRate" label="Insertion Rate" description="How many items were added since last event (per second)" />
+    <Field type="float" name="removalRate" label="Removal Rate" description="How many items were removed since last event (per second)" />
+  </Event>
+
   <Event name="ThreadAllocationStatistics" category="Java Application, Statistics" label="Thread Allocation Statistics" period="everyChunk">
     <Field type="ulong" contentType="bytes" name="allocated" label="Allocated" description="Approximate number of bytes allocated since thread start" />
     <Field type="Thread" name="thread" label="Thread" />
--- old/src/share/vm/jfr/periodic/jfrOSInterface.cpp	2019-09-02 18:07:33.831389600 +0300
+++ new/src/share/vm/jfr/periodic/jfrOSInterface.cpp	2019-09-02 18:07:33.265307700 +0300
@@ -215,6 +215,27 @@
   return instance()._impl->os_version(os_version);
 }
 
+const char* JfrOSInterface::virtualization_name() {
+  VirtualizationType vrt = VM_Version::get_detected_virtualization();
+  if (vrt == XenHVM) {
+    return "Xen hardware-assisted virtualization";
+  } else if (vrt == KVM) {
+    return "KVM virtualization";
+  } else if (vrt == VMWare) {
+    return "VMWare virtualization";
+  } else if (vrt == HyperV) {
+    return "HyperV virtualization";
+  } else if (vrt == PowerVM) {
+    return "PowerVM virtualization";
+  } else if (vrt == PowerKVM) {
+    return "Power KVM virtualization";
+  } else if (vrt == PowerFullPartitionMode) {
+    return "Power full partition";
+  }
+
+  return "No virtualization detected";
+}
+
 int JfrOSInterface::generate_initial_environment_variable_events() {
   if (environ == NULL) {
     return OS_ERR;
--- old/src/share/vm/jfr/periodic/jfrOSInterface.hpp	2019-09-02 18:07:39.114483500 +0300
+++ new/src/share/vm/jfr/periodic/jfrOSInterface.hpp	2019-09-02 18:07:38.460566700 +0300
@@ -53,6 +53,7 @@
   static int cpu_load_total_process(double* cpu_load);
   static int cpu_loads_process(double* pjvmUserLoad, double* pjvmKernelLoad, double* psystemTotalLoad);
   static int os_version(char** os_version);
+  static const char* virtualization_name();
   static int generate_initial_environment_variable_events();
   static int system_processes(SystemProcess** system_processes, int* no_of_sys_processes);
   static int network_utilization(NetworkInterface** network_interfaces);
--- old/src/share/vm/jfr/periodic/jfrPeriodic.cpp	2019-09-02 18:07:43.995465700 +0300
+++ new/src/share/vm/jfr/periodic/jfrPeriodic.cpp	2019-09-02 18:07:43.369851200 +0300
@@ -26,6 +26,8 @@
 #include "jvm.h"
 #include "classfile/classLoaderStats.hpp"
 #include "classfile/javaClasses.hpp"
+#include "classfile/symbolTable.hpp"
+#include "classfile/systemDictionary.hpp"
 #include "code/codeCache.hpp"
 #include "compiler/compileBroker.hpp"
 #include "gc_implementation/g1/g1HeapRegionEventSender.hpp"
@@ -87,6 +89,12 @@
   event.commit();
 }
 
+TRACE_REQUEST_FUNC(VirtualizationInformation) {
+  EventVirtualizationInformation event;
+  event.set_name(JfrOSInterface::virtualization_name());
+  event.commit();
+}
+
 /*
  * This is left empty on purpose, having ExecutionSample as a requestable
  * is a way of getting the period. The period is passed to ThreadSampling::update_period.
@@ -492,6 +500,46 @@
   VMThread::execute(&op);
 }
 
+template<typename EVENT>
+static void emit_table_statistics(TableStatistics statistics) {
+  EVENT event;
+  event.set_bucketCount(statistics._number_of_buckets);
+  event.set_entryCount(statistics._number_of_entries);
+  event.set_totalFootprint(statistics._total_footprint);
+  event.set_bucketCountMaximum(statistics._maximum_bucket_size);
+  event.set_bucketCountAverage(statistics._average_bucket_size);
+  event.set_bucketCountVariance(statistics._variance_of_bucket_size);
+  event.set_bucketCountStandardDeviation(statistics._stddev_of_bucket_size);
+  event.set_insertionRate(statistics._add_rate);
+  event.set_removalRate(statistics._remove_rate);
+  event.commit();
+}
+
+TRACE_REQUEST_FUNC(SymbolTableStatistics) {
+  TableStatistics statistics = SymbolTable::the_table()->get_table_statistics();
+  emit_table_statistics<EventSymbolTableStatistics>(statistics);
+}
+
+TRACE_REQUEST_FUNC(StringTableStatistics) {
+  TableStatistics statistics = StringTable::the_table()->get_table_statistics();
+  emit_table_statistics<EventStringTableStatistics>(statistics);
+}
+
+TRACE_REQUEST_FUNC(PlaceholderTableStatistics) {
+  TableStatistics statistics = SystemDictionary::placeholders_statistics();
+  emit_table_statistics<EventPlaceholderTableStatistics>(statistics);
+}
+
+TRACE_REQUEST_FUNC(LoaderConstraintsTableStatistics) {
+  TableStatistics statistics = SystemDictionary::loader_constraints_statistics();
+  emit_table_statistics<EventLoaderConstraintsTableStatistics>(statistics);
+}
+
+TRACE_REQUEST_FUNC(ProtectionDomainCacheTableStatistics) {
+  TableStatistics statistics = SystemDictionary::protection_domain_cache_statistics();
+  emit_table_statistics<EventProtectionDomainCacheTableStatistics>(statistics);
+}
+
 TRACE_REQUEST_FUNC(CompilerStatistics) {
   EventCompilerStatistics event;
   event.set_compileCount(CompileBroker::get_total_compile_count());
--- old/src/share/vm/jfr/periodic/sampling/jfrCallTrace.cpp	2019-09-02 18:07:48.830574300 +0300
+++ new/src/share/vm/jfr/periodic/sampling/jfrCallTrace.cpp	2019-09-02 18:07:48.167870100 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -27,6 +27,7 @@
 #include "code/nmethod.hpp"
 #include "code/pcDesc.hpp"
 #include "jfr/periodic/sampling/jfrCallTrace.hpp"
+#include "jfr/utilities/jfrTypes.hpp"
 #include "oops/method.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/frame.inline.hpp"
@@ -37,7 +38,7 @@
   assert(top_frame.cb() != NULL, "invariant");
   RegisterMap map(_thread, false);
   frame candidate = top_frame;
-  for (int i = 0; i < MaxJavaStackTraceDepth * 2; ++i) {
+  for (u4 i = 0; i < MAX_STACK_DEPTH * 2; ++i) {
     if (candidate.is_entry_frame()) {
       JavaCallWrapper *jcw = candidate.entry_frame_call_wrapper_if_safe(_thread);
       if (jcw == NULL || jcw->is_first_frame()) {
--- old/src/share/vm/jfr/periodic/sampling/jfrThreadSampler.cpp	2019-09-02 18:07:53.522212600 +0300
+++ new/src/share/vm/jfr/periodic/sampling/jfrThreadSampler.cpp	2019-09-02 18:07:52.932709000 +0300
@@ -285,13 +285,13 @@
 
 void JfrThreadSampleClosure::commit_events(JfrSampleType type) {
   if (JAVA_SAMPLE == type) {
-    assert(_added_java <= MAX_NR_OF_JAVA_SAMPLES, "invariant");
+    assert(_added_java > 0 && _added_java <= MAX_NR_OF_JAVA_SAMPLES, "invariant");
     for (uint i = 0; i < _added_java; ++i) {
       _events[i].commit();
     }
   } else {
     assert(NATIVE_SAMPLE == type, "invariant");
-    assert(_added_native <= MAX_NR_OF_NATIVE_SAMPLES, "invariant");
+    assert(_added_native > 0 && _added_native <= MAX_NR_OF_NATIVE_SAMPLES, "invariant");
     for (uint i = 0; i < _added_native; ++i) {
       _events_native[i].commit();
     }
@@ -494,8 +494,8 @@
       last_native_ms = last_java_ms;
     }
     _sample.signal();
-    jlong java_interval = _interval_java == 0 ? max_jlong : MAX2<jlong>(_interval_java, 10);
-    jlong native_interval = _interval_native == 0 ? max_jlong : MAX2<jlong>(_interval_native, 10);
+    jlong java_interval = _interval_java == 0 ? max_jlong : MAX2<jlong>(_interval_java, 1);
+    jlong native_interval = _interval_native == 0 ? max_jlong : MAX2<jlong>(_interval_native, 1);
 
     jlong now_ms = get_monotonic_ms();
 
@@ -537,7 +537,7 @@
   JfrThreadSampleClosure sample_task(samples, samples_native);
 
   const uint sample_limit = JAVA_SAMPLE == type ? MAX_NR_OF_JAVA_SAMPLES : MAX_NR_OF_NATIVE_SAMPLES;
-  uint num_sample_attempts = 0;
+  uint num_samples = 0;
   JavaThread* start = NULL;
 
   {
@@ -555,7 +555,7 @@
       JavaThread* current = Threads::includes(*last_thread) ? *last_thread : NULL;
       JavaThread* start = NULL;
 
-      while (num_sample_attempts < sample_limit) {
+      while (num_samples < sample_limit) {
         current = next_thread(threads_list, index, start, current);
         if (current == NULL) {
           break;
@@ -566,8 +566,9 @@
         if (current->is_Compiler_thread()) {
           continue;
         }
-        sample_task.do_sample_thread(current, _frames, _max_frames, type);
-        num_sample_attempts++;
+        if (sample_task.do_sample_thread(current, _frames, _max_frames, type)) {
+          num_samples++;
+        }
       }
       *last_thread = current;  // remember the thread we last attempted to sample
       FREE_C_HEAP_ARRAY(JavaThread *, threads_list, mtInternal);
@@ -576,7 +577,7 @@
     if (LogJFR && Verbose) tty->print_cr("JFR thread sampling done in %3.7f secs with %d java %d native samples",
                    sample_time.seconds(), sample_task.java_entries(), sample_task.native_entries());
   }
-  if (num_sample_attempts > 0) {
+  if (num_samples > 0) {
     sample_task.commit_events(type);
   }
 }
--- old/src/share/vm/jfr/recorder/checkpoint/jfrCheckpointManager.cpp	2019-09-02 18:07:57.978634100 +0300
+++ new/src/share/vm/jfr/recorder/checkpoint/jfrCheckpointManager.cpp	2019-09-02 18:07:57.426218500 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -135,6 +135,8 @@
 
 void JfrCheckpointManager::register_full(BufferPtr t, Thread* thread) {
   // nothing here at the moment
+  assert(t != NULL, "invariant");
+  assert(t->acquired_by(thread), "invariant");
   assert(t->retired(), "invariant");
 }
 
--- old/src/share/vm/jfr/recorder/repository/jfrChunkWriter.cpp	2019-09-02 18:08:02.321840900 +0300
+++ new/src/share/vm/jfr/recorder/repository/jfrChunkWriter.cpp	2019-09-02 18:08:01.788944300 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -47,13 +47,9 @@
   return _chunkstate != NULL;
 }
 
-static fio_fd open_existing(const char* path) {
-  return os::open(path, O_RDWR, S_IREAD | S_IWRITE);
-}
-
 static fio_fd open_chunk(const char* path) {
   assert(JfrStream_lock->owned_by_self(), "invariant");
-  return path != NULL ? open_existing(path) : invalid_fd;
+  return path != NULL ? os::open(path, O_CREAT | O_RDWR, S_IREAD | S_IWRITE) : invalid_fd;
 }
 
 bool JfrChunkWriter::open() {
--- old/src/share/vm/jfr/recorder/repository/jfrEmergencyDump.cpp	2019-09-02 18:08:06.643573200 +0300
+++ new/src/share/vm/jfr/recorder/repository/jfrEmergencyDump.cpp	2019-09-02 18:08:06.076516000 +0300
@@ -24,17 +24,309 @@
 
 #include "precompiled.hpp"
 #include "jfr/jfrEvents.hpp"
+#include "jfr/jni/jfrJavaSupport.hpp"
 #include "jfr/leakprofiler/leakProfiler.hpp"
 #include "jfr/recorder/repository/jfrEmergencyDump.hpp"
 #include "jfr/recorder/service/jfrPostBox.hpp"
 #include "jfr/recorder/service/jfrRecorderService.hpp"
 #include "jfr/utilities/jfrTypes.hpp"
 #include "memory/resourceArea.hpp"
+#include "runtime/arguments.hpp"
 #include "runtime/atomic.hpp"
 #include "runtime/handles.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/mutexLocker.hpp"
-#include "runtime/thread.hpp"
+#include "runtime/os.hpp"
+#include "runtime/thread.inline.hpp"
+#include "utilities/growableArray.hpp"
+
+static const char vm_error_filename_fmt[] = "hs_err_pid%p.jfr";
+static const char vm_oom_filename_fmt[] = "hs_oom_pid%p.jfr";
+static const char vm_soe_filename_fmt[] = "hs_soe_pid%p.jfr";
+static const char chunk_file_jfr_ext[] = ".jfr";
+static const size_t iso8601_len = 19; // "YYYY-MM-DDTHH:MM:SS"
+
+static fio_fd open_exclusivly(const char* path) {
+  return os::open(path, O_CREAT | O_RDWR, S_IREAD | S_IWRITE);
+}
+
+static int file_sort(const char** const file1, const char** file2) {
+  assert(NULL != *file1 && NULL != *file2, "invariant");
+  int cmp = strncmp(*file1, *file2, iso8601_len);
+  if (0 == cmp) {
+    const char* const dot1 = strchr(*file1, '.');
+    assert(NULL != dot1, "invariant");
+    const char* const dot2 = strchr(*file2, '.');
+    assert(NULL != dot2, "invariant");
+    ptrdiff_t file1_len = dot1 - *file1;
+    ptrdiff_t file2_len = dot2 - *file2;
+    if (file1_len < file2_len) {
+      return -1;
+    }
+    if (file1_len > file2_len) {
+      return 1;
+    }
+    assert(file1_len == file2_len, "invariant");
+    cmp = strncmp(*file1, *file2, file1_len);
+  }
+  assert(cmp != 0, "invariant");
+  return cmp;
+}
+
+static void iso8601_to_date_time(char* iso8601_str) {
+  assert(iso8601_str != NULL, "invariant");
+  assert(strlen(iso8601_str) == iso8601_len, "invariant");
+  // "YYYY-MM-DDTHH:MM:SS"
+  for (size_t i = 0; i < iso8601_len; ++i) {
+    switch (iso8601_str[i]) {
+    case 'T':
+    case '-':
+    case ':':
+      iso8601_str[i] = '_';
+      break;
+    }
+  }
+  // "YYYY_MM_DD_HH_MM_SS"
+}
+
+static void date_time(char* buffer, size_t buffer_len) {
+  assert(buffer != NULL, "invariant");
+  assert(buffer_len >= iso8601_len, "buffer too small");
+  os::iso8601_time(buffer, buffer_len);
+  assert(strlen(buffer) >= iso8601_len + 1, "invariant");
+  // "YYYY-MM-DDTHH:MM:SS"
+  buffer[iso8601_len] = '\0';
+  iso8601_to_date_time(buffer);
+}
+
+static jlong file_size(fio_fd fd) {
+  assert(fd != invalid_fd, "invariant");
+  const jlong current_offset = os::current_file_offset(fd);
+  const jlong size = os::lseek(fd, 0, SEEK_END);
+  os::seek_to_file_offset(fd, current_offset);
+  return size;
+}
+
+class RepositoryIterator : public StackObj {
+ private:
+  const char* const _repo;
+  const size_t _repository_len;
+  GrowableArray<const char*>* _files;
+  const char* const fully_qualified(const char* entry) const;
+  mutable int _iterator;
+
+ public:
+  RepositoryIterator(const char* repository, size_t repository_len);
+  ~RepositoryIterator() {}
+  const char* const filter(const char* entry) const;
+  bool has_next() const;
+  const char* const next() const;
+};
+
+const char* const RepositoryIterator::fully_qualified(const char* entry) const {
+  assert(NULL != entry, "invariant");
+  char* file_path_entry = NULL;
+  // only use files that have content, not placeholders
+  const char* const file_separator = os::file_separator();
+  if (NULL != file_separator) {
+    const size_t entry_len = strlen(entry);
+    const size_t file_separator_length = strlen(file_separator);
+    const size_t file_path_entry_length = _repository_len + file_separator_length + entry_len;
+    file_path_entry = NEW_RESOURCE_ARRAY_RETURN_NULL(char, file_path_entry_length + 1);
+    if (NULL == file_path_entry) {
+      return NULL;
+    }
+    int position = 0;
+    position += jio_snprintf(&file_path_entry[position], _repository_len + 1, "%s", _repo);
+    position += jio_snprintf(&file_path_entry[position], file_separator_length + 1, "%s", os::file_separator());
+    position += jio_snprintf(&file_path_entry[position], entry_len + 1, "%s", entry);
+    file_path_entry[position] = '\0';
+    assert((size_t)position == file_path_entry_length, "invariant");
+    assert(strlen(file_path_entry) == (size_t)position, "invariant");
+  }
+  return file_path_entry;
+}
+
+const char* const RepositoryIterator::filter(const char* entry) const {
+  if (entry == NULL) {
+    return NULL;
+  }
+  const size_t entry_len = strlen(entry);
+  if (entry_len <= 2) {
+    // for "." and ".."
+    return NULL;
+  }
+  char* entry_name = NEW_RESOURCE_ARRAY_RETURN_NULL(char, entry_len + 1);
+  if (entry_name == NULL) {
+    return NULL;
+  }
+  strncpy(entry_name, entry, entry_len + 1);
+  const char* const fully_qualified_path_entry = fully_qualified(entry_name);
+  if (NULL == fully_qualified_path_entry) {
+    return NULL;
+  }
+  const fio_fd entry_fd = open_exclusivly(fully_qualified_path_entry);
+  if (invalid_fd == entry_fd) {
+    return NULL;
+  }
+  const jlong entry_size = file_size(entry_fd);
+  os::close(entry_fd);
+  if (0 == entry_size) {
+    return NULL;
+  }
+  return entry_name;
+}
+
+RepositoryIterator::RepositoryIterator(const char* repository, size_t repository_len) :
+  _repo(repository),
+  _repository_len(repository_len),
+  _files(NULL),
+  _iterator(0) {
+  if (NULL != _repo) {
+    assert(strlen(_repo) == _repository_len, "invariant");
+    _files = new GrowableArray<const char*>(10);
+    DIR* dirp = os::opendir(_repo);
+    if (dirp == NULL) {
+      if (true) tty->print_cr("Unable to open repository %s", _repo);
+      return;
+    }
+    struct dirent* dentry;
+    while ((dentry = os::readdir(dirp)) != NULL) {
+      const char* const entry_path = filter(dentry->d_name);
+      if (NULL != entry_path) {
+        _files->append(entry_path);
+      }
+    }
+    os::closedir(dirp);
+    if (_files->length() > 1) {
+      _files->sort(file_sort);
+    }
+  }
+}
+
+bool RepositoryIterator::has_next() const {
+  return (_files != NULL && _iterator < _files->length());
+}
+
+const char* const RepositoryIterator::next() const {
+  return _iterator >= _files->length() ? NULL : fully_qualified(_files->at(_iterator++));
+}
+
+static void write_emergency_file(fio_fd emergency_fd, const RepositoryIterator& iterator) {
+  assert(emergency_fd != invalid_fd, "invariant");
+  const size_t size_of_file_copy_block = 1 * M; // 1 mb
+  jbyte* const file_copy_block = NEW_RESOURCE_ARRAY_RETURN_NULL(jbyte, size_of_file_copy_block);
+  if (file_copy_block == NULL) {
+    return;
+  }
+  while (iterator.has_next()) {
+    fio_fd current_fd = invalid_fd;
+    const char* const fqn = iterator.next();
+    if (fqn != NULL) {
+      current_fd = open_exclusivly(fqn);
+      if (current_fd != invalid_fd) {
+        const jlong current_filesize = file_size(current_fd);
+        assert(current_filesize > 0, "invariant");
+        jlong bytes_read = 0;
+        jlong bytes_written = 0;
+        while (bytes_read < current_filesize) {
+          bytes_read += (jlong)os::read_at(current_fd, file_copy_block, size_of_file_copy_block, bytes_read);
+          assert(bytes_read - bytes_written <= (jlong)size_of_file_copy_block, "invariant");
+          bytes_written += (jlong)os::write(emergency_fd, file_copy_block, bytes_read - bytes_written);
+          assert(bytes_read == bytes_written, "invariant");
+        }
+        os::close(current_fd);
+      }
+    }
+  }
+}
+
+static const char* create_emergency_dump_path() {
+  assert(JfrStream_lock->owned_by_self(), "invariant");
+  char* buffer = NEW_RESOURCE_ARRAY_RETURN_NULL(char, JVM_MAXPATHLEN);
+  if (NULL == buffer) {
+    return NULL;
+  }
+  const char* const cwd = os::get_current_directory(buffer, JVM_MAXPATHLEN);
+  if (NULL == cwd) {
+    return NULL;
+  }
+  size_t pos = strlen(cwd);
+  const int fsep_len = jio_snprintf(&buffer[pos], JVM_MAXPATHLEN - pos, "%s", os::file_separator());
+  const char* filename_fmt = NULL;
+  // fetch specific error cause
+  switch (JfrJavaSupport::cause()) {
+    case JfrJavaSupport::OUT_OF_MEMORY:
+      filename_fmt = vm_oom_filename_fmt;
+      break;
+    case JfrJavaSupport::STACK_OVERFLOW:
+      filename_fmt = vm_soe_filename_fmt;
+      break;
+    default:
+      filename_fmt = vm_error_filename_fmt;
+  }
+  char* emergency_dump_path = NULL;
+  pos += fsep_len;
+  if (Arguments::copy_expand_pid(filename_fmt, strlen(filename_fmt), &buffer[pos], JVM_MAXPATHLEN - pos)) {
+    const size_t emergency_filename_length = strlen(buffer);
+    emergency_dump_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, emergency_filename_length + 1);
+    if (NULL == emergency_dump_path) {
+      return NULL;
+    }
+    strncpy(emergency_dump_path, buffer, emergency_filename_length + 1);
+  }
+  if (emergency_dump_path != NULL) {
+    if (LogJFR) tty->print_cr( // For user, should not be "jfr, system"
+      "Attempting to recover JFR data, emergency jfr file: %s", emergency_dump_path);
+  }
+  return emergency_dump_path;
+}
+
+// Caller needs ResourceMark
+static const char* create_emergency_chunk_path(const char* repository_path) {
+  assert(repository_path != NULL, "invariant");
+  assert(JfrStream_lock->owned_by_self(), "invariant");
+  const size_t repository_path_len = strlen(repository_path);
+  // date time
+  char date_time_buffer[32] = { 0 };
+  date_time(date_time_buffer, sizeof(date_time_buffer));
+  size_t date_time_len = strlen(date_time_buffer);
+  size_t chunkname_max_len = repository_path_len          // repository_base_path
+                             + 1                          // "/"
+                             + date_time_len              // date_time
+                             + strlen(chunk_file_jfr_ext) // .jfr
+                             + 1;
+  char* chunk_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, chunkname_max_len);
+  if (chunk_path == NULL) {
+    return NULL;
+  }
+  // append the individual substrings
+  jio_snprintf(chunk_path, chunkname_max_len, "%s%s%s%s", repository_path_len, os::file_separator(), date_time_buffer, chunk_file_jfr_ext);
+  return chunk_path;
+}
+
+static fio_fd emergency_dump_file_descriptor() {
+  assert(JfrStream_lock->owned_by_self(), "invariant");
+  ResourceMark rm;
+  const char* const emergency_dump_path = create_emergency_dump_path();
+  return emergency_dump_path != NULL ? open_exclusivly(emergency_dump_path) : invalid_fd;
+}
+
+const char* JfrEmergencyDump::build_dump_path(const char* repository_path) {
+  return repository_path == NULL ? create_emergency_dump_path() : create_emergency_chunk_path(repository_path);
+}
+
+void JfrEmergencyDump::on_vm_error(const char* repository_path) {
+  assert(repository_path != NULL, "invariant");
+  ResourceMark rm;
+  MutexLockerEx stream_lock(JfrStream_lock, Mutex::_no_safepoint_check_flag);
+  const fio_fd emergency_fd = emergency_dump_file_descriptor();
+  if (emergency_fd != invalid_fd) {
+    RepositoryIterator iterator(repository_path, strlen(repository_path));
+    write_emergency_file(emergency_fd, iterator);
+    os::close(emergency_fd);
+  }
+}
 
 /*
 * We are just about to exit the VM, so we will be very aggressive
--- old/src/share/vm/jfr/recorder/repository/jfrEmergencyDump.hpp	2019-09-02 18:08:11.083401700 +0300
+++ new/src/share/vm/jfr/recorder/repository/jfrEmergencyDump.hpp	2019-09-02 18:08:10.521225300 +0300
@@ -33,6 +33,8 @@
 class JfrEmergencyDump : AllStatic {
  public:
   static void on_vm_shutdown(bool exception_handler);
+  static void on_vm_error(const char* repository_path);
+  static const char* build_dump_path(const char* repository_path);
 };
 
 #endif // SHARE_VM_JFR_RECORDER_INTERNAL_JFREMERGENCY_HPP
--- old/src/share/vm/jfr/recorder/repository/jfrRepository.cpp	2019-09-02 18:08:15.563248100 +0300
+++ new/src/share/vm/jfr/recorder/repository/jfrRepository.cpp	2019-09-02 18:08:14.970815800 +0300
@@ -28,12 +28,12 @@
 #include "jfr/recorder/jfrRecorder.hpp"
 #include "jfr/recorder/repository/jfrChunkState.hpp"
 #include "jfr/recorder/repository/jfrChunkWriter.hpp"
+#include "jfr/recorder/repository/jfrEmergencyDump.hpp"
 #include "jfr/recorder/repository/jfrRepository.hpp"
 #include "jfr/recorder/service/jfrPostBox.hpp"
 #include "memory/resourceArea.hpp"
 #include "runtime/mutex.hpp"
 #include "runtime/arguments.hpp"
-#include "runtime/os.hpp"
 #include "runtime/thread.inline.hpp"
 
 static JfrRepository* _instance = NULL;
@@ -84,314 +84,13 @@
   _instance = NULL;
 }
 
-static const char vm_error_filename_fmt[] = "hs_err_pid%p.jfr";
-static const char vm_oom_filename_fmt[] = "hs_oom_pid%p.jfr";
-static const char vm_soe_filename_fmt[] = "hs_soe_pid%p.jfr";
-static const char chunk_file_jfr_ext[] = ".jfr";
-static const size_t iso8601_len = 19; // "YYYY-MM-DDTHH:MM:SS"
-
-static fio_fd open_exclusivly(const char* path) {
-  return os::open(path, O_CREAT | O_WRONLY, S_IREAD | S_IWRITE);
-}
-
-static fio_fd open_existing(const char* path) {
-  return os::open(path, O_RDWR, S_IREAD | S_IWRITE);
-}
-
-static int file_sort(const char** const file1, const char** file2) {
-  assert(NULL != *file1 && NULL != *file2, "invariant");
-  int cmp = strncmp(*file1, *file2, iso8601_len);
-  if (0 == cmp) {
-    const char* const dot1 = strchr(*file1, '.');
-    assert(NULL != dot1, "invariant");
-    const char* const dot2 = strchr(*file2, '.');
-    assert(NULL != dot2, "invariant");
-    ptrdiff_t file1_len = dot1 - *file1;
-    ptrdiff_t file2_len = dot2 - *file2;
-    if (file1_len < file2_len) {
-      return -1;
-    }
-    if (file1_len > file2_len) {
-      return 1;
-    }
-    assert(file1_len == file2_len, "invariant");
-    cmp = strncmp(*file1, *file2, file1_len);
-  }
-  assert(cmp != 0, "invariant");
-  return cmp;
-}
-
-static void iso8601_to_date_time(char* iso8601_str) {
-  assert(iso8601_str != NULL, "invariant");
-  assert(strlen(iso8601_str) == iso8601_len, "invariant");
-  // "YYYY-MM-DDTHH:MM:SS"
-  for (size_t i = 0; i < iso8601_len; ++i) {
-    switch(iso8601_str[i]) {
-      case 'T' :
-      case '-' :
-      case ':' :
-        iso8601_str[i] = '_';
-        break;
-    }
-  }
-  // "YYYY_MM_DD_HH_MM_SS"
-}
-
-static void date_time(char* buffer, size_t buffer_len) {
-  assert(buffer != NULL, "invariant");
-  assert(buffer_len >= iso8601_len, "buffer too small");
-  os::iso8601_time(buffer, buffer_len);
-  assert(strlen(buffer) >= iso8601_len + 1, "invariant");
-  // "YYYY-MM-DDTHH:MM:SS"
-  buffer[iso8601_len] = '\0';
-  iso8601_to_date_time(buffer);
-}
-
-static jlong file_size(fio_fd fd) {
-  assert(fd != invalid_fd, "invariant");
-  const jlong current_offset = os::current_file_offset(fd);
-  const jlong size = os::lseek(fd, 0, SEEK_END);
-  os::seek_to_file_offset(fd, current_offset);
-  return size;
-}
-
-class RepositoryIterator : public StackObj {
- private:
-  const char* const _repo;
-  const size_t _repository_len;
-  GrowableArray<const char*>* _files;
-  const char* const fully_qualified(const char* entry) const;
-  mutable int _iterator;
-
- public:
-   RepositoryIterator(const char* repository, size_t repository_len);
-   ~RepositoryIterator() {}
-  debug_only(void print_repository_files() const;)
-  const char* const filter(const char* entry) const;
-  bool has_next() const;
-  const char* const next() const;
-};
-
-const char* const RepositoryIterator::fully_qualified(const char* entry) const {
-  assert(NULL != entry, "invariant");
-  char* file_path_entry = NULL;
-   // only use files that have content, not placeholders
-  const char* const file_separator = os::file_separator();
-  if (NULL != file_separator) {
-    const size_t entry_len = strlen(entry);
-    const size_t file_separator_length = strlen(file_separator);
-    const size_t file_path_entry_length = _repository_len + file_separator_length + entry_len;
-    file_path_entry = NEW_RESOURCE_ARRAY_RETURN_NULL(char, file_path_entry_length + 1);
-    if (NULL == file_path_entry) {
-      return NULL;
-    }
-    int position = 0;
-    position += jio_snprintf(&file_path_entry[position], _repository_len + 1, "%s", _repo);
-    position += jio_snprintf(&file_path_entry[position], file_separator_length + 1, "%s", os::file_separator());
-    position += jio_snprintf(&file_path_entry[position], entry_len + 1, "%s", entry);
-    file_path_entry[position] = '\0';
-    assert((size_t)position == file_path_entry_length, "invariant");
-    assert(strlen(file_path_entry) == (size_t)position, "invariant");
-  }
-  return file_path_entry;
-}
-
-const char* const RepositoryIterator::filter(const char* entry) const {
-  if (entry == NULL) {
-    return NULL;
-  }
-  const size_t entry_len = strlen(entry);
-  if (entry_len <= 2) {
-    // for "." and ".."
-    return NULL;
-  }
-  char* entry_name = NEW_RESOURCE_ARRAY_RETURN_NULL(char, entry_len + 1);
-  if (entry_name == NULL) {
-    return NULL;
-  }
-  strncpy(entry_name, entry, entry_len + 1);
-  const char* const fully_qualified_path_entry = fully_qualified(entry_name);
-  if (NULL == fully_qualified_path_entry) {
-    return NULL;
-  }
-  const fio_fd entry_fd = open_existing(fully_qualified_path_entry);
-  if (invalid_fd == entry_fd) {
-    return NULL;
-  }
-  const jlong entry_size = file_size(entry_fd);
-  os::close(entry_fd);
-  if (0 == entry_size) {
-    return NULL;
-  }
-  return entry_name;
-}
-
-RepositoryIterator::RepositoryIterator(const char* repository, size_t repository_len) :
-  _repo(repository),
-  _repository_len(repository_len),
-  _files(NULL),
-  _iterator(0) {
-  if (NULL != _repo) {
-    assert(strlen(_repo) == _repository_len, "invariant");
-    _files = new GrowableArray<const char*>(10);
-    DIR* dirp = os::opendir(_repo);
-    if (dirp == NULL) {
-      if (true) tty->print_cr("Unable to open repository %s", _repo);
-      return;
-    }
-    struct dirent* dentry;
-    while ((dentry = os::readdir(dirp)) != NULL) {
-      const char* const entry_path = filter(dentry->d_name);
-      if (NULL != entry_path) {
-        _files->append(entry_path);
-      }
-    }
-    os::closedir(dirp);
-    if (_files->length() > 1) {
-      _files->sort(file_sort);
-    }
-  }
-}
-
-#ifdef ASSERT
-void RepositoryIterator::print_repository_files() const {
-  while (has_next()) {
-    if (true) tty->print_cr( "%s", next());
-  }
-}
-#endif
-bool RepositoryIterator::has_next() const {
-  return (_files != NULL && _iterator < _files->length());
-}
-
-const char* const RepositoryIterator::next() const {
-  return _iterator >= _files->length() ? NULL : fully_qualified(_files->at(_iterator++));
-}
-
-static void write_emergency_file(fio_fd emergency_fd, const RepositoryIterator& iterator) {
-  assert(emergency_fd != invalid_fd, "invariant");
-  const size_t size_of_file_copy_block = 1 * M; // 1 mb
-  jbyte* const file_copy_block = NEW_RESOURCE_ARRAY_RETURN_NULL(jbyte, size_of_file_copy_block);
-  if (file_copy_block == NULL) {
-    return;
-  }
- jlong bytes_written_total = 0;
-  while (iterator.has_next()) {
-    fio_fd current_fd = invalid_fd;
-    const char* const fqn = iterator.next();
-    if (fqn != NULL) {
-      current_fd = open_existing(fqn);
-      if (current_fd != invalid_fd) {
-        const jlong current_filesize = file_size(current_fd);
-        assert(current_filesize > 0, "invariant");
-        jlong bytes_read = 0;
-        jlong bytes_written = 0;
-        while (bytes_read < current_filesize) {
-          bytes_read += (jlong)os::read_at(current_fd, file_copy_block, size_of_file_copy_block, bytes_read);
-          assert(bytes_read - bytes_written <= (jlong)size_of_file_copy_block, "invariant");
-          bytes_written += (jlong)os::write(emergency_fd, file_copy_block, bytes_read - bytes_written);
-          assert(bytes_read == bytes_written, "invariant");
-        }
-        os::close(current_fd);
-        bytes_written_total += bytes_written;
-      }
-    }
-  }
-}
-
-static const char* create_emergency_dump_path() {
-  assert(JfrStream_lock->owned_by_self(), "invariant");
-  char* buffer = NEW_RESOURCE_ARRAY_RETURN_NULL(char, O_BUFLEN);
-  if (NULL == buffer) {
-    return NULL;
-  }
-  const char* const cwd = os::get_current_directory(buffer, O_BUFLEN);
-  if (NULL == cwd) {
-    return NULL;
-  }
-  size_t pos = strlen(cwd);
-  const int fsep_len = jio_snprintf(&buffer[pos], O_BUFLEN - pos, "%s", os::file_separator());
-  const char* filename_fmt = NULL;
-  // fetch specific error cause
-  switch (JfrJavaSupport::cause()) {
-    case JfrJavaSupport::OUT_OF_MEMORY:
-      filename_fmt = vm_oom_filename_fmt;
-      break;
-    case JfrJavaSupport::STACK_OVERFLOW:
-      filename_fmt = vm_soe_filename_fmt;
-      break;
-    default:
-      filename_fmt = vm_error_filename_fmt;
-  }
-  char* emergency_dump_path = NULL;
-  pos += fsep_len;
-  if (Arguments::copy_expand_pid(filename_fmt, strlen(filename_fmt), &buffer[pos], O_BUFLEN - pos)) {
-    const size_t emergency_filename_length = strlen(buffer);
-    emergency_dump_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, emergency_filename_length + 1);
-    if (NULL == emergency_dump_path) {
-      return NULL;
-    }
-    strncpy(emergency_dump_path, buffer, emergency_filename_length + 1);
-  }
-  return emergency_dump_path;
-}
-
-// Caller needs ResourceMark
-static const char* create_emergency_chunk_path(const char* repository_base, size_t repository_len) {
-  assert(repository_base != NULL, "invariant");
-  assert(JfrStream_lock->owned_by_self(), "invariant");
-  // date time
-  char date_time_buffer[32] = {0};
-  date_time(date_time_buffer, sizeof(date_time_buffer));
-  size_t date_time_len = strlen(date_time_buffer);
-  size_t chunkname_max_len = repository_len               // repository_base
-                             + 1                          // "/"
-                             + date_time_len              // date_time
-                             + strlen(chunk_file_jfr_ext) // .jfr
-                             + 1;
-  char* chunk_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, chunkname_max_len);
-  if (chunk_path == NULL) {
-    return NULL;
-  }
-  // append the individual substrings
-  jio_snprintf(chunk_path, chunkname_max_len, "%s%s%s%s", repository_base, os::file_separator(), date_time_buffer, chunk_file_jfr_ext);
-  return chunk_path;
-}
-
-static fio_fd emergency_dump_file() {
-  assert(JfrStream_lock->owned_by_self(), "invariant");
-  ResourceMark rm;
-  const char* const emergency_dump_path = create_emergency_dump_path();
-  if (emergency_dump_path == NULL) {
-    return invalid_fd;
-  }
-  const fio_fd fd = open_exclusivly(emergency_dump_path);
-  if (fd != invalid_fd) {
-    if (LogJFR) tty->print_cr( // For user, should not be "jfr, system"
-      "Attempting to recover JFR data, emergency jfr file: %s", emergency_dump_path);
-  }
-  return fd;
-}
-
-static const char* emergency_path(const char* repository, size_t repository_len) {
-  return repository == NULL ? create_emergency_dump_path() : create_emergency_chunk_path(repository, repository_len);
-}
-
 void JfrRepository::on_vm_error() {
   assert(!JfrStream_lock->owned_by_self(), "invariant");
-  const char* path = _path;
-  if (path == NULL) {
+  if (_path == NULL) {
     // completed already
     return;
   }
-  ResourceMark rm;
-  MutexLockerEx stream_lock(JfrStream_lock, Mutex::_no_safepoint_check_flag);
-  const fio_fd emergency_fd = emergency_dump_file();
-  if (emergency_fd != invalid_fd) {
-    RepositoryIterator iterator(path, strlen(path));
-    write_emergency_file(emergency_fd, iterator);
-    os::close(emergency_fd);
-  }
+  JfrEmergencyDump::on_vm_error(_path);
 }
 
 bool JfrRepository::set_path(const char* path) {
@@ -460,10 +159,7 @@
   assert(JfrStream_lock->owned_by_self(), "invariant");
   if (vm_error) {
     ResourceMark rm;
-    const char* repository_path = _path;
-    const size_t repository_path_len = repository_path != NULL ? strlen(repository_path) : 0;
-    const char* const path = emergency_path(repository_path, repository_path_len);
-    _chunkwriter->set_chunk_path(path);
+    _chunkwriter->set_chunk_path(JfrEmergencyDump::build_dump_path(_path));
   }
   return _chunkwriter->open();
 }
--- old/src/share/vm/jfr/recorder/service/jfrOptionSet.cpp	2019-09-02 18:08:19.977702100 +0300
+++ new/src/share/vm/jfr/recorder/service/jfrOptionSet.cpp	2019-09-02 18:08:19.427239800 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -27,6 +27,7 @@
 #include "jfr/recorder/service/jfrMemorySizer.hpp"
 #include "jfr/recorder/service/jfrOptionSet.hpp"
 #include "jfr/utilities/jfrAllocation.hpp"
+#include "jfr/utilities/jfrTypes.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
 #include "runtime/java.hpp"
@@ -105,10 +106,6 @@
   return _stack_depth;
 }
 
-static const u4 STACK_DEPTH_DEFAULT = 64;
-static const u4 MIN_STACK_DEPTH = 1;
-static const u4 MAX_STACK_DEPTH = 2048;
-
 void JfrOptionSet::set_stackdepth(u4 depth) {
   if (depth < MIN_STACK_DEPTH) {
     _stack_depth = MIN_STACK_DEPTH;
--- old/src/share/vm/jfr/recorder/stacktrace/jfrStackTraceRepository.cpp	2019-09-02 18:08:24.648844500 +0300
+++ new/src/share/vm/jfr/recorder/stacktrace/jfrStackTraceRepository.cpp	2019-09-02 18:08:24.062265400 +0300
@@ -69,8 +69,8 @@
   }
 
   // handle general case
-  int loop_count = 0;
-  int loop_max = MaxJavaStackTraceDepth * 2;
+  u4 loop_count = 0;
+  u4 loop_max = MAX_STACK_DEPTH * 2;
   do {
     loop_count++;
     // By the time we get here we should never see unsafe but better safe then segv'd
--- old/src/share/vm/jfr/recorder/storage/jfrBuffer.cpp	2019-09-02 18:08:29.795297000 +0300
+++ new/src/share/vm/jfr/recorder/storage/jfrBuffer.cpp	2019-09-02 18:08:29.093551200 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -137,6 +137,14 @@
   _identity = NULL;
 }
 
+bool JfrBuffer::acquired_by(const void* id) const {
+  return identity() == id;
+}
+
+bool JfrBuffer::acquired_by_self() const {
+  return acquired_by(Thread::current());
+}
+
 #ifdef ASSERT
 static bool validate_to(const JfrBuffer* const to, size_t size) {
   assert(to != NULL, "invariant");
@@ -154,10 +162,6 @@
   assert(t->top() + size <= t->pos(), "invariant");
   return true;
 }
-
-bool JfrBuffer::acquired_by_self() const {
-  return identity() == Thread::current();
-}
 #endif // ASSERT
 
 void JfrBuffer::move(JfrBuffer* const to, size_t size) {
@@ -184,7 +188,6 @@
   set_concurrent_top(start());
 }
 
-// flags
 enum FLAG {
   RETIRED = 1,
   TRANSIENT = 2,
--- old/src/share/vm/jfr/recorder/storage/jfrBuffer.hpp	2019-09-02 18:08:35.696200300 +0300
+++ new/src/share/vm/jfr/recorder/storage/jfrBuffer.hpp	2019-09-02 18:08:34.939800600 +0300
@@ -57,7 +57,6 @@
   u4 _size;
 
   const u1* stable_top() const;
-  void clear_flags();
 
  public:
   JfrBuffer();
@@ -150,6 +149,8 @@
 
   void acquire(const void* id);
   bool try_acquire(const void* id);
+  bool acquired_by(const void* id) const;
+  bool acquired_by_self() const;
   void release();
 
   void move(JfrBuffer* const to, size_t size);
@@ -166,8 +167,6 @@
   bool retired() const;
   void set_retired();
   void clear_retired();
-
-  debug_only(bool acquired_by_self() const;)
 };
 
 class JfrAgeNode : public JfrBuffer {
--- old/src/share/vm/jfr/recorder/storage/jfrMemorySpace.inline.hpp	2019-09-02 18:08:41.227200300 +0300
+++ new/src/share/vm/jfr/recorder/storage/jfrMemorySpace.inline.hpp	2019-09-02 18:08:40.476654200 +0300
@@ -346,19 +346,19 @@
 template <typename Mspace>
 inline bool ReleaseOp<Mspace>::process(typename Mspace::Type* t) {
   assert(t != NULL, "invariant");
-  if (t->retired() || t->try_acquire(_thread)) {
-    if (t->transient()) {
-      if (_release_full) {
-        mspace_release_full_critical(t, _mspace);
-      } else {
-        mspace_release_free_critical(t, _mspace);
-      }
-      return true;
+  // assumes some means of exclusive access to t
+  if (t->transient()) {
+    if (_release_full) {
+      mspace_release_full_critical(t, _mspace);
+    } else {
+      mspace_release_free_critical(t, _mspace);
     }
-    t->reinitialize();
-    assert(t->empty(), "invariant");
-    t->release(); // publish
+    return true;
   }
+  t->reinitialize();
+  assert(t->empty(), "invariant");
+  assert(!t->retired(), "invariant");
+  t->release(); // publish
   return true;
 }
 
--- old/src/share/vm/jfr/recorder/storage/jfrStorage.cpp	2019-09-02 18:08:46.888983600 +0300
+++ new/src/share/vm/jfr/recorder/storage/jfrStorage.cpp	2019-09-02 18:08:46.151127000 +0300
@@ -340,9 +340,9 @@
 void JfrStorage::register_full(BufferPtr buffer, Thread* thread) {
   assert(buffer != NULL, "invariant");
   assert(buffer->retired(), "invariant");
+  assert(buffer->acquired_by(thread), "invariant");
   if (!full_buffer_registration(buffer, _age_mspace, control(), thread)) {
     handle_registration_failure(buffer);
-    buffer->release();
   }
   if (control().should_post_buffer_full_message()) {
     _post_box.post(MSG_FULLBUFFER);
@@ -377,8 +377,8 @@
     }
   }
   assert(buffer->empty(), "invariant");
+  assert(buffer->identity() != NULL, "invariant");
   control().increment_dead();
-  buffer->release();
   buffer->set_retired();
 }
 
@@ -733,13 +733,14 @@
   Scavenger(JfrStorageControl& control, Mspace* mspace) : _control(control), _mspace(mspace), _count(0), _amount(0) {}
   bool process(Type* t) {
     if (t->retired()) {
+      assert(t->identity() != NULL, "invariant");
+      assert(t->empty(), "invariant");
       assert(!t->transient(), "invariant");
       assert(!t->lease(), "invariant");
-      assert(t->empty(), "invariant");
-      assert(t->identity() == NULL, "invariant");
       ++_count;
       _amount += t->total_size();
       t->clear_retired();
+      t->release();
       _control.decrement_dead();
       mspace_release_full_critical(t, _mspace);
     }
--- old/src/share/vm/jfr/recorder/storage/jfrStorageUtils.hpp	2019-09-02 18:08:52.654220900 +0300
+++ new/src/share/vm/jfr/recorder/storage/jfrStorageUtils.hpp	2019-09-02 18:08:51.914412100 +0300
@@ -92,7 +92,6 @@
   size_t processed() const { return ConcurrentWriteOp<Operation>::processed(); }
 };
 
-
 template <typename Operation>
 class MutexedWriteOp {
  private:
@@ -104,6 +103,15 @@
   size_t processed() const { return _operation.processed(); }
 };
 
+template <typename Operation>
+class ExclusiveOp : private MutexedWriteOp<Operation> {
+ public:
+  typedef typename Operation::Type Type;
+  ExclusiveOp(Operation& operation) : MutexedWriteOp<Operation>(operation) {}
+  bool process(Type* t);
+  size_t processed() const { return MutexedWriteOp<Operation>::processed(); }
+};
+
 enum jfr_operation_mode {
   mutexed = 1,
   concurrent
--- old/src/share/vm/jfr/recorder/storage/jfrStorageUtils.inline.hpp	2019-09-02 18:08:59.134868200 +0300
+++ new/src/share/vm/jfr/recorder/storage/jfrStorageUtils.inline.hpp	2019-09-02 18:08:58.272083300 +0300
@@ -26,6 +26,7 @@
 #define SHARE_VM_JFR_RECORDER_STORAGE_JFRSTORAGEUTILS_INLINE_HPP
 
 #include "jfr/recorder/storage/jfrStorageUtils.hpp"
+#include "runtime/thread.inline.hpp"
 
 template <typename T>
 inline bool UnBufferedWriteToChunk<T>::write(T* t, const u1* data, size_t size) {
@@ -75,6 +76,28 @@
   return result;
 }
 
+template <typename Type>
+static void retired_sensitive_acquire(Type* t) {
+  assert(t != NULL, "invariant");
+  if (t->retired()) {
+    return;
+  }
+  Thread* const thread = Thread::current();
+  while (!t->try_acquire(thread)) {
+    if (t->retired()) {
+      return;
+    }
+  }
+}
+
+template <typename Operation>
+inline bool ExclusiveOp<Operation>::process(typename Operation::Type* t) {
+  retired_sensitive_acquire(t);
+  assert(t->acquired_by_self() || t->retired(), "invariant");
+  // User is required to ensure proper release of the acquisition
+  return MutexedWriteOp<Operation>::process(t);
+}
+
 template <typename Operation>
 inline bool DiscardOp<Operation>::process(typename Operation::Type* t) {
   assert(t != NULL, "invariant");
--- old/src/share/vm/jfr/recorder/stringpool/jfrStringPool.cpp	2019-09-02 18:09:05.382252000 +0300
+++ new/src/share/vm/jfr/recorder/stringpool/jfrStringPool.cpp	2019-09-02 18:09:04.633658900 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -139,93 +139,76 @@
   return current_epoch;
 }
 
-class StringPoolWriteOp  {
+template <template <typename> class Operation>
+class StringPoolOp {
  public:
   typedef JfrStringPoolBuffer Type;
  private:
-  UnBufferedWriteToChunk<Type> _writer;
+  Operation<Type> _op;
   Thread* _thread;
   size_t _strings_processed;
  public:
-  StringPoolWriteOp(JfrChunkWriter& writer, Thread* thread) : _writer(writer), _thread(thread), _strings_processed(0) {}
+  StringPoolOp() : _op(), _thread(Thread::current()), _strings_processed(0) {}
+  StringPoolOp(JfrChunkWriter& writer, Thread* thread) : _op(writer), _thread(thread), _strings_processed(0) {}
   bool write(Type* buffer, const u1* data, size_t size) {
-    buffer->acquire(_thread); // blocking
+    assert(buffer->acquired_by(_thread) || buffer->retired(), "invariant");
     const uint64_t nof_strings_used = buffer->string_count();
     assert(nof_strings_used > 0, "invariant");
     buffer->set_string_top(buffer->string_top() + nof_strings_used);
     // "size processed" for string pool buffers is the number of processed string elements
     _strings_processed += nof_strings_used;
-    const bool ret = _writer.write(buffer, data, size);
-    buffer->release();
-    return ret;
+    return _op.write(buffer, data, size);
   }
   size_t processed() { return _strings_processed; }
 };
 
-typedef StringPoolWriteOp WriteOperation;
-typedef ConcurrentWriteOp<WriteOperation> ConcurrentWriteOperation;
-
-size_t JfrStringPool::write() {
-  Thread* const thread = Thread::current();
-  WriteOperation wo(_chunkwriter, thread);
-  ConcurrentWriteOperation cwo(wo);
-  assert(_free_list_mspace->is_full_empty(), "invariant");
-  process_free_list(cwo, _free_list_mspace);
-  return wo.processed();
-}
+template <typename Type>
+class StringPoolDiscarderStub {
+ public:
+  bool write(Type* buffer, const u1* data, size_t size) {
+    // stub only, discard happens at higher level
+    return true;
+  }
+};
 
-typedef MutexedWriteOp<WriteOperation> MutexedWriteOperation;
+typedef StringPoolOp<UnBufferedWriteToChunk> WriteOperation;
+typedef StringPoolOp<StringPoolDiscarderStub> DiscardOperation;
+typedef ExclusiveOp<WriteOperation> ExclusiveWriteOperation;
+typedef ExclusiveOp<DiscardOperation> ExclusiveDiscardOperation;
 typedef ReleaseOp<JfrStringPoolMspace> StringPoolReleaseOperation;
-typedef CompositeOperation<MutexedWriteOperation, StringPoolReleaseOperation> StringPoolWriteOperation;
+typedef CompositeOperation<ExclusiveWriteOperation, StringPoolReleaseOperation> StringPoolWriteOperation;
+typedef CompositeOperation<ExclusiveDiscardOperation, StringPoolReleaseOperation> StringPoolDiscardOperation;
 
-size_t JfrStringPool::write_at_safepoint() {
-  assert(SafepointSynchronize::is_at_safepoint(), "invariant");
+size_t JfrStringPool::write() {
   Thread* const thread = Thread::current();
   WriteOperation wo(_chunkwriter, thread);
-  MutexedWriteOperation mwo(wo);
+  ExclusiveWriteOperation ewo(wo);
   StringPoolReleaseOperation spro(_free_list_mspace, thread, false);
-  StringPoolWriteOperation spwo(&mwo, &spro);
+  StringPoolWriteOperation spwo(&ewo, &spro);
   assert(_free_list_mspace->is_full_empty(), "invariant");
   process_free_list(spwo, _free_list_mspace);
   return wo.processed();
 }
 
-class StringPoolBufferDiscarder {
- private:
-  Thread* _thread;
-  size_t _processed;
- public:
-  typedef JfrStringPoolBuffer Type;
-  StringPoolBufferDiscarder() : _thread(Thread::current()), _processed(0) {}
-  bool process(Type* buffer) {
-    buffer->acquire(_thread); // serialized access
-    const u1* const current_top = buffer->top();
-    const size_t unflushed_size = buffer->pos() - current_top;
-    if (unflushed_size == 0) {
-      assert(buffer->string_count() == 0, "invariant");
-      buffer->release();
-      return true;
-    }
-    buffer->set_top(current_top + unflushed_size);
-    const uint64_t nof_strings_used = buffer->string_count();
-    buffer->set_string_top(buffer->string_top() + nof_strings_used);
-    // "size processed" for string pool buffers is the number of string elements
-    _processed += (size_t)nof_strings_used;
-    buffer->release();
-    return true;
-  }
-  size_t processed() const { return _processed; }
-};
+size_t JfrStringPool::write_at_safepoint() {
+  assert(SafepointSynchronize::is_at_safepoint(), "invariant");
+  return write();
+}
 
 size_t JfrStringPool::clear() {
-  StringPoolBufferDiscarder discard_operation;
+  DiscardOperation discard_operation;
+  ExclusiveDiscardOperation edo(discard_operation);
+  StringPoolReleaseOperation spro(_free_list_mspace, Thread::current(), false);
+  StringPoolDiscardOperation spdo(&edo, &spro);
   assert(_free_list_mspace->is_full_empty(), "invariant");
-  process_free_list(discard_operation, _free_list_mspace);
+  process_free_list(spdo, _free_list_mspace);
   return discard_operation.processed();
 }
 
 void JfrStringPool::register_full(BufferPtr t, Thread* thread) {
   // nothing here at the moment
+  assert(t != NULL, "invariant");
+  assert(t->acquired_by(thread), "invariant");
   assert(t->retired(), "invariant");
 }
 
--- old/src/share/vm/jfr/recorder/stringpool/jfrStringPoolBuffer.cpp	2019-09-02 18:09:11.082099300 +0300
+++ new/src/share/vm/jfr/recorder/stringpool/jfrStringPoolBuffer.cpp	2019-09-02 18:09:10.344242900 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,11 +29,9 @@
 
 void JfrStringPoolBuffer::reinitialize() {
   assert(acquired_by_self() || retired(), "invariant");
-  concurrent_top();
-  set_pos((start()));
   set_string_pos(0);
   set_string_top(0);
-  set_concurrent_top(start());
+  JfrBuffer::reinitialize();
 }
 
 uint64_t JfrStringPoolBuffer::string_pos() const {
@@ -57,7 +55,7 @@
 }
 
 void JfrStringPoolBuffer::increment(uint64_t value) {
-  assert(acquired_by_self() || retired(), "invariant");
+  assert(acquired_by_self(), "invariant");
   ++_string_count_pos;
 }
 
--- old/src/share/vm/jfr/utilities/jfrTypes.hpp	2019-09-02 18:09:16.792682700 +0300
+++ new/src/share/vm/jfr/utilities/jfrTypes.hpp	2019-09-02 18:09:16.048969100 +0300
@@ -33,6 +33,9 @@
 typedef int fio_fd;
 const int invalid_fd = -1;
 const jlong invalid_offset = -1;
+const u4 STACK_DEPTH_DEFAULT = 64;
+const u4 MIN_STACK_DEPTH = 1;
+const u4 MAX_STACK_DEPTH = 2048;
 
 enum EventStartTime {
   UNTIMED,
--- old/src/share/vm/memory/allocation.hpp	2019-09-02 18:09:22.488624300 +0300
+++ new/src/share/vm/memory/allocation.hpp	2019-09-02 18:09:21.756623300 +0300
@@ -154,8 +154,9 @@
   mtChunk             = 0x0C,  // chunk that holds content of arenas
   mtTest              = 0x0D,  // Test type for verifying NMT
   mtTracing           = 0x0E,  // memory used for Tracing
-  mtNone              = 0x0F,  // undefined
-  mt_number_of_types  = 0x10   // number of memory types (mtDontTrack
+  mtStatistics        = 0x0F,
+  mtNone              = 0x10,  // undefined
+  mt_number_of_types  = 0x11   // number of memory types (mtDontTrack
                                  // is not included as validate type)
 };
 
--- old/src/share/vm/runtime/vm_version.cpp	2019-09-02 18:09:28.092823300 +0300
+++ new/src/share/vm/runtime/vm_version.cpp	2019-09-02 18:09:27.358873500 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -53,6 +53,8 @@
 unsigned int Abstract_VM_Version::_L1_data_cache_line_size = 0;
 int Abstract_VM_Version::_reserve_for_allocation_prefetch = 0;
 
+VirtualizationType Abstract_VM_Version::_detected_virtualization = NoDetectedVirtualization;
+
 #ifndef HOTSPOT_RELEASE_VERSION
   #error HOTSPOT_RELEASE_VERSION must be defined
 #endif
@@ -287,7 +289,6 @@
          (Abstract_VM_Version::vm_build_number() & 0xFF);
 }
 
-
 void VM_Version_init() {
   VM_Version::initialize();
 
@@ -298,6 +299,28 @@
 #endif
 }
 
+bool Abstract_VM_Version::print_matching_lines_from_file(const char* filename, outputStream* st, const char* keywords_to_match[]) {
+  char line[500];
+  FILE* fp = fopen(filename, "r");
+  if (fp == NULL) {
+    return false;
+  }
+
+  st->print_cr("Virtualization information:");
+  while (fgets(line, sizeof(line), fp) != NULL) {
+    int i = 0;
+    while (keywords_to_match[i] != NULL) {
+      if (strncmp(line, keywords_to_match[i], strlen(keywords_to_match[i])) == 0) {
+        st->print("%s", line);
+        break;
+      }
+      i++;
+    }
+  }
+  fclose(fp);
+  return true;
+}
+
 unsigned int Abstract_VM_Version::nof_parallel_worker_threads(
                                                       unsigned int num,
                                                       unsigned int den,
--- old/src/share/vm/runtime/vm_version.hpp	2019-09-02 18:09:33.604301800 +0300
+++ new/src/share/vm/runtime/vm_version.hpp	2019-09-02 18:09:32.761036700 +0300
@@ -28,6 +28,17 @@
 #include "memory/allocation.hpp"
 #include "utilities/ostream.hpp"
 
+typedef enum {
+  NoDetectedVirtualization,
+  XenHVM,
+  KVM,
+  VMWare,
+  HyperV,
+  PowerVM, // on AIX or Linux ppc64(le)
+  PowerFullPartitionMode, // on Linux ppc64(le)
+  PowerKVM
+} VirtualizationType;
+
 // VM_Version provides information about the VM.
 
 class Abstract_VM_Version: AllStatic {
@@ -54,7 +65,9 @@
   static unsigned int nof_parallel_worker_threads(unsigned int num,
                                                   unsigned int dem,
                                                   unsigned int switch_pt);
- public:
+  static VirtualizationType _detected_virtualization;
+
+public:
   // Called as part of the runtime services initialization which is
   // called from the management module initialization (via init_globals())
   // after argument parsing and attaching of the main thread has
@@ -96,6 +109,14 @@
   static const char* internal_vm_info_string();
   static const char* jre_release_version();
 
+  static VirtualizationType get_detected_virtualization() {
+    return _detected_virtualization;
+  }
+
+  // platforms that need to specialize this
+  // define VM_Version::print_platform_virtualization_info()
+  static void print_platform_virtualization_info(outputStream*) { }
+
   // does HW support an 8-byte compare-exchange operation?
   static bool supports_cx8()  {
     assert(_initialized, "not initialized");
@@ -143,6 +164,8 @@
   // Calculates and returns the number of parallel threads.  May
   // be VM version specific.
   static unsigned int calc_parallel_worker_threads();
+
+  static bool print_matching_lines_from_file(const char* filename, outputStream* st, const char* keywords_to_match[]);
 };
 
 #endif // SHARE_VM_RUNTIME_VM_VERSION_HPP
--- old/src/share/vm/services/nmtCommon.cpp	2019-09-02 18:09:40.546599400 +0300
+++ new/src/share/vm/services/nmtCommon.cpp	2019-09-02 18:09:39.634037100 +0300
@@ -40,6 +40,7 @@
   "Arena Chunk",
   "Test",
   "Tracing",
+  "Statistics",
   "Unknown"
 };
 
--- old/src/share/vm/utilities/hashtable.cpp	2019-09-02 18:09:47.305408500 +0300
+++ new/src/share/vm/utilities/hashtable.cpp	2019-09-02 18:09:46.406509700 +0300
@@ -268,16 +268,28 @@
   }
 }
 
-template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(Symbol *symbol) {
+// For oops and Strings the size of the literal is interesting. For other types, nobody cares.
+int literal_size(ConstantPool*) { return 0; }
+int literal_size(Klass*)        { return 0; }
+#if INCLUDE_ALL_GCS
+int literal_size(nmethod*)      { return 0; }
+#endif
+
+int literal_size(Symbol *symbol) {
   return symbol->size() * HeapWordSize;
 }
 
-template <class T, MEMFLAGS F> int RehashableHashtable<T, F>::literal_size(oop oop) {
+int literal_size(oop obj) {
   // NOTE: this would over-count if (pre-JDK8) java_lang_Class::has_offset_field() is true,
   // and the String.value array is shared by several Strings. However, starting from JDK8,
   // the String.value array is not shared anymore.
-  assert(oop != NULL && oop->klass() == SystemDictionary::String_klass(), "only strings are supported");
-  return (oop->size() + java_lang_String::value(oop)->size()) * HeapWordSize;
+  if (obj == NULL) {
+    return 0;
+  } else if (obj->klass() == SystemDictionary::String_klass()) {
+    return (obj->size() + java_lang_String::value(obj)->size()) * HeapWordSize;
+  } else {
+    return obj->size();
+  }
 }
 
 // Dump footprint and bucket length statistics
@@ -337,6 +349,21 @@
   *top += len;
 }
 
+template <class T, MEMFLAGS F> TableStatistics Hashtable<T, F>::statistics_calculate(T (*literal_load_barrier)(HashtableEntry<T, F>*)) {
+  NumberSeq summary;
+  int literal_bytes = 0;
+  for (int i = 0; i < this->table_size(); ++i) {
+    int count = 0;
+    for (HashtableEntry<T, F>* e = this->bucket(i);
+         e != NULL; e = e->next()) {
+      count++;
+      T l = (literal_load_barrier != NULL) ? literal_load_barrier(e) : e->literal();
+      literal_bytes += literal_size(l);
+    }
+    summary.add((double)count);
+  }
+  return TableStatistics(this->_stats_rate, summary, literal_bytes, sizeof(HashtableBucket<F>), sizeof(HashtableEntry<T, F>));
+}
 
 #ifndef PRODUCT
 
--- old/src/share/vm/utilities/hashtable.hpp	2019-09-02 18:09:54.037864400 +0300
+++ new/src/share/vm/utilities/hashtable.hpp	2019-09-02 18:09:53.148727300 +0300
@@ -30,6 +30,7 @@
 #include "oops/oop.hpp"
 #include "oops/symbol.hpp"
 #include "runtime/handles.hpp"
+#include "utilities/tableStatistics.hpp"
 
 // This is a generic hashtable, designed to be used for the symbol
 // and string tables.
@@ -178,6 +179,8 @@
   void verify_lookup_length(double load);
 #endif
 
+  TableRateStatistics _stats_rate;
+
   void initialize(int table_size, int entry_size, int number_of_entries);
 
   // Accessor
@@ -267,6 +270,8 @@
   // addresses, and appear first in the list.
   void reverse(void* boundary = NULL);
 
+  TableStatistics statistics_calculate(T (*literal_load_barrier)(HashtableEntry<T, F>*) = NULL);
+
 protected:
 
   unsigned int compute_hash(Symbol* name) {
@@ -317,16 +322,6 @@
   static bool use_alternate_hashcode()  { return _seed != 0; }
   static juint seed()                    { return _seed; }
 
-  static int literal_size(Symbol *symbol);
-  static int literal_size(oop oop);
-
-  // The following two are currently not used, but are needed anyway because some
-  // C++ compilers (MacOS and Solaris) force the instantiation of
-  // Hashtable<ConstantPool*, mtClass>::dump_table() even though we never call this function
-  // in the VM code.
-  static int literal_size(ConstantPool *cp) {Unimplemented(); return 0;}
-  static int literal_size(Klass *k)         {Unimplemented(); return 0;}
-
   void dump_table(outputStream* st, const char *table_name);
 
  private:
--- old/src/share/vm/utilities/hashtable.inline.hpp	2019-09-02 18:10:00.880607500 +0300
+++ new/src/share/vm/utilities/hashtable.inline.hpp	2019-09-02 18:09:59.870446600 +0300
@@ -43,6 +43,7 @@
   for (int index = 0; index < _table_size; index++) {
     _buckets[index].clear();
   }
+  _stats_rate = TableRateStatistics();
 }
 
 
@@ -52,6 +53,7 @@
   // Called on startup, no locking needed
   initialize(table_size, entry_size, number_of_entries);
   _buckets = buckets;
+  _stats_rate = TableRateStatistics();
 }
 
 
@@ -97,6 +99,11 @@
 
 template <MEMFLAGS F> inline void BasicHashtable<F>::set_entry(int index, BasicHashtableEntry<F>* entry) {
   _buckets[index].set_entry(entry);
+  if (entry != NULL) {
+    JFR_ONLY(_stats_rate.add();)
+  } else {
+    JFR_ONLY(_stats_rate.remove();)
+  }
 }
 
 
@@ -104,12 +111,14 @@
   entry->set_next(bucket(index));
   _buckets[index].set_entry(entry);
   ++_number_of_entries;
+  JFR_ONLY(_stats_rate.add();)
 }
 
 template <MEMFLAGS F> inline void BasicHashtable<F>::free_entry(BasicHashtableEntry<F>* entry) {
   entry->set_next(_free_list);
   _free_list = entry;
   --_number_of_entries;
+  JFR_ONLY(_stats_rate.remove();)
 }
 
 #endif // SHARE_VM_UTILITIES_HASHTABLE_INLINE_HPP
--- old/test/testlibrary/com/oracle/java/testlibrary/DockerRunOptions.java	2019-09-02 18:10:08.016156600 +0300
+++ new/test/testlibrary/com/oracle/java/testlibrary/DockerRunOptions.java	2019-09-02 18:10:07.106518500 +0300
@@ -70,4 +70,8 @@
         return this;
     }
 
+    public DockerRunOptions addClassOptions(String... opts) {
+        Collections.addAll(classParams,opts);
+        return this;
+    }
 }
--- old/test/testlibrary/com/oracle/java/testlibrary/DockerTestUtils.java	2019-09-02 18:10:14.946741600 +0300
+++ new/test/testlibrary/com/oracle/java/testlibrary/DockerTestUtils.java	2019-09-02 18:10:13.989279200 +0300
@@ -167,15 +167,15 @@
 
 
     /**
-     * Run Java inside the docker image with specified parameters and options.
+     * Build the docker command to run java inside a container
      *
      * @param DockerRunOptions optins for running docker
      *
-     * @return output of the run command
+     * @return command
      * @throws Exception
      */
-    public static OutputAnalyzer dockerRunJava(DockerRunOptions opts) throws Exception {
-        ArrayList<String> cmd = new ArrayList<>();
+    public static List<String> buildJavaCommand(DockerRunOptions opts) throws Exception {
+        List<String> cmd = new ArrayList<>();
 
         cmd.add("docker");
         cmd.add("run");
@@ -195,9 +195,20 @@
 
         cmd.add(opts.classToRun);
         cmd.addAll(opts.classParams);
-        return execute(cmd);
+        return cmd;
     }
 
+    /**
+     * Run Java inside the docker image with specified parameters and options.
+     *
+     * @param DockerRunOptions optins for running docker
+     *
+     * @return output of the run command
+     * @throws Exception
+     */
+    public static OutputAnalyzer dockerRunJava(DockerRunOptions opts) throws Exception {
+        return execute(buildJavaCommand(opts));
+    }
 
      /**
      * Remove docker image
--- /dev/null	2019-09-02 18:10:21.000000000 +0300
+++ new/src/share/vm/utilities/tableStatistics.cpp	2019-09-02 18:10:20.590952600 +0300
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "runtime/atomic.hpp"
+#include "runtime/atomic.inline.hpp"
+#include "runtime/os.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/macros.hpp"
+#include "utilities/tableStatistics.hpp"
+#if INCLUDE_JFR
+#include "jfr/jfr.hpp"
+#endif
+
+TableRateStatistics::TableRateStatistics() :
+  _added_items(0), _removed_items(0),
+  _time_stamp(0), _seconds_stamp(0),
+  _added_items_stamp(0), _added_items_stamp_prev(0),
+  _removed_items_stamp(0), _removed_items_stamp_prev(0) {}
+
+TableRateStatistics::~TableRateStatistics() { };
+
+void TableRateStatistics::add() {
+#if INCLUDE_JFR
+  if (Jfr::is_recording()) {
+    Atomic::inc_ptr(&_added_items);
+  }
+#endif
+}
+
+void TableRateStatistics::remove() {
+#if INCLUDE_JFR
+  if (Jfr::is_recording()) {
+    Atomic::inc_ptr(&_removed_items);
+  }
+#endif
+}
+
+void TableRateStatistics::stamp() {
+  jlong now = os::javaTimeNanos();
+
+  _added_items_stamp_prev = _added_items_stamp;
+  _removed_items_stamp_prev = _removed_items_stamp;
+
+  _added_items_stamp = _added_items;
+  _removed_items_stamp = _removed_items;
+
+  if (_time_stamp == 0) {
+    _time_stamp = now - 1000000000;
+  }
+  jlong diff = (now - _time_stamp);
+  _seconds_stamp = (float)diff / 1000000000.0;
+  _time_stamp = now;
+}
+
+float TableRateStatistics::get_add_rate() {
+  return (float)((_added_items_stamp - _added_items_stamp_prev) / _seconds_stamp);
+}
+
+float TableRateStatistics::get_remove_rate() {
+  return (float)((_removed_items_stamp - _removed_items_stamp_prev) / _seconds_stamp);
+}
+
+TableStatistics::TableStatistics() :
+  _literal_bytes(0),
+  _number_of_buckets(0), _number_of_entries(0),
+  _maximum_bucket_size(0), _average_bucket_size(0),
+  _variance_of_bucket_size(0), _stddev_of_bucket_size(0),
+  _bucket_bytes(0), _entry_bytes(0), _total_footprint(0),
+  _bucket_size(0), _entry_size(0),
+  _add_rate(0), _remove_rate(0) {
+}
+
+TableStatistics::TableStatistics(TableRateStatistics& rate_stats, NumberSeq summary, size_t literal_bytes, size_t bucket_bytes, size_t node_bytes) :
+  _literal_bytes(literal_bytes),
+  _number_of_buckets(0), _number_of_entries(0),
+  _maximum_bucket_size(0), _average_bucket_size(0),
+  _variance_of_bucket_size(0), _stddev_of_bucket_size(0),
+  _bucket_bytes(0), _entry_bytes(0), _total_footprint(0),
+  _bucket_size(0), _entry_size(0),
+  _add_rate(0), _remove_rate(0) {
+
+  _number_of_buckets = summary.num();
+  _number_of_entries = (size_t)summary.sum();
+
+  _maximum_bucket_size = (size_t)summary.maximum();
+  _average_bucket_size = summary.avg();
+  _variance_of_bucket_size = summary.variance();
+  _stddev_of_bucket_size = summary.sd();
+
+  _bucket_bytes = _number_of_buckets * bucket_bytes;
+  _entry_bytes = _number_of_entries * node_bytes;
+  _total_footprint = _literal_bytes + _bucket_bytes + _entry_bytes;
+
+  _bucket_size = (_number_of_buckets <= 0) ? 0 : (_bucket_bytes / _number_of_buckets);
+  _entry_size = (_number_of_entries <= 0) ? 0 : (_entry_bytes / _number_of_entries);
+
+#if INCLUDE_JFR
+  if (Jfr::is_recording()) {
+    rate_stats.stamp();
+    _add_rate = rate_stats.get_add_rate();
+    _remove_rate = rate_stats.get_remove_rate();
+  }
+#endif
+}
+
+TableStatistics::~TableStatistics() { }
+
+void TableStatistics::print(outputStream* st, const char *table_name) {
+  st->print_cr("%s statistics:", table_name);
+  st->print_cr("Number of buckets       : %9" PRIuPTR " = %9" PRIuPTR
+               " bytes, each " SIZE_FORMAT,
+              _number_of_buckets, _bucket_bytes, _bucket_size);
+  st->print_cr("Number of entries       : %9" PRIuPTR " = %9" PRIuPTR
+               " bytes, each " SIZE_FORMAT,
+               _number_of_entries, _entry_bytes, _entry_size);
+  if (_literal_bytes != 0) {
+    float literal_avg = (_number_of_entries <= 0) ? 0 : (_literal_bytes / _number_of_entries);
+    st->print_cr("Number of literals      : %9" PRIuPTR " = %9" PRIuPTR
+                 " bytes, avg %7.3f",
+                 _number_of_entries, _literal_bytes, literal_avg);
+  }
+  st->print_cr("Total footprint         : %9s = %9" PRIuPTR " bytes", "", _total_footprint);
+  st->print_cr("Average bucket size     : %9.3f", _average_bucket_size);
+  st->print_cr("Variance of bucket size : %9.3f", _variance_of_bucket_size);
+  st->print_cr("Std. dev. of bucket size: %9.3f", _stddev_of_bucket_size);
+  st->print_cr("Maximum bucket size     : %9" PRIuPTR, _maximum_bucket_size);
+}
+
--- /dev/null	2019-09-02 18:10:27.000000000 +0300
+++ new/src/share/vm/utilities/tableStatistics.hpp	2019-09-02 18:10:26.595311100 +0300
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_UTILITIES_TABLE_STATISTICS_HPP
+#define SHARE_UTILITIES_TABLE_STATISTICS_HPP
+
+#include "memory/allocation.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/numberSeq.hpp"
+
+class TableRateStatistics : CHeapObj<mtStatistics> {
+
+  friend class TableStatistics;
+
+private:
+  volatile size_t _added_items;
+  volatile size_t _removed_items;
+
+  jlong _time_stamp;
+  double _seconds_stamp;
+  size_t _added_items_stamp;
+  size_t _added_items_stamp_prev;
+  size_t _removed_items_stamp;
+  size_t _removed_items_stamp_prev;
+
+public:
+  TableRateStatistics();
+  ~TableRateStatistics();
+
+  void add();
+  void remove();
+
+protected:
+  void stamp();
+  float get_add_rate();
+  float get_remove_rate();
+};
+
+class TableStatistics : CHeapObj<mtStatistics> {
+
+public:
+  size_t _literal_bytes;
+
+  size_t _number_of_buckets;
+  size_t _number_of_entries;
+
+  size_t _maximum_bucket_size;
+  float _average_bucket_size;
+  float _variance_of_bucket_size;
+  float _stddev_of_bucket_size;
+
+  size_t _bucket_bytes;
+  size_t _entry_bytes;
+  size_t _total_footprint;
+
+  size_t _bucket_size;
+  size_t _entry_size;
+
+  float _add_rate;
+  float _remove_rate;
+
+  TableStatistics();
+  TableStatistics(TableRateStatistics& rate_stats, NumberSeq summary, size_t literal_bytes, size_t bucket_bytes, size_t node_bytes);
+  ~TableStatistics();
+
+  void print(outputStream* st, const char *table_name);
+};
+
+#endif // SHARE_UTILITIES_TABLE_STATISTICS_HPP
--- /dev/null	2019-09-02 18:10:33.000000000 +0300
+++ new/test/runtime/containers/docker/JfrNetwork.java	2019-09-02 18:10:32.383972800 +0300
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.nio.file.Paths;
+import java.util.List;
+import jdk.jfr.Recording;
+import jdk.jfr.consumer.RecordedEvent;
+import jdk.jfr.consumer.RecordingFile;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+
+
+// This class is intended to run inside a container
+public class JfrNetwork {
+    // use a unique hostname for container
+    public static final String HOST_NAME = "container-unique-8221711";
+    public static final String JFR_REPORTED_CONTAINER_HOSTNAME_TAG = "jfr_reported_container_hostname=";
+
+    public static void main(String[] args) throws Exception {
+        String event = args[0];
+        try (ServerSocket ss = new ServerSocket()) {
+            testNetworkInfo(ss, event);
+        }
+    }
+
+    private static void assertTrue(boolean expr, String msg) {
+        if (!expr) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    private static void testNetworkInfo(ServerSocket ss, String event) throws Exception {
+        ServerSocketListener server = new ServerSocketListener(ss);
+        server.start();
+        SocketWriter writer = new SocketWriter(ss.getLocalSocketAddress());
+
+        // setup and start the recording
+        String recordingPath = event + ".jfr";
+        log("========= Recording event: " + event);
+        Recording r = new Recording();
+        r.enable(event);
+        r.setDestination(Paths.get("/", "tmp", recordingPath));
+        r.start();
+
+        // start the socker writer thread, write some data into the socket
+        writer.start();
+
+        // wait for writer thread to terminate, then for server thread, then stop recording
+        writer.joinAndThrow();
+        server.joinAndThrow();
+        r.stop();
+
+        // analyze the recording
+        List<RecordedEvent> events = RecordingFile.readAllEvents(r.getDestination());
+        events.forEach(e -> log ("event = " + e));
+        assertTrue(!events.isEmpty(), "No recorded network events");
+        RecordedEvent e = events.get(0);
+        log(JFR_REPORTED_CONTAINER_HOSTNAME_TAG + e.getString("host"));
+        verifyIpAddress(e.getString("address"));
+    }
+
+    private static void verifyIpAddress(String eventIp) throws Exception {
+        ProcessBuilder pb = new ProcessBuilder("hostname", "--ip-address");
+        OutputAnalyzer out = new OutputAnalyzer(pb.start());
+        out.shouldHaveExitValue(0);
+        log("hostname --ip-address returned: " + out.getOutput());
+        out.shouldContain(eventIp);
+    }
+
+    private static void log(String msg) {
+        System.out.println(msg);
+    }
+
+
+    private static class ServerSocketListener extends Thread {
+        Exception exception;
+        ServerSocket ss;
+
+        ServerSocketListener(ServerSocket socket) throws Exception {
+            ss = socket;
+            ss.setReuseAddress(true);
+            ss.bind(null);
+            log("ServerSocker Local Address: " + ss.getLocalSocketAddress());
+        }
+
+        public void joinAndThrow() throws Exception {
+            join();
+            if (exception != null) {
+                throw exception;
+            }
+        }
+
+        public void run() {
+            try {
+                try (Socket s = ss.accept(); InputStream is = s.getInputStream()) {
+                    System.out.println("ServerSocketListener: accepted socket connection: s = " + s);
+                    is.read();
+                    is.read();
+                    is.read();
+                }
+            } catch (Exception e) {
+                exception = e;
+            }
+        }
+    }
+
+
+    private static class SocketWriter extends Thread {
+        Exception exception;
+        private SocketAddress ssAddr;
+
+        public SocketWriter(SocketAddress sa) {
+            this.ssAddr = sa;
+            System.out.println("SocketWriter(): sa = " + sa);
+        }
+
+        public void joinAndThrow() throws Exception {
+            join();
+            if (exception != null) {
+                throw exception;
+            }
+        }
+
+        public void run() {
+            try (Socket s = new Socket()) {
+                s.connect(ssAddr);
+                try (OutputStream os = s.getOutputStream()) {
+                    os.write('A');
+                    os.write('B');
+                    os.write('C');
+                }
+            } catch (Exception e) {
+                exception = e;
+            }
+        }
+    }
+
+}
--- /dev/null	2019-09-02 18:10:37.000000000 +0300
+++ new/test/runtime/containers/docker/JfrReporter.java	2019-09-02 18:10:36.768171500 +0300
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import jdk.jfr.Recording;
+import jdk.jfr.ValueDescriptor;
+import jdk.jfr.consumer.RecordedEvent;
+import jdk.jfr.consumer.RecordingFile;
+
+// This class is intended to run inside a container
+public class JfrReporter {
+    public static void main(String[] args) throws Exception {
+        String eventName = args[0];
+        try(Recording r = new Recording()) {
+            r.enable(eventName);
+            r.start();
+            r.stop();
+            Path p = Paths.get("/", "tmp", eventName + ".jfr");
+            r.dump(p);
+            for (RecordedEvent e : RecordingFile.readAllEvents(p)) {
+                System.out.println("===== EventType: " + e.getEventType().getName());
+                for (ValueDescriptor v : e.getEventType().getFields()) {
+                    System.out.println(v.getName() + " = " + e.getValue(v.getName()));
+                }
+            }
+        }
+    }
+}
+  
\ No newline at end of file
--- /dev/null	2019-09-02 18:10:42.000000000 +0300
+++ new/test/runtime/containers/docker/TestJFREvents.java	2019-09-02 18:10:41.295840000 +0300
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/*
+ * @test
+ * @summary Ensure that certain JFR events return correct results for resource values
+ *          when run inside Docker container, such as available CPU and memory.
+ *          Also make sure that PIDs are based on value provided by container,
+ *          not by the host system.
+ * @requires (os.maxMemory >= 2g)
+ * @library /testlibrary
+ * @build JfrReporter
+ * @run driver TestJFREvents
+ */
+import java.util.List;
+import com.oracle.java.testlibrary.Common;
+import com.oracle.java.testlibrary.DockerRunOptions;
+import com.oracle.java.testlibrary.DockerTestUtils;
+import com.oracle.java.testlibrary.Asserts;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import com.oracle.java.testlibrary.Utils;
+
+
+public class TestJFREvents {
+    private static final String imageName = Common.imageName("jfr-events");
+    private static final String TEST_ENV_VARIABLE = "UNIQUE_VARIABLE_ABC592903XYZ";
+    private static final String TEST_ENV_VALUE = "unique_value_abc592903xyz";
+    private static final int availableCPUs = Runtime.getRuntime().availableProcessors();
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("Test Environment: detected availableCPUs = " + availableCPUs);
+        if (!DockerTestUtils.canTestDocker()) {
+            return;
+        }
+
+        DockerTestUtils.buildJdkDockerImage(imageName, "Dockerfile-BasicTest", "jdk-docker");
+
+        try {
+            // leave one CPU for system and tools, otherwise this test may be unstable
+            int maxNrOfAvailableCpus =  availableCPUs - 1;
+            for (int i=1; i < maxNrOfAvailableCpus; i = i * 2) {
+                testCPUInfo(i, i);
+            }
+
+            long MB = 1024*1024;
+            testMemory("200m", "" + 200*MB);
+            testMemory("500m", "" + 500*MB);
+            testMemory("1g", "" + 1024*MB);
+
+            testProcessInfo();
+
+            testEnvironmentVariables();
+        } finally {
+            DockerTestUtils.removeDockerImage(imageName);
+        }
+    }
+
+
+    private static void testCPUInfo(int valueToSet, int expectedValue) throws Exception {
+        Common.logNewTestCase("CPUInfo: --cpus = " + valueToSet);
+        DockerTestUtils.dockerRunJava(
+                                      commonDockerOpts()
+                                      .addDockerOpts("--cpus=" + valueToSet)
+                                      .addClassOptions("jdk.CPUInformation"))
+            .shouldHaveExitValue(0);
+        // The following assertion is currently disabled due to JFR reporting incorrect values.
+        // JFR reports values for the host system as opposed to values for the container.
+        // @ignore 8219999
+        // .shouldContain("cores = " + expectedValue");
+    }
+
+
+    private static void testMemory(String valueToSet, String expectedValue) throws Exception {
+        Common.logNewTestCase("Memory: --memory = " + valueToSet);
+        DockerTestUtils.dockerRunJava(
+                                      commonDockerOpts()
+                                      .addDockerOpts("--memory=" + valueToSet)
+                                      .addClassOptions("jdk.PhysicalMemory"))
+            .shouldHaveExitValue(0)
+            .shouldContain("totalSize = " + expectedValue);
+    }
+
+
+    private static void testProcessInfo() throws Exception {
+        Common.logNewTestCase("ProcessInfo");
+        DockerTestUtils.dockerRunJava(
+                                      commonDockerOpts()
+                                      .addClassOptions("jdk.SystemProcess"))
+            .shouldHaveExitValue(0)
+            .shouldContain("pid = 1");
+    }
+
+
+    private static DockerRunOptions commonDockerOpts() {
+        return new DockerRunOptions(imageName, "/jdk/bin/java", "JfrReporter")
+            .addDockerOpts("--volume", Utils.TEST_CLASSES + ":/test-classes/")
+            .addJavaOpts("-cp", "/test-classes/");
+    }
+
+
+    private static void testEnvironmentVariables() throws Exception {
+        Common.logNewTestCase("EnvironmentVariables");
+
+        List<String> cmd = DockerTestUtils.buildJavaCommand(
+                                      commonDockerOpts()
+                                      .addClassOptions("jdk.InitialEnvironmentVariable"));
+
+        ProcessBuilder pb = new ProcessBuilder(cmd);
+        // Container has JAVA_HOME defined via the Dockerfile; make sure
+        // it is reported by JFR event.
+        // Environment variable set in host system should not be visible inside a container,
+        // and should not be reported by JFR.
+        pb.environment().put(TEST_ENV_VARIABLE, TEST_ENV_VALUE);
+
+        System.out.println("[COMMAND]\n" + Utils.getCommandLine(pb));
+        OutputAnalyzer out = new OutputAnalyzer(pb.start());
+        System.out.println("[STDERR]\n" + out.getStderr());
+        System.out.println("[STDOUT]\n" + out.getStdout());
+
+        out.shouldHaveExitValue(0)
+            .shouldContain("key = JAVA_HOME")
+            .shouldContain("value = /jdk")
+            .shouldNotContain(TEST_ENV_VARIABLE)
+            .shouldNotContain(TEST_ENV_VALUE);
+    }
+}
--- /dev/null	2019-09-02 18:10:46.000000000 +0300
+++ new/test/runtime/containers/docker/TestJFRNetworkEvents.java	2019-09-02 18:10:45.576583500 +0300
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/*
+ * @test
+ * @summary Test JFR network related events inside a container; make sure
+ *          the reported host ip and host name are correctly reported within
+ *          the container.
+ * @library /testlibrary
+ * @build JfrNetwork
+ * @run driver TestJFRNetworkEvents
+ */
+import com.oracle.java.testlibrary.Common;
+import com.oracle.java.testlibrary.DockerRunOptions;
+import com.oracle.java.testlibrary.DockerTestUtils;
+import com.oracle.java.testlibrary.Utils;
+
+
+public class TestJFRNetworkEvents {
+    private static final String imageName = Common.imageName("jfr-network");
+    private static final int availableCPUs = Runtime.getRuntime().availableProcessors();
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("Test Environment: detected availableCPUs = " + availableCPUs);
+        if (!DockerTestUtils.canTestDocker()) {
+            return;
+        }
+
+        DockerTestUtils.buildJdkDockerImage(imageName, "Dockerfile-BasicTest", "jdk-docker");
+
+        try {
+            runTest("jdk.SocketWrite");
+        } finally {
+            DockerTestUtils.removeDockerImage(imageName);
+        }
+    }
+
+    private static void runTest(String event) throws Exception {
+        DockerRunOptions opts = new DockerRunOptions(imageName, "/jdk/bin/java", "JfrNetwork")
+        .addDockerOpts("--volume", Utils.TEST_CLASSES + ":/test-classes/")
+        .addJavaOpts("-cp", "/test-classes/")
+        .addDockerOpts("--hostname", JfrNetwork.HOST_NAME)
+        .addClassOptions(event);
+    DockerTestUtils.dockerRunJava(opts)
+        .shouldHaveExitValue(0)
+        .shouldContain(JfrNetwork.JFR_REPORTED_CONTAINER_HOSTNAME_TAG + JfrNetwork.HOST_NAME);
+    }
+}