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