1 /*
   2  * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  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 #include "precompiled.hpp"
  26 #include "memory/universe.hpp"
  27 #include "oops/oop.inline.hpp"
  28 #include "runtime/arguments.hpp"
  29 #ifdef TARGET_ARCH_x86
  30 # include "vm_version_x86.hpp"
  31 #endif
  32 #ifdef TARGET_ARCH_sparc
  33 # include "vm_version_sparc.hpp"
  34 #endif
  35 #ifdef TARGET_ARCH_zero
  36 # include "vm_version_zero.hpp"
  37 #endif
  38 #ifdef TARGET_ARCH_arm
  39 # include "vm_version_arm.hpp"
  40 #endif
  41 #ifdef TARGET_ARCH_ppc
  42 # include "vm_version_ppc.hpp"
  43 #endif
  44 
  45 const char* Abstract_VM_Version::_s_vm_release = Abstract_VM_Version::vm_release();
  46 const char* Abstract_VM_Version::_s_internal_vm_info_string = Abstract_VM_Version::internal_vm_info_string();
  47 bool Abstract_VM_Version::_supports_cx8 = false;
  48 bool Abstract_VM_Version::_supports_atomic_getset4 = false;
  49 bool Abstract_VM_Version::_supports_atomic_getset8 = false;
  50 bool Abstract_VM_Version::_supports_atomic_getadd4 = false;
  51 bool Abstract_VM_Version::_supports_atomic_getadd8 = false;
  52 unsigned int Abstract_VM_Version::_logical_processors_per_package = 1U;
  53 int Abstract_VM_Version::_reserve_for_allocation_prefetch = 0;
  54 
  55 #ifndef HOTSPOT_RELEASE_VERSION
  56   #error HOTSPOT_RELEASE_VERSION must be defined
  57 #endif
  58 #ifndef JRE_RELEASE_VERSION
  59   #error JRE_RELEASE_VERSION must be defined
  60 #endif
  61 #ifndef HOTSPOT_BUILD_TARGET
  62   #error HOTSPOT_BUILD_TARGET must be defined
  63 #endif
  64 
  65 #ifdef PRODUCT
  66   #define VM_RELEASE HOTSPOT_RELEASE_VERSION
  67 #else
  68   #define VM_RELEASE HOTSPOT_RELEASE_VERSION "-" HOTSPOT_BUILD_TARGET
  69 #endif
  70 
  71 // HOTSPOT_RELEASE_VERSION must follow the release version naming convention
  72 // <major_ver>.<minor_ver>-b<nn>[-<identifier>][-<debug_target>]
  73 int Abstract_VM_Version::_vm_major_version = 0;
  74 int Abstract_VM_Version::_vm_minor_version = 0;
  75 int Abstract_VM_Version::_vm_build_number = 0;
  76 bool Abstract_VM_Version::_initialized = false;
  77 int Abstract_VM_Version::_parallel_worker_threads = 0;
  78 bool Abstract_VM_Version::_parallel_worker_threads_initialized = false;
  79 
  80 void Abstract_VM_Version::initialize() {
  81   if (_initialized) {
  82     return;
  83   }
  84   char* vm_version = os::strdup(HOTSPOT_RELEASE_VERSION);
  85 
  86   // Expecting the next vm_version format:
  87   // <major_ver>.<minor_ver>-b<nn>[-<identifier>]
  88   char* vm_major_ver = vm_version;
  89   assert(isdigit(vm_major_ver[0]),"wrong vm major version number");
  90   char* vm_minor_ver = strchr(vm_major_ver, '.');
  91   assert(vm_minor_ver != NULL && isdigit(vm_minor_ver[1]),"wrong vm minor version number");
  92   vm_minor_ver[0] = '\0'; // terminate vm_major_ver
  93   vm_minor_ver += 1;
  94   char* vm_build_num = strchr(vm_minor_ver, '-');
  95   assert(vm_build_num != NULL && vm_build_num[1] == 'b' && isdigit(vm_build_num[2]),"wrong vm build number");
  96   vm_build_num[0] = '\0'; // terminate vm_minor_ver
  97   vm_build_num += 2;
  98 
  99   _vm_major_version = atoi(vm_major_ver);
 100   _vm_minor_version = atoi(vm_minor_ver);
 101   _vm_build_number  = atoi(vm_build_num);
 102 
 103   os::free(vm_version);
 104   _initialized = true;
 105 }
 106 
 107 #if defined(_LP64)
 108   #define VMLP "64-Bit "
 109 #else
 110   #define VMLP ""
 111 #endif
 112 
 113 #ifndef VMTYPE
 114   #ifdef TIERED
 115     #define VMTYPE "Server"
 116   #else // TIERED
 117   #ifdef ZERO
 118   #ifdef SHARK
 119     #define VMTYPE "Shark"
 120   #else // SHARK
 121     #define VMTYPE "Zero"
 122   #endif // SHARK
 123   #else // ZERO
 124      #define VMTYPE COMPILER1_PRESENT("Client")   \
 125                     COMPILER2_PRESENT("Server")
 126   #endif // ZERO
 127   #endif // TIERED
 128 #endif
 129 
 130 #ifndef HOTSPOT_VM_DISTRO
 131   #error HOTSPOT_VM_DISTRO must be defined
 132 #endif
 133 #define VMNAME HOTSPOT_VM_DISTRO " " VMLP EMBEDDED_ONLY("Embedded ") VMTYPE " VM"
 134 
 135 const char* Abstract_VM_Version::vm_name() {
 136   return VMNAME;
 137 }
 138 
 139 
 140 const char* Abstract_VM_Version::vm_vendor() {
 141 #ifdef VENDOR
 142   return XSTR(VENDOR);
 143 #else
 144   return JDK_Version::is_gte_jdk17x_version() ?
 145     "Oracle Corporation" : "Sun Microsystems Inc.";
 146 #endif
 147 }
 148 
 149 
 150 const char* Abstract_VM_Version::vm_info_string() {
 151   switch (Arguments::mode()) {
 152     case Arguments::_int:
 153       return UseSharedSpaces ? "interpreted mode, sharing" : "interpreted mode";
 154     case Arguments::_mixed:
 155       return UseSharedSpaces ? "mixed mode, sharing"       :  "mixed mode";
 156     case Arguments::_comp:
 157       return UseSharedSpaces ? "compiled mode, sharing"    : "compiled mode";
 158   };
 159   ShouldNotReachHere();
 160   return "";
 161 }
 162 
 163 // NOTE: do *not* use stringStream. this function is called by
 164 //       fatal error handler. if the crash is in native thread,
 165 //       stringStream cannot get resource allocated and will SEGV.
 166 const char* Abstract_VM_Version::vm_release() {
 167   return VM_RELEASE;
 168 }
 169 
 170 // NOTE: do *not* use stringStream. this function is called by
 171 //       fatal error handlers. if the crash is in native thread,
 172 //       stringStream cannot get resource allocated and will SEGV.
 173 const char* Abstract_VM_Version::jre_release_version() {
 174   return JRE_RELEASE_VERSION;
 175 }
 176 
 177 #define OS       LINUX_ONLY("linux")             \
 178                  WINDOWS_ONLY("windows")         \
 179                  SOLARIS_ONLY("solaris")         \
 180                  BSD_ONLY("bsd")
 181 
 182 #ifdef ZERO
 183 #define CPU      ZERO_LIBARCH
 184 #else
 185 #define CPU      IA32_ONLY("x86")                \
 186                  IA64_ONLY("ia64")               \
 187                  AMD64_ONLY("amd64")             \
 188                  ARM_ONLY("arm")                 \
 189                  PPC_ONLY("ppc")                 \
 190                  SPARC_ONLY("sparc")
 191 #endif // ZERO
 192 
 193 const char *Abstract_VM_Version::vm_platform_string() {
 194   return OS "-" CPU;
 195 }
 196 
 197 const char* Abstract_VM_Version::internal_vm_info_string() {
 198   #ifndef HOTSPOT_BUILD_USER
 199     #define HOTSPOT_BUILD_USER unknown
 200   #endif
 201 
 202   #ifndef HOTSPOT_BUILD_COMPILER
 203     #ifdef _MSC_VER
 204       #if   _MSC_VER == 1100
 205         #define HOTSPOT_BUILD_COMPILER "MS VC++ 5.0"
 206       #elif _MSC_VER == 1200
 207         #define HOTSPOT_BUILD_COMPILER "MS VC++ 6.0"
 208       #elif _MSC_VER == 1310
 209         #define HOTSPOT_BUILD_COMPILER "MS VC++ 7.1 (VS2003)"
 210       #elif _MSC_VER == 1400
 211         #define HOTSPOT_BUILD_COMPILER "MS VC++ 8.0 (VS2005)"
 212       #elif _MSC_VER == 1500
 213         #define HOTSPOT_BUILD_COMPILER "MS VC++ 9.0 (VS2008)"
 214       #else
 215         #define HOTSPOT_BUILD_COMPILER "unknown MS VC++:" XSTR(_MSC_VER)
 216       #endif
 217     #elif defined(__SUNPRO_CC)
 218       #if   __SUNPRO_CC == 0x420
 219         #define HOTSPOT_BUILD_COMPILER "Workshop 4.2"
 220       #elif __SUNPRO_CC == 0x500
 221         #define HOTSPOT_BUILD_COMPILER "Workshop 5.0 compat=" XSTR(__SUNPRO_CC_COMPAT)
 222       #elif __SUNPRO_CC == 0x520
 223         #define HOTSPOT_BUILD_COMPILER "Workshop 5.2 compat=" XSTR(__SUNPRO_CC_COMPAT)
 224       #elif __SUNPRO_CC == 0x580
 225         #define HOTSPOT_BUILD_COMPILER "Workshop 5.8"
 226       #elif __SUNPRO_CC == 0x590
 227         #define HOTSPOT_BUILD_COMPILER "Workshop 5.9"
 228       #elif __SUNPRO_CC == 0x5100
 229         #define HOTSPOT_BUILD_COMPILER "Sun Studio 12u1"
 230       #else
 231         #define HOTSPOT_BUILD_COMPILER "unknown Workshop:" XSTR(__SUNPRO_CC)
 232       #endif
 233     #elif defined(__GNUC__)
 234         #define HOTSPOT_BUILD_COMPILER "gcc " __VERSION__
 235     #else
 236       #define HOTSPOT_BUILD_COMPILER "unknown compiler"
 237     #endif
 238   #endif
 239 
 240   #ifndef FLOAT_ARCH
 241     #if defined(__SOFTFP__)
 242       #define FLOAT_ARCH_STR "-sflt"
 243     #elif defined(E500V2)
 244       #define FLOAT_ARCH_STR "-e500v2"
 245     #elif defined(ARM)
 246       #define FLOAT_ARCH_STR "-vfp"
 247     #elif defined(PPC)
 248       #define FLOAT_ARCH_STR "-hflt"
 249     #else
 250       #define FLOAT_ARCH_STR ""
 251     #endif
 252   #else
 253     #define FLOAT_ARCH_STR XSTR(FLOAT_ARCH)
 254   #endif
 255 
 256   return VMNAME " (" VM_RELEASE ") for " OS "-" CPU FLOAT_ARCH_STR
 257          " JRE (" JRE_RELEASE_VERSION "), built on " __DATE__ " " __TIME__
 258          " by " XSTR(HOTSPOT_BUILD_USER) " with " HOTSPOT_BUILD_COMPILER;
 259 }
 260 
 261 const char *Abstract_VM_Version::vm_build_user() {
 262   return HOTSPOT_BUILD_USER;
 263 }
 264 
 265 unsigned int Abstract_VM_Version::jvm_version() {
 266   return ((Abstract_VM_Version::vm_major_version() & 0xFF) << 24) |
 267          ((Abstract_VM_Version::vm_minor_version() & 0xFF) << 16) |
 268          (Abstract_VM_Version::vm_build_number() & 0xFF);
 269 }
 270 
 271 
 272 void VM_Version_init() {
 273   VM_Version::initialize();
 274 
 275 #ifndef PRODUCT
 276   if (PrintMiscellaneous && Verbose) {
 277     os::print_cpu_info(tty);
 278   }
 279 #endif
 280 }
 281 
 282 unsigned int Abstract_VM_Version::nof_parallel_worker_threads(
 283                                                       unsigned int num,
 284                                                       unsigned int den,
 285                                                       unsigned int switch_pt) {
 286   if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
 287     assert(ParallelGCThreads == 0, "Default ParallelGCThreads is not 0");
 288     // For very large machines, there are diminishing returns
 289     // for large numbers of worker threads.  Instead of
 290     // hogging the whole system, use a fraction of the workers for every
 291     // processor after the first 8.  For example, on a 72 cpu machine
 292     // and a chosen fraction of 5/8
 293     // use 8 + (72 - 8) * (5/8) == 48 worker threads.
 294     unsigned int ncpus = (unsigned int) os::active_processor_count();
 295     return (ncpus <= switch_pt) ?
 296            ncpus :
 297           (switch_pt + ((ncpus - switch_pt) * num) / den);
 298   } else {
 299     return ParallelGCThreads;
 300   }
 301 }
 302 
 303 unsigned int Abstract_VM_Version::calc_parallel_worker_threads() {
 304   return nof_parallel_worker_threads(5, 8, 8);
 305 }
 306 
 307 
 308 // Does not set the _initialized flag since it is
 309 // a global flag.
 310 unsigned int Abstract_VM_Version::parallel_worker_threads() {
 311   if (!_parallel_worker_threads_initialized) {
 312     if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
 313       _parallel_worker_threads = VM_Version::calc_parallel_worker_threads();
 314     } else {
 315       _parallel_worker_threads = ParallelGCThreads;
 316     }
 317     _parallel_worker_threads_initialized = true;
 318   }
 319   return _parallel_worker_threads;
 320 }