Mercurial > hg > graal-compiler
view src/share/vm/runtime/vm_version.cpp @ 2149:7e37af9d69ef
7011379: G1: overly long concurrent marking cycles
Summary: This changeset introduces filtering of SATB buffers at the point when they are about to be enqueued. If this filtering clears enough entries on each buffer, the buffer can then be re-used and not enqueued. This cuts down the number of SATB buffers that need to be processed by the concurrent marking threads.
Reviewed-by: johnc, ysr
author | tonyp |
---|---|
date | Wed, 19 Jan 2011 09:35:17 -0500 |
parents | f95d63e2154a |
children | b92c45f2bc75 |
line wrap: on
line source
/* * Copyright (c) 1998, 2010, 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 "memory/universe.hpp" #include "oops/oop.inline.hpp" #include "runtime/arguments.hpp" #ifdef TARGET_ARCH_x86 # include "vm_version_x86.hpp" #endif #ifdef TARGET_ARCH_sparc # include "vm_version_sparc.hpp" #endif #ifdef TARGET_ARCH_zero # include "vm_version_zero.hpp" #endif const char* Abstract_VM_Version::_s_vm_release = Abstract_VM_Version::vm_release(); const char* Abstract_VM_Version::_s_internal_vm_info_string = Abstract_VM_Version::internal_vm_info_string(); bool Abstract_VM_Version::_supports_cx8 = false; unsigned int Abstract_VM_Version::_logical_processors_per_package = 1U; #ifndef HOTSPOT_RELEASE_VERSION #error HOTSPOT_RELEASE_VERSION must be defined #endif #ifndef JRE_RELEASE_VERSION #error JRE_RELEASE_VERSION must be defined #endif #ifndef HOTSPOT_BUILD_TARGET #error HOTSPOT_BUILD_TARGET must be defined #endif #ifdef PRODUCT #define VM_RELEASE HOTSPOT_RELEASE_VERSION #else #define VM_RELEASE HOTSPOT_RELEASE_VERSION "-" HOTSPOT_BUILD_TARGET #endif // HOTSPOT_RELEASE_VERSION must follow the release version naming convention // <major_ver>.<minor_ver>-b<nn>[-<identifier>][-<debug_target>] int Abstract_VM_Version::_vm_major_version = 0; int Abstract_VM_Version::_vm_minor_version = 0; int Abstract_VM_Version::_vm_build_number = 0; bool Abstract_VM_Version::_initialized = false; int Abstract_VM_Version::_parallel_worker_threads = 0; bool Abstract_VM_Version::_parallel_worker_threads_initialized = false; void Abstract_VM_Version::initialize() { if (_initialized) { return; } char* vm_version = os::strdup(HOTSPOT_RELEASE_VERSION); // Expecting the next vm_version format: // <major_ver>.<minor_ver>-b<nn>[-<identifier>] char* vm_major_ver = vm_version; assert(isdigit(vm_major_ver[0]),"wrong vm major version number"); char* vm_minor_ver = strchr(vm_major_ver, '.'); assert(vm_minor_ver != NULL && isdigit(vm_minor_ver[1]),"wrong vm minor version number"); vm_minor_ver[0] = '\0'; // terminate vm_major_ver vm_minor_ver += 1; char* vm_build_num = strchr(vm_minor_ver, '-'); assert(vm_build_num != NULL && vm_build_num[1] == 'b' && isdigit(vm_build_num[2]),"wrong vm build number"); vm_build_num[0] = '\0'; // terminate vm_minor_ver vm_build_num += 2; _vm_major_version = atoi(vm_major_ver); _vm_minor_version = atoi(vm_minor_ver); _vm_build_number = atoi(vm_build_num); os::free(vm_version); _initialized = true; } #if defined(_LP64) #define VMLP "64-Bit " #else #define VMLP "" #endif #ifdef KERNEL #define VMTYPE "Kernel" #else // KERNEL #ifdef TIERED #define VMTYPE "Server" #else // TIERED #ifdef ZERO #ifdef SHARK #define VMTYPE "Shark" #else // SHARK #define VMTYPE "Zero" #endif // SHARK #else // ZERO #define VMTYPE COMPILER1_PRESENT("Client") \ COMPILER2_PRESENT("Server") #endif // ZERO #endif // TIERED #endif // KERNEL #ifndef HOTSPOT_VM_DISTRO #error HOTSPOT_VM_DISTRO must be defined #endif #define VMNAME HOTSPOT_VM_DISTRO " " VMLP VMTYPE " VM" const char* Abstract_VM_Version::vm_name() { return VMNAME; } const char* Abstract_VM_Version::vm_vendor() { #ifdef VENDOR return XSTR(VENDOR); #else return JDK_Version::is_gte_jdk17x_version() ? "Oracle Corporation" : "Sun Microsystems Inc."; #endif } const char* Abstract_VM_Version::vm_info_string() { switch (Arguments::mode()) { case Arguments::_int: return UseSharedSpaces ? "interpreted mode, sharing" : "interpreted mode"; case Arguments::_mixed: return UseSharedSpaces ? "mixed mode, sharing" : "mixed mode"; case Arguments::_comp: return UseSharedSpaces ? "compiled mode, sharing" : "compiled mode"; }; ShouldNotReachHere(); return ""; } // NOTE: do *not* use stringStream. this function is called by // fatal error handler. if the crash is in native thread, // stringStream cannot get resource allocated and will SEGV. const char* Abstract_VM_Version::vm_release() { return VM_RELEASE; } #define OS LINUX_ONLY("linux") \ WINDOWS_ONLY("windows") \ SOLARIS_ONLY("solaris") #ifdef ZERO #define CPU ZERO_LIBARCH #else #define CPU IA32_ONLY("x86") \ IA64_ONLY("ia64") \ AMD64_ONLY("amd64") \ ARM_ONLY("arm") \ PPC_ONLY("ppc") \ SPARC_ONLY("sparc") #endif // ZERO const char *Abstract_VM_Version::vm_platform_string() { return OS "-" CPU; } const char* Abstract_VM_Version::internal_vm_info_string() { #ifndef HOTSPOT_BUILD_USER #define HOTSPOT_BUILD_USER unknown #endif #ifndef HOTSPOT_BUILD_COMPILER #ifdef _MSC_VER #if _MSC_VER == 1100 #define HOTSPOT_BUILD_COMPILER "MS VC++ 5.0" #elif _MSC_VER == 1200 #define HOTSPOT_BUILD_COMPILER "MS VC++ 6.0" #elif _MSC_VER == 1310 #define HOTSPOT_BUILD_COMPILER "MS VC++ 7.1 (VS2003)" #elif _MSC_VER == 1400 #define HOTSPOT_BUILD_COMPILER "MS VC++ 8.0 (VS2005)" #elif _MSC_VER == 1500 #define HOTSPOT_BUILD_COMPILER "MS VC++ 9.0 (VS2008)" #else #define HOTSPOT_BUILD_COMPILER "unknown MS VC++:" XSTR(_MSC_VER) #endif #elif defined(__SUNPRO_CC) #if __SUNPRO_CC == 0x420 #define HOTSPOT_BUILD_COMPILER "Workshop 4.2" #elif __SUNPRO_CC == 0x500 #define HOTSPOT_BUILD_COMPILER "Workshop 5.0 compat=" XSTR(__SUNPRO_CC_COMPAT) #elif __SUNPRO_CC == 0x520 #define HOTSPOT_BUILD_COMPILER "Workshop 5.2 compat=" XSTR(__SUNPRO_CC_COMPAT) #elif __SUNPRO_CC == 0x580 #define HOTSPOT_BUILD_COMPILER "Workshop 5.8" #elif __SUNPRO_CC == 0x590 #define HOTSPOT_BUILD_COMPILER "Workshop 5.9" #elif __SUNPRO_CC == 0x5100 #define HOTSPOT_BUILD_COMPILER "Sun Studio 12u1" #else #define HOTSPOT_BUILD_COMPILER "unknown Workshop:" XSTR(__SUNPRO_CC) #endif #elif defined(__GNUC__) #define HOTSPOT_BUILD_COMPILER "gcc " __VERSION__ #else #define HOTSPOT_BUILD_COMPILER "unknown compiler" #endif #endif return VMNAME " (" VM_RELEASE ") for " OS "-" CPU " JRE (" JRE_RELEASE_VERSION "), built on " __DATE__ " " __TIME__ " by " XSTR(HOTSPOT_BUILD_USER) " with " HOTSPOT_BUILD_COMPILER; } unsigned int Abstract_VM_Version::jvm_version() { return ((Abstract_VM_Version::vm_major_version() & 0xFF) << 24) | ((Abstract_VM_Version::vm_minor_version() & 0xFF) << 16) | (Abstract_VM_Version::vm_build_number() & 0xFF); } void VM_Version_init() { VM_Version::initialize(); #ifndef PRODUCT if (PrintMiscellaneous && Verbose) { os::print_cpu_info(tty); } #endif } unsigned int Abstract_VM_Version::nof_parallel_worker_threads( unsigned int num, unsigned int den, unsigned int switch_pt) { if (FLAG_IS_DEFAULT(ParallelGCThreads)) { assert(ParallelGCThreads == 0, "Default ParallelGCThreads is not 0"); // For very large machines, there are diminishing returns // for large numbers of worker threads. Instead of // hogging the whole system, use a fraction of the workers for every // processor after the first 8. For example, on a 72 cpu machine // and a chosen fraction of 5/8 // use 8 + (72 - 8) * (5/8) == 48 worker threads. unsigned int ncpus = (unsigned int) os::active_processor_count(); return (ncpus <= switch_pt) ? ncpus : (switch_pt + ((ncpus - switch_pt) * num) / den); } else { return ParallelGCThreads; } } unsigned int Abstract_VM_Version::calc_parallel_worker_threads() { return nof_parallel_worker_threads(5, 8, 8); } // Does not set the _initialized flag since it is // a global flag. unsigned int Abstract_VM_Version::parallel_worker_threads() { if (!_parallel_worker_threads_initialized) { if (FLAG_IS_DEFAULT(ParallelGCThreads)) { _parallel_worker_threads = VM_Version::calc_parallel_worker_threads(); } else { _parallel_worker_threads = ParallelGCThreads; } _parallel_worker_threads_initialized = true; } return _parallel_worker_threads; }