12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_RUNTIME_VM_VERSION_HPP 26 #define SHARE_RUNTIME_VM_VERSION_HPP 27 28 #include "memory/allocation.hpp" 29 #include "utilities/ostream.hpp" 30 #include "utilities/macros.hpp" 31 32 typedef enum { 33 NoDetectedVirtualization, 34 XenHVM, 35 KVM, 36 VMWare, 37 HyperV 38 } VirtualizationType; 39 40 // VM_Version provides information about the VM. 41 42 class Abstract_VM_Version: AllStatic { 43 friend class VMStructs; 44 friend class JVMCIVMStructs; 45 46 protected: 47 static const char* _s_vm_release; 48 static const char* _s_internal_vm_info_string; 49 50 // CPU feature flags. 51 static uint64_t _features; 52 static const char* _features_string; 53 54 // These are set by machine-dependent initializations 55 static bool _supports_cx8; 56 static bool _supports_atomic_getset4; 57 static bool _supports_atomic_getset8; 58 static bool _supports_atomic_getadd4; 59 static bool _supports_atomic_getadd8; 60 static unsigned int _logical_processors_per_package; 61 static unsigned int _L1_data_cache_line_size; 62 static int _vm_major_version; 63 static int _vm_minor_version; 64 static int _vm_security_version; 65 static int _vm_patch_version; 66 static int _vm_build_number; 67 68 static VirtualizationType _detected_virtualization; 69 70 public: 71 // Called as part of the runtime services initialization which is 72 // called from the management module initialization (via init_globals()) 73 // after argument parsing and attaching of the main thread has 74 // occurred. Examines a variety of the hardware capabilities of 75 // the platform to determine which features can be used to execute the 76 // program. 77 static void initialize() { } 78 79 // This allows for early initialization of VM_Version information 80 // that may be needed later in the initialization sequence but before 81 // full VM_Version initialization is possible. It can not depend on any 82 // other part of the VM being initialized when called. Platforms that 83 // need to specialize this define VM_Version::early_initialize(). 84 static void early_initialize() { } 85 86 // Called to initialize VM variables needing initialization 87 // after command line parsing. Platforms that need to specialize 88 // this should define VM_Version::init_before_ergo(). 89 static void init_before_ergo() {} 104 static int vm_patch_version() { return _vm_patch_version; } 105 static int vm_build_number() { return _vm_build_number; } 106 107 // Gets the jvm_version_info.jvm_version defined in jvm.h 108 static unsigned int jvm_version(); 109 110 // Internal version providing additional build information 111 static const char* internal_vm_info_string(); 112 static const char* jre_release_version(); 113 static const char* jdk_debug_level(); 114 static const char* printable_jdk_debug_level(); 115 116 static uint64_t features() { 117 return _features; 118 } 119 120 static const char* features_string() { 121 return _features_string; 122 } 123 124 static VirtualizationType get_detected_virtualization() { 125 return _detected_virtualization; 126 } 127 128 // platforms that need to specialize this 129 // define VM_Version::print_platform_virtualization_info() 130 static void print_platform_virtualization_info(outputStream*) { } 131 132 // does HW support an 8-byte compare-exchange operation? 133 static bool supports_cx8() { 134 #ifdef SUPPORTS_NATIVE_CX8 135 return true; 136 #else 137 return _supports_cx8; 138 #endif 139 } 140 // does HW support atomic get-and-set or atomic get-and-add? Used 141 // to guide intrinsification decisions for Unsafe atomic ops 142 static bool supports_atomic_getset4() {return _supports_atomic_getset4;} 143 static bool supports_atomic_getset8() {return _supports_atomic_getset8;} 144 static bool supports_atomic_getadd4() {return _supports_atomic_getadd4;} 145 static bool supports_atomic_getadd8() {return _supports_atomic_getadd8;} 146 147 static unsigned int logical_processors_per_package() { 148 return _logical_processors_per_package; 149 } 150 151 static unsigned int L1_data_cache_line_size() { 152 return _L1_data_cache_line_size; 153 } 154 155 // ARCH specific policy for the BiasedLocking 156 static bool use_biased_locking() { return true; } 157 158 // Number of page sizes efficiently supported by the hardware. Most chips now 159 // support two sizes, thus this default implementation. Processor-specific 160 // subclasses should define new versions to hide this one as needed. Note 161 // that the O/S may support more sizes, but at most this many are used. 162 static uint page_size_count() { return 2; } 163 164 // Denominator for computing default ParallelGCThreads for machines with 165 // a large number of cores. 166 static uint parallel_worker_threads_denominator() { return 8; } 167 168 // Does this CPU support spin wait instruction? 169 static bool supports_on_spin_wait() { return false; } 170 171 static bool print_matching_lines_from_file(const char* filename, outputStream* st, const char* keywords_to_match[]); 172 }; 173 174 #include CPU_HEADER(vm_version) 175 176 #endif // SHARE_RUNTIME_VM_VERSION_HPP | 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_RUNTIME_VM_VERSION_HPP 26 #define SHARE_RUNTIME_VM_VERSION_HPP 27 28 #include "memory/allocation.hpp" 29 #include "utilities/ostream.hpp" 30 #include "utilities/macros.hpp" 31 32 // VM_Version provides information about the VM. 33 34 class Abstract_VM_Version: AllStatic { 35 friend class VMStructs; 36 friend class JVMCIVMStructs; 37 38 protected: 39 static const char* _s_vm_release; 40 static const char* _s_internal_vm_info_string; 41 42 // CPU feature flags. 43 static uint64_t _features; 44 static const char* _features_string; 45 46 // These are set by machine-dependent initializations 47 static bool _supports_cx8; 48 static bool _supports_atomic_getset4; 49 static bool _supports_atomic_getset8; 50 static bool _supports_atomic_getadd4; 51 static bool _supports_atomic_getadd8; 52 static unsigned int _logical_processors_per_package; 53 static unsigned int _L1_data_cache_line_size; 54 static int _vm_major_version; 55 static int _vm_minor_version; 56 static int _vm_security_version; 57 static int _vm_patch_version; 58 static int _vm_build_number; 59 60 public: 61 // Called as part of the runtime services initialization which is 62 // called from the management module initialization (via init_globals()) 63 // after argument parsing and attaching of the main thread has 64 // occurred. Examines a variety of the hardware capabilities of 65 // the platform to determine which features can be used to execute the 66 // program. 67 static void initialize() { } 68 69 // This allows for early initialization of VM_Version information 70 // that may be needed later in the initialization sequence but before 71 // full VM_Version initialization is possible. It can not depend on any 72 // other part of the VM being initialized when called. Platforms that 73 // need to specialize this define VM_Version::early_initialize(). 74 static void early_initialize() { } 75 76 // Called to initialize VM variables needing initialization 77 // after command line parsing. Platforms that need to specialize 78 // this should define VM_Version::init_before_ergo(). 79 static void init_before_ergo() {} 94 static int vm_patch_version() { return _vm_patch_version; } 95 static int vm_build_number() { return _vm_build_number; } 96 97 // Gets the jvm_version_info.jvm_version defined in jvm.h 98 static unsigned int jvm_version(); 99 100 // Internal version providing additional build information 101 static const char* internal_vm_info_string(); 102 static const char* jre_release_version(); 103 static const char* jdk_debug_level(); 104 static const char* printable_jdk_debug_level(); 105 106 static uint64_t features() { 107 return _features; 108 } 109 110 static const char* features_string() { 111 return _features_string; 112 } 113 114 // does HW support an 8-byte compare-exchange operation? 115 static bool supports_cx8() { 116 #ifdef SUPPORTS_NATIVE_CX8 117 return true; 118 #else 119 return _supports_cx8; 120 #endif 121 } 122 // does HW support atomic get-and-set or atomic get-and-add? Used 123 // to guide intrinsification decisions for Unsafe atomic ops 124 static bool supports_atomic_getset4() {return _supports_atomic_getset4;} 125 static bool supports_atomic_getset8() {return _supports_atomic_getset8;} 126 static bool supports_atomic_getadd4() {return _supports_atomic_getadd4;} 127 static bool supports_atomic_getadd8() {return _supports_atomic_getadd8;} 128 129 static unsigned int logical_processors_per_package() { 130 return _logical_processors_per_package; 131 } 132 133 static unsigned int L1_data_cache_line_size() { 134 return _L1_data_cache_line_size; 135 } 136 137 // ARCH specific policy for the BiasedLocking 138 static bool use_biased_locking() { return true; } 139 140 // Number of page sizes efficiently supported by the hardware. Most chips now 141 // support two sizes, thus this default implementation. Processor-specific 142 // subclasses should define new versions to hide this one as needed. Note 143 // that the O/S may support more sizes, but at most this many are used. 144 static uint page_size_count() { return 2; } 145 146 // Denominator for computing default ParallelGCThreads for machines with 147 // a large number of cores. 148 static uint parallel_worker_threads_denominator() { return 8; } 149 150 // Does this CPU support spin wait instruction? 151 static bool supports_on_spin_wait() { return false; } 152 }; 153 154 #include CPU_HEADER(vm_version) 155 156 #endif // SHARE_RUNTIME_VM_VERSION_HPP |