truffle: src/os/linux/vm/os_linux.hpp annotate

annotate src/os/linux/vm/os_linux.hpp @ 20338:8d5f66b42c53

8055525: Bigapp weblogic+medrec fails to startup after JDK-8038423 Summary: If large pages are enabled and configured in Linux, the VM always pre-commits the entire space. The VM fails verification of the commit of the initial heap because some internal data structure marked all memory pages of the heap as committed during initialization. This makes the code think that we attempted a double-commit during first allocation of the heap. Remove the initial marking of memory pages of the heap to committed. Reviewed-by: mgerdin

author	tschatzl
date	Wed, 20 Aug 2014 14:34:40 +0200
parents	b0133e4187d3
children	bb9356ec5967 833b0f92429a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8675 63e54c37ac64 8008959: Fix non-PCH build on Linux, Windows and MacOS X simonis parents: 6630 diff changeset	2 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 844 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 844 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 844 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #ifndef OS_LINUX_VM_OS_LINUX_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define OS_LINUX_VM_OS_LINUX_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
0 a61af66fc99e Initial load duke parents: diff changeset	28 // Linux_OS defines the interface to Linux operating systems
a61af66fc99e Initial load duke parents: diff changeset	29
a61af66fc99e Initial load duke parents: diff changeset	30 /* pthread_getattr_np comes with LinuxThreads-0.9-7 on RedHat 7.1 */
a61af66fc99e Initial load duke parents: diff changeset	31 typedef int (pthread_getattr_func_type) (pthread_t, pthread_attr_t );
a61af66fc99e Initial load duke parents: diff changeset	32
14436 b0133e4187d3 8028471: PPC64 (part 215): opto: Extend ImplicitNullCheck optimization. goetz parents: 12211 diff changeset	33 // Information about the protection of the page at address '0' on this os.
b0133e4187d3 8028471: PPC64 (part 215): opto: Extend ImplicitNullCheck optimization. goetz parents: 12211 diff changeset	34 static bool zero_page_read_protected() { return true; }
b0133e4187d3 8028471: PPC64 (part 215): opto: Extend ImplicitNullCheck optimization. goetz parents: 12211 diff changeset	35
0 a61af66fc99e Initial load duke parents: diff changeset	36 class Linux {
a61af66fc99e Initial load duke parents: diff changeset	37 friend class os;
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	38 friend class TestReserveMemorySpecial;
0 a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 // For signal-chaining
a61af66fc99e Initial load duke parents: diff changeset	41 #define MAXSIGNUM 32
a61af66fc99e Initial load duke parents: diff changeset	42 static struct sigaction sigact[MAXSIGNUM]; // saved preinstalled sigactions
a61af66fc99e Initial load duke parents: diff changeset	43 static unsigned int sigs; // mask of signals that have
a61af66fc99e Initial load duke parents: diff changeset	44 // preinstalled signal handlers
a61af66fc99e Initial load duke parents: diff changeset	45 static bool libjsig_is_loaded; // libjsig that interposes sigaction(),
a61af66fc99e Initial load duke parents: diff changeset	46 // __sigaction(), signal() is loaded
a61af66fc99e Initial load duke parents: diff changeset	47 static struct sigaction (get_signal_action)(int);
a61af66fc99e Initial load duke parents: diff changeset	48 static struct sigaction *get_preinstalled_handler(int);
a61af66fc99e Initial load duke parents: diff changeset	49 static void save_preinstalled_handler(int, struct sigaction&);
a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 static void check_signal_handler(int sig);
a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 // For signal flags diagnostics
a61af66fc99e Initial load duke parents: diff changeset	54 static int sigflags[MAXSIGNUM];
a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56 static int (_clock_gettime)(clockid_t, struct timespec );
a61af66fc99e Initial load duke parents: diff changeset	57 static int (_pthread_getcpuclockid)(pthread_t, clockid_t );
a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 static address _initial_thread_stack_bottom;
a61af66fc99e Initial load duke parents: diff changeset	60 static uintptr_t _initial_thread_stack_size;
a61af66fc99e Initial load duke parents: diff changeset	61
199 f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	62 static const char *_glibc_version;
f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	63 static const char *_libpthread_version;
0 a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65 static bool _is_floating_stack;
a61af66fc99e Initial load duke parents: diff changeset	66 static bool _is_NPTL;
a61af66fc99e Initial load duke parents: diff changeset	67 static bool _supports_fast_thread_cpu_time;
a61af66fc99e Initial load duke parents: diff changeset	68
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	69 static GrowableArray<int>* _cpu_to_node;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	70
0 a61af66fc99e Initial load duke parents: diff changeset	71 protected:
a61af66fc99e Initial load duke parents: diff changeset	72
a61af66fc99e Initial load duke parents: diff changeset	73 static julong _physical_memory;
a61af66fc99e Initial load duke parents: diff changeset	74 static pthread_t _main_thread;
a61af66fc99e Initial load duke parents: diff changeset	75 static Mutex* _createThread_lock;
a61af66fc99e Initial load duke parents: diff changeset	76 static int _page_size;
10164 b4081e9714ec 8013398: Adjust number of stack guard pages on systems with large memory page size vladidan parents: 8812 diff changeset	77 static const int _vm_default_page_size;
0 a61af66fc99e Initial load duke parents: diff changeset	78
a61af66fc99e Initial load duke parents: diff changeset	79 static julong available_memory();
a61af66fc99e Initial load duke parents: diff changeset	80 static julong physical_memory() { return _physical_memory; }
a61af66fc99e Initial load duke parents: diff changeset	81 static void initialize_system_info();
a61af66fc99e Initial load duke parents: diff changeset	82
10969 a837fa3d3f86 8013057: assert(_needs_gc \|\| SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint dcubed parents: 10405 diff changeset	83 static int commit_memory_impl(char* addr, size_t bytes, bool exec);
a837fa3d3f86 8013057: assert(_needs_gc \|\| SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint dcubed parents: 10405 diff changeset	84 static int commit_memory_impl(char* addr, size_t bytes,
a837fa3d3f86 8013057: assert(_needs_gc \|\| SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint dcubed parents: 10405 diff changeset	85 size_t alignment_hint, bool exec);
a837fa3d3f86 8013057: assert(_needs_gc \|\| SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint dcubed parents: 10405 diff changeset	86
199 f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	87 static void set_glibc_version(const char *s) { _glibc_version = s; }
f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	88 static void set_libpthread_version(const char *s) { _libpthread_version = s; }
0 a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90 static bool supports_variable_stack_size();
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92 static void set_is_NPTL() { _is_NPTL = true; }
a61af66fc99e Initial load duke parents: diff changeset	93 static void set_is_LinuxThreads() { _is_NPTL = false; }
a61af66fc99e Initial load duke parents: diff changeset	94 static void set_is_floating_stack() { _is_floating_stack = true; }
a61af66fc99e Initial load duke parents: diff changeset	95
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	96 static void rebuild_cpu_to_node_map();
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	97 static GrowableArray<int>* cpu_to_node() { return _cpu_to_node; }
3286 139667d9836a 7034464: Support transparent large pages on Linux iveresov parents: 1972 diff changeset	98
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	99 static size_t find_large_page_size();
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	100 static size_t setup_large_page_size();
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	101
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	102 static bool setup_large_page_type(size_t page_size);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	103 static bool transparent_huge_pages_sanity_check(bool warn, size_t pages_size);
3286 139667d9836a 7034464: Support transparent large pages on Linux iveresov parents: 1972 diff changeset	104 static bool hugetlbfs_sanity_check(bool warn, size_t page_size);
139667d9836a 7034464: Support transparent large pages on Linux iveresov parents: 1972 diff changeset	105
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	106 static char* reserve_memory_special_shm(size_t bytes, size_t alignment, char* req_addr, bool exec);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	107 static char* reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, char* req_addr, bool exec);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	108 static char* reserve_memory_special_huge_tlbfs_only(size_t bytes, char* req_addr, bool exec);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	109 static char* reserve_memory_special_huge_tlbfs_mixed(size_t bytes, size_t alignment, char* req_addr, bool exec);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	110
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	111 static bool release_memory_special_shm(char* base, size_t bytes);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	112 static bool release_memory_special_huge_tlbfs(char* base, size_t bytes);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	113
6080 7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	114 static void print_full_memory_info(outputStream* st);
7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	115 static void print_distro_info(outputStream* st);
7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	116 static void print_libversion_info(outputStream* st);
7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	117
0 a61af66fc99e Initial load duke parents: diff changeset	118 public:
8710 9058789475af 7107135: Stack guard pages are no more protected after loading a shared library with executable stack iklam parents: 8675 diff changeset	119 static bool _stack_is_executable;
8812 14509df4cd63 8010389: After fix for 7107135 a failed dlopen() call results in a VM crash iklam parents: 8710 diff changeset	120 static void dlopen_helper(const char name, char *ebuf, int ebuflen);
14509df4cd63 8010389: After fix for 7107135 a failed dlopen() call results in a VM crash iklam parents: 8710 diff changeset	121 static void dll_load_in_vmthread(const char name, char *ebuf, int ebuflen);
8710 9058789475af 7107135: Stack guard pages are no more protected after loading a shared library with executable stack iklam parents: 8675 diff changeset	122
0 a61af66fc99e Initial load duke parents: diff changeset	123 static void init_thread_fpu_state();
a61af66fc99e Initial load duke parents: diff changeset	124 static int get_fpu_control_word();
a61af66fc99e Initial load duke parents: diff changeset	125 static void set_fpu_control_word(int fpu_control);
a61af66fc99e Initial load duke parents: diff changeset	126 static pthread_t main_thread(void) { return _main_thread; }
a61af66fc99e Initial load duke parents: diff changeset	127 // returns kernel thread id (similar to LWP id on Solaris), which can be
a61af66fc99e Initial load duke parents: diff changeset	128 // used to access /proc
a61af66fc99e Initial load duke parents: diff changeset	129 static pid_t gettid();
a61af66fc99e Initial load duke parents: diff changeset	130 static void set_createThread_lock(Mutex* lk) { _createThread_lock = lk; }
a61af66fc99e Initial load duke parents: diff changeset	131 static Mutex* createThread_lock(void) { return _createThread_lock; }
a61af66fc99e Initial load duke parents: diff changeset	132 static void hotspot_sigmask(Thread* thread);
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 static address initial_thread_stack_bottom(void) { return _initial_thread_stack_bottom; }
a61af66fc99e Initial load duke parents: diff changeset	135 static uintptr_t initial_thread_stack_size(void) { return _initial_thread_stack_size; }
a61af66fc99e Initial load duke parents: diff changeset	136 static bool is_initial_thread(void);
a61af66fc99e Initial load duke parents: diff changeset	137
a61af66fc99e Initial load duke parents: diff changeset	138 static int page_size(void) { return _page_size; }
a61af66fc99e Initial load duke parents: diff changeset	139 static void set_page_size(int val) { _page_size = val; }
a61af66fc99e Initial load duke parents: diff changeset	140
10164 b4081e9714ec 8013398: Adjust number of stack guard pages on systems with large memory page size vladidan parents: 8812 diff changeset	141 static int vm_default_page_size(void) { return _vm_default_page_size; }
b4081e9714ec 8013398: Adjust number of stack guard pages on systems with large memory page size vladidan parents: 8812 diff changeset	142
0 a61af66fc99e Initial load duke parents: diff changeset	143 static address ucontext_get_pc(ucontext_t* uc);
a61af66fc99e Initial load duke parents: diff changeset	144 static intptr_t* ucontext_get_sp(ucontext_t* uc);
a61af66fc99e Initial load duke parents: diff changeset	145 static intptr_t* ucontext_get_fp(ucontext_t* uc);
a61af66fc99e Initial load duke parents: diff changeset	146
a61af66fc99e Initial load duke parents: diff changeset	147 // For Analyzer Forte AsyncGetCallTrace profiling support:
a61af66fc99e Initial load duke parents: diff changeset	148 //
a61af66fc99e Initial load duke parents: diff changeset	149 // This interface should be declared in os_linux_i486.hpp, but
a61af66fc99e Initial load duke parents: diff changeset	150 // that file provides extensions to the os class and not the
a61af66fc99e Initial load duke parents: diff changeset	151 // Linux class.
a61af66fc99e Initial load duke parents: diff changeset	152 static ExtendedPC fetch_frame_from_ucontext(Thread* thread, ucontext_t* uc,
a61af66fc99e Initial load duke parents: diff changeset	153 intptr_t ret_sp, intptr_t ret_fp);
a61af66fc99e Initial load duke parents: diff changeset	154
a61af66fc99e Initial load duke parents: diff changeset	155 // This boolean allows users to forward their own non-matching signals
a61af66fc99e Initial load duke parents: diff changeset	156 // to JVM_handle_linux_signal, harmlessly.
a61af66fc99e Initial load duke parents: diff changeset	157 static bool signal_handlers_are_installed;
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 static int get_our_sigflags(int);
a61af66fc99e Initial load duke parents: diff changeset	160 static void set_our_sigflags(int, int);
a61af66fc99e Initial load duke parents: diff changeset	161 static void signal_sets_init();
a61af66fc99e Initial load duke parents: diff changeset	162 static void install_signal_handlers();
a61af66fc99e Initial load duke parents: diff changeset	163 static void set_signal_handler(int, bool);
a61af66fc99e Initial load duke parents: diff changeset	164 static bool is_sig_ignored(int sig);
a61af66fc99e Initial load duke parents: diff changeset	165
a61af66fc99e Initial load duke parents: diff changeset	166 static sigset_t* unblocked_signals();
a61af66fc99e Initial load duke parents: diff changeset	167 static sigset_t* vm_signals();
a61af66fc99e Initial load duke parents: diff changeset	168 static sigset_t* allowdebug_blocked_signals();
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 // For signal-chaining
a61af66fc99e Initial load duke parents: diff changeset	171 static struct sigaction *get_chained_signal_action(int sig);
a61af66fc99e Initial load duke parents: diff changeset	172 static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 // GNU libc and libpthread version strings
199 f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	175 static const char *glibc_version() { return _glibc_version; }
f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	176 static const char *libpthread_version() { return _libpthread_version; }
0 a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 // NPTL or LinuxThreads?
a61af66fc99e Initial load duke parents: diff changeset	179 static bool is_LinuxThreads() { return !_is_NPTL; }
a61af66fc99e Initial load duke parents: diff changeset	180 static bool is_NPTL() { return _is_NPTL; }
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 // NPTL is always floating stack. LinuxThreads could be using floating
a61af66fc99e Initial load duke parents: diff changeset	183 // stack or fixed stack.
a61af66fc99e Initial load duke parents: diff changeset	184 static bool is_floating_stack() { return _is_floating_stack; }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 static void libpthread_init();
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	187 static bool libnuma_init();
763 cf71f149d7ae 6840196: NUMA allocator: crash in fastdebug during startup on Linux iveresov parents: 462 diff changeset	188 static void* libnuma_dlsym(void* handle, const char* name);
0 a61af66fc99e Initial load duke parents: diff changeset	189 // Minimum stack size a thread can be created with (allowing
a61af66fc99e Initial load duke parents: diff changeset	190 // the VM to completely create the thread and enter user code)
a61af66fc99e Initial load duke parents: diff changeset	191 static size_t min_stack_allowed;
a61af66fc99e Initial load duke parents: diff changeset	192
a61af66fc99e Initial load duke parents: diff changeset	193 // Return default stack size or guard size for the specified thread type
a61af66fc99e Initial load duke parents: diff changeset	194 static size_t default_stack_size(os::ThreadType thr_type);
a61af66fc99e Initial load duke parents: diff changeset	195 static size_t default_guard_size(os::ThreadType thr_type);
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 static void capture_initial_stack(size_t max_size);
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 // Stack overflow handling
a61af66fc99e Initial load duke parents: diff changeset	200 static bool manually_expand_stack(JavaThread * t, address addr);
a61af66fc99e Initial load duke parents: diff changeset	201 static int max_register_window_saves_before_flushing();
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 // Real-time clock functions
a61af66fc99e Initial load duke parents: diff changeset	204 static void clock_init(void);
a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 // fast POSIX clocks support
a61af66fc99e Initial load duke parents: diff changeset	207 static void fast_thread_clock_init(void);
a61af66fc99e Initial load duke parents: diff changeset	208
6630 fa9253dcd4df 7194409: os::javaTimeNanos() shows hot on CPU_CLK_UNHALTED profiles johnc parents: 6197 diff changeset	209 static inline bool supports_monotonic_clock() {
0 a61af66fc99e Initial load duke parents: diff changeset	210 return _clock_gettime != NULL;
a61af66fc99e Initial load duke parents: diff changeset	211 }
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 static int clock_gettime(clockid_t clock_id, struct timespec *tp) {
a61af66fc99e Initial load duke parents: diff changeset	214 return _clock_gettime ? _clock_gettime(clock_id, tp) : -1;
a61af66fc99e Initial load duke parents: diff changeset	215 }
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 static int pthread_getcpuclockid(pthread_t tid, clockid_t *clock_id) {
a61af66fc99e Initial load duke parents: diff changeset	218 return _pthread_getcpuclockid ? _pthread_getcpuclockid(tid, clock_id) : -1;
a61af66fc99e Initial load duke parents: diff changeset	219 }
a61af66fc99e Initial load duke parents: diff changeset	220
a61af66fc99e Initial load duke parents: diff changeset	221 static bool supports_fast_thread_cpu_time() {
a61af66fc99e Initial load duke parents: diff changeset	222 return _supports_fast_thread_cpu_time;
a61af66fc99e Initial load duke parents: diff changeset	223 }
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 static jlong fast_thread_cpu_time(clockid_t clockid);
a61af66fc99e Initial load duke parents: diff changeset	226
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	227 // pthread_cond clock suppport
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	228 private:
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	229 static pthread_condattr_t _condattr[1];
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	230
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	231 public:
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	232 static pthread_condattr_t* condAttr() { return _condattr; }
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	233
0 a61af66fc99e Initial load duke parents: diff changeset	234 // Stack repair handling
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 // none present
a61af66fc99e Initial load duke parents: diff changeset	237
a61af66fc99e Initial load duke parents: diff changeset	238 // LinuxThreads work-around for 6292965
a61af66fc99e Initial load duke parents: diff changeset	239 static int safe_cond_timedwait(pthread_cond_t _cond, pthread_mutex_t _mutex, const struct timespec *_abstime);
a61af66fc99e Initial load duke parents: diff changeset	240
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	241 private:
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	242 typedef int (*sched_getcpu_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	243 typedef int (numa_node_to_cpus_func_t)(int node, unsigned long buffer, int bufferlen);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	244 typedef int (*numa_max_node_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	245 typedef int (*numa_available_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	246 typedef int (numa_tonode_memory_func_t)(void start, size_t size, int node);
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	247 typedef void (numa_interleave_memory_func_t)(void start, size_t size, unsigned long *nodemask);
12176 88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	248 typedef void (*numa_set_bind_policy_func_t)(int policy);
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	249
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	250 static sched_getcpu_func_t _sched_getcpu;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	251 static numa_node_to_cpus_func_t _numa_node_to_cpus;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	252 static numa_max_node_func_t _numa_max_node;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	253 static numa_available_func_t _numa_available;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	254 static numa_tonode_memory_func_t _numa_tonode_memory;
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	255 static numa_interleave_memory_func_t _numa_interleave_memory;
12176 88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	256 static numa_set_bind_policy_func_t _numa_set_bind_policy;
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	257 static unsigned long* _numa_all_nodes;
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	258
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	259 static void set_sched_getcpu(sched_getcpu_func_t func) { _sched_getcpu = func; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	260 static void set_numa_node_to_cpus(numa_node_to_cpus_func_t func) { _numa_node_to_cpus = func; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	261 static void set_numa_max_node(numa_max_node_func_t func) { _numa_max_node = func; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	262 static void set_numa_available(numa_available_func_t func) { _numa_available = func; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	263 static void set_numa_tonode_memory(numa_tonode_memory_func_t func) { _numa_tonode_memory = func; }
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	264 static void set_numa_interleave_memory(numa_interleave_memory_func_t func) { _numa_interleave_memory = func; }
12176 88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	265 static void set_numa_set_bind_policy(numa_set_bind_policy_func_t func) { _numa_set_bind_policy = func; }
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	266 static void set_numa_all_nodes(unsigned long* ptr) { _numa_all_nodes = ptr; }
3826 7c2653aefc46 7060836: RHEL 5.5 and 5.6 should support UseNUMA iveresov parents: 3286 diff changeset	267 static int sched_getcpu_syscall(void);
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	268 public:
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	269 static int sched_getcpu() { return _sched_getcpu != NULL ? _sched_getcpu() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	270 static int numa_node_to_cpus(int node, unsigned long *buffer, int bufferlen) {
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	271 return _numa_node_to_cpus != NULL ? _numa_node_to_cpus(node, buffer, bufferlen) : -1;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	272 }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	273 static int numa_max_node() { return _numa_max_node != NULL ? _numa_max_node() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	274 static int numa_available() { return _numa_available != NULL ? _numa_available() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	275 static int numa_tonode_memory(void *start, size_t size, int node) {
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	276 return _numa_tonode_memory != NULL ? _numa_tonode_memory(start, size, node) : -1;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	277 }
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	278 static void numa_interleave_memory(void *start, size_t size) {
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	279 if (_numa_interleave_memory != NULL && _numa_all_nodes != NULL) {
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	280 _numa_interleave_memory(start, size, _numa_all_nodes);
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	281 }
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	282 }
12176 88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	283 static void numa_set_bind_policy(int policy) {
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	284 if (_numa_set_bind_policy != NULL) {
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	285 _numa_set_bind_policy(policy);
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	286 }
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	287 }
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	288 static int get_node_by_cpu(int cpu_id);
0 a61af66fc99e Initial load duke parents: diff changeset	289 };
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6080 diff changeset	292 class PlatformEvent : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	293 private:
a61af66fc99e Initial load duke parents: diff changeset	294 double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line
a61af66fc99e Initial load duke parents: diff changeset	295 volatile int _Event ;
a61af66fc99e Initial load duke parents: diff changeset	296 volatile int _nParked ;
a61af66fc99e Initial load duke parents: diff changeset	297 pthread_mutex_t _mutex [1] ;
a61af66fc99e Initial load duke parents: diff changeset	298 pthread_cond_t _cond [1] ;
a61af66fc99e Initial load duke parents: diff changeset	299 double PostPad [2] ;
a61af66fc99e Initial load duke parents: diff changeset	300 Thread * _Assoc ;
a61af66fc99e Initial load duke parents: diff changeset	301
a61af66fc99e Initial load duke parents: diff changeset	302 public: // TODO-FIXME: make dtor private
a61af66fc99e Initial load duke parents: diff changeset	303 ~PlatformEvent() { guarantee (0, "invariant") ; }
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 public:
a61af66fc99e Initial load duke parents: diff changeset	306 PlatformEvent() {
a61af66fc99e Initial load duke parents: diff changeset	307 int status;
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	308 status = pthread_cond_init (_cond, os::Linux::condAttr());
0 a61af66fc99e Initial load duke parents: diff changeset	309 assert_status(status == 0, status, "cond_init");
a61af66fc99e Initial load duke parents: diff changeset	310 status = pthread_mutex_init (_mutex, NULL);
a61af66fc99e Initial load duke parents: diff changeset	311 assert_status(status == 0, status, "mutex_init");
a61af66fc99e Initial load duke parents: diff changeset	312 _Event = 0 ;
a61af66fc99e Initial load duke parents: diff changeset	313 _nParked = 0 ;
a61af66fc99e Initial load duke parents: diff changeset	314 _Assoc = NULL ;
a61af66fc99e Initial load duke parents: diff changeset	315 }
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 // Use caution with reset() and fired() -- they may require MEMBARs
a61af66fc99e Initial load duke parents: diff changeset	318 void reset() { _Event = 0 ; }
a61af66fc99e Initial load duke parents: diff changeset	319 int fired() { return _Event; }
a61af66fc99e Initial load duke parents: diff changeset	320 void park () ;
a61af66fc99e Initial load duke parents: diff changeset	321 void unpark () ;
a61af66fc99e Initial load duke parents: diff changeset	322 int TryPark () ;
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	323 int park (jlong millis) ; // relative timed-wait only
0 a61af66fc99e Initial load duke parents: diff changeset	324 void SetAssociation (Thread * a) { _Assoc = a ; }
a61af66fc99e Initial load duke parents: diff changeset	325 } ;
a61af66fc99e Initial load duke parents: diff changeset	326
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6080 diff changeset	327 class PlatformParker : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	328 protected:
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	329 enum {
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	330 REL_INDEX = 0,
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	331 ABS_INDEX = 1
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	332 };
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	333 int _cur_index; // which cond is in use: -1, 0, 1
0 a61af66fc99e Initial load duke parents: diff changeset	334 pthread_mutex_t _mutex [1] ;
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	335 pthread_cond_t _cond [2] ; // one for relative times and one for abs.
0 a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 public: // TODO-FIXME: make dtor private
a61af66fc99e Initial load duke parents: diff changeset	338 ~PlatformParker() { guarantee (0, "invariant") ; }
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 public:
a61af66fc99e Initial load duke parents: diff changeset	341 PlatformParker() {
a61af66fc99e Initial load duke parents: diff changeset	342 int status;
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	343 status = pthread_cond_init (&_cond[REL_INDEX], os::Linux::condAttr());
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	344 assert_status(status == 0, status, "cond_init rel");
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	345 status = pthread_cond_init (&_cond[ABS_INDEX], NULL);
2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	346 assert_status(status == 0, status, "cond_init abs");
0 a61af66fc99e Initial load duke parents: diff changeset	347 status = pthread_mutex_init (_mutex, NULL);
a61af66fc99e Initial load duke parents: diff changeset	348 assert_status(status == 0, status, "mutex_init");
12211 2e6938dd68f2 6900441: PlatformEvent.park(millis) on Linux could still be affected by changes to the time-of-day clock dholmes parents: 12177 diff changeset	349 _cur_index = -1; // mark as unused
0 a61af66fc99e Initial load duke parents: diff changeset	350 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10164 diff changeset	351 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	352
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	353 #endif // OS_LINUX_VM_OS_LINUX_HPP

Mercurial > hg > truffle

annotate src/os/linux/vm/os_linux.hpp @ 20338:8d5f66b42c53