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

annotate src/os/linux/vm/os_linux.hpp @ 17716:cdb71841f4bc

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	2e6938dd68f2
children	b0133e4187d3 6c9332549827

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
a61af66fc99e Initial load duke parents: diff changeset	33 class Linux {
a61af66fc99e Initial load duke parents: diff changeset	34 friend class os;
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	35 friend class TestReserveMemorySpecial;
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 // For signal-chaining
a61af66fc99e Initial load duke parents: diff changeset	38 #define MAXSIGNUM 32
a61af66fc99e Initial load duke parents: diff changeset	39 static struct sigaction sigact[MAXSIGNUM]; // saved preinstalled sigactions
a61af66fc99e Initial load duke parents: diff changeset	40 static unsigned int sigs; // mask of signals that have
a61af66fc99e Initial load duke parents: diff changeset	41 // preinstalled signal handlers
a61af66fc99e Initial load duke parents: diff changeset	42 static bool libjsig_is_loaded; // libjsig that interposes sigaction(),
a61af66fc99e Initial load duke parents: diff changeset	43 // __sigaction(), signal() is loaded
a61af66fc99e Initial load duke parents: diff changeset	44 static struct sigaction (get_signal_action)(int);
a61af66fc99e Initial load duke parents: diff changeset	45 static struct sigaction *get_preinstalled_handler(int);
a61af66fc99e Initial load duke parents: diff changeset	46 static void save_preinstalled_handler(int, struct sigaction&);
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 static void check_signal_handler(int sig);
a61af66fc99e Initial load duke parents: diff changeset	49
a61af66fc99e Initial load duke parents: diff changeset	50 // For signal flags diagnostics
a61af66fc99e Initial load duke parents: diff changeset	51 static int sigflags[MAXSIGNUM];
a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 static int (_clock_gettime)(clockid_t, struct timespec );
a61af66fc99e Initial load duke parents: diff changeset	54 static int (_pthread_getcpuclockid)(pthread_t, clockid_t );
a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56 static address _initial_thread_stack_bottom;
a61af66fc99e Initial load duke parents: diff changeset	57 static uintptr_t _initial_thread_stack_size;
a61af66fc99e Initial load duke parents: diff changeset	58
199 f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	59 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	60 static const char *_libpthread_version;
0 a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 static bool _is_floating_stack;
a61af66fc99e Initial load duke parents: diff changeset	63 static bool _is_NPTL;
a61af66fc99e Initial load duke parents: diff changeset	64 static bool _supports_fast_thread_cpu_time;
a61af66fc99e Initial load duke parents: diff changeset	65
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	66 static GrowableArray<int>* _cpu_to_node;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	67
0 a61af66fc99e Initial load duke parents: diff changeset	68 protected:
a61af66fc99e Initial load duke parents: diff changeset	69
a61af66fc99e Initial load duke parents: diff changeset	70 static julong _physical_memory;
a61af66fc99e Initial load duke parents: diff changeset	71 static pthread_t _main_thread;
a61af66fc99e Initial load duke parents: diff changeset	72 static Mutex* _createThread_lock;
a61af66fc99e Initial load duke parents: diff changeset	73 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	74 static const int _vm_default_page_size;
0 a61af66fc99e Initial load duke parents: diff changeset	75
a61af66fc99e Initial load duke parents: diff changeset	76 static julong available_memory();
a61af66fc99e Initial load duke parents: diff changeset	77 static julong physical_memory() { return _physical_memory; }
a61af66fc99e Initial load duke parents: diff changeset	78 static void initialize_system_info();
a61af66fc99e Initial load duke parents: diff changeset	79
10969 a837fa3d3f86 8013057: assert(_needs_gc \|\| SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint dcubed parents: 10405 diff changeset	80 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	81 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	82 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	83
199 f139919897d2 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6 xlu parents: 141 diff changeset	84 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	85 static void set_libpthread_version(const char *s) { _libpthread_version = s; }
0 a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 static bool supports_variable_stack_size();
a61af66fc99e Initial load duke parents: diff changeset	88
a61af66fc99e Initial load duke parents: diff changeset	89 static void set_is_NPTL() { _is_NPTL = true; }
a61af66fc99e Initial load duke parents: diff changeset	90 static void set_is_LinuxThreads() { _is_NPTL = false; }
a61af66fc99e Initial load duke parents: diff changeset	91 static void set_is_floating_stack() { _is_floating_stack = true; }
a61af66fc99e Initial load duke parents: diff changeset	92
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	93 static void rebuild_cpu_to_node_map();
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	94 static GrowableArray<int>* cpu_to_node() { return _cpu_to_node; }
3286 139667d9836a 7034464: Support transparent large pages on Linux iveresov parents: 1972 diff changeset	95
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	96 static size_t find_large_page_size();
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	97 static size_t setup_large_page_size();
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	98
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	99 static bool setup_large_page_type(size_t page_size);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	100 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	101 static bool hugetlbfs_sanity_check(bool warn, size_t page_size);
139667d9836a 7034464: Support transparent large pages on Linux iveresov parents: 1972 diff changeset	102
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	103 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	104 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	105 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	106 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	107
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	108 static bool release_memory_special_shm(char* base, size_t bytes);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	109 static bool release_memory_special_huge_tlbfs(char* base, size_t bytes);
4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 10969 diff changeset	110
6080 7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	111 static void print_full_memory_info(outputStream* st);
7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	112 static void print_distro_info(outputStream* st);
7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	113 static void print_libversion_info(outputStream* st);
7432b9db36ff 7165755: OS Information much longer on linux than other platforms nloodin parents: 3826 diff changeset	114
0 a61af66fc99e Initial load duke parents: diff changeset	115 public:
8710 9058789475af 7107135: Stack guard pages are no more protected after loading a shared library with executable stack iklam parents: 8675 diff changeset	116 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	117 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	118 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	119
0 a61af66fc99e Initial load duke parents: diff changeset	120 static void init_thread_fpu_state();
a61af66fc99e Initial load duke parents: diff changeset	121 static int get_fpu_control_word();
a61af66fc99e Initial load duke parents: diff changeset	122 static void set_fpu_control_word(int fpu_control);
a61af66fc99e Initial load duke parents: diff changeset	123 static pthread_t main_thread(void) { return _main_thread; }
a61af66fc99e Initial load duke parents: diff changeset	124 // returns kernel thread id (similar to LWP id on Solaris), which can be
a61af66fc99e Initial load duke parents: diff changeset	125 // used to access /proc
a61af66fc99e Initial load duke parents: diff changeset	126 static pid_t gettid();
a61af66fc99e Initial load duke parents: diff changeset	127 static void set_createThread_lock(Mutex* lk) { _createThread_lock = lk; }
a61af66fc99e Initial load duke parents: diff changeset	128 static Mutex* createThread_lock(void) { return _createThread_lock; }
a61af66fc99e Initial load duke parents: diff changeset	129 static void hotspot_sigmask(Thread* thread);
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 static address initial_thread_stack_bottom(void) { return _initial_thread_stack_bottom; }
a61af66fc99e Initial load duke parents: diff changeset	132 static uintptr_t initial_thread_stack_size(void) { return _initial_thread_stack_size; }
a61af66fc99e Initial load duke parents: diff changeset	133 static bool is_initial_thread(void);
a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135 static int page_size(void) { return _page_size; }
a61af66fc99e Initial load duke parents: diff changeset	136 static void set_page_size(int val) { _page_size = val; }
a61af66fc99e Initial load duke parents: diff changeset	137
10164 b4081e9714ec 8013398: Adjust number of stack guard pages on systems with large memory page size vladidan parents: 8812 diff changeset	138 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	139
0 a61af66fc99e Initial load duke parents: diff changeset	140 static address ucontext_get_pc(ucontext_t* uc);
a61af66fc99e Initial load duke parents: diff changeset	141 static intptr_t* ucontext_get_sp(ucontext_t* uc);
a61af66fc99e Initial load duke parents: diff changeset	142 static intptr_t* ucontext_get_fp(ucontext_t* uc);
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 // For Analyzer Forte AsyncGetCallTrace profiling support:
a61af66fc99e Initial load duke parents: diff changeset	145 //
a61af66fc99e Initial load duke parents: diff changeset	146 // This interface should be declared in os_linux_i486.hpp, but
a61af66fc99e Initial load duke parents: diff changeset	147 // that file provides extensions to the os class and not the
a61af66fc99e Initial load duke parents: diff changeset	148 // Linux class.
a61af66fc99e Initial load duke parents: diff changeset	149 static ExtendedPC fetch_frame_from_ucontext(Thread* thread, ucontext_t* uc,
a61af66fc99e Initial load duke parents: diff changeset	150 intptr_t ret_sp, intptr_t ret_fp);
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 // This boolean allows users to forward their own non-matching signals
a61af66fc99e Initial load duke parents: diff changeset	153 // to JVM_handle_linux_signal, harmlessly.
a61af66fc99e Initial load duke parents: diff changeset	154 static bool signal_handlers_are_installed;
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 static int get_our_sigflags(int);
a61af66fc99e Initial load duke parents: diff changeset	157 static void set_our_sigflags(int, int);
a61af66fc99e Initial load duke parents: diff changeset	158 static void signal_sets_init();
a61af66fc99e Initial load duke parents: diff changeset	159 static void install_signal_handlers();
a61af66fc99e Initial load duke parents: diff changeset	160 static void set_signal_handler(int, bool);
a61af66fc99e Initial load duke parents: diff changeset	161 static bool is_sig_ignored(int sig);
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 static sigset_t* unblocked_signals();
a61af66fc99e Initial load duke parents: diff changeset	164 static sigset_t* vm_signals();
a61af66fc99e Initial load duke parents: diff changeset	165 static sigset_t* allowdebug_blocked_signals();
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 // For signal-chaining
a61af66fc99e Initial load duke parents: diff changeset	168 static struct sigaction *get_chained_signal_action(int sig);
a61af66fc99e Initial load duke parents: diff changeset	169 static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 // 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	172 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	173 static const char *libpthread_version() { return _libpthread_version; }
0 a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 // NPTL or LinuxThreads?
a61af66fc99e Initial load duke parents: diff changeset	176 static bool is_LinuxThreads() { return !_is_NPTL; }
a61af66fc99e Initial load duke parents: diff changeset	177 static bool is_NPTL() { return _is_NPTL; }
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // NPTL is always floating stack. LinuxThreads could be using floating
a61af66fc99e Initial load duke parents: diff changeset	180 // stack or fixed stack.
a61af66fc99e Initial load duke parents: diff changeset	181 static bool is_floating_stack() { return _is_floating_stack; }
a61af66fc99e Initial load duke parents: diff changeset	182
a61af66fc99e Initial load duke parents: diff changeset	183 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	184 static bool libnuma_init();
763 cf71f149d7ae 6840196: NUMA allocator: crash in fastdebug during startup on Linux iveresov parents: 462 diff changeset	185 static void* libnuma_dlsym(void* handle, const char* name);
0 a61af66fc99e Initial load duke parents: diff changeset	186 // Minimum stack size a thread can be created with (allowing
a61af66fc99e Initial load duke parents: diff changeset	187 // the VM to completely create the thread and enter user code)
a61af66fc99e Initial load duke parents: diff changeset	188 static size_t min_stack_allowed;
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // Return default stack size or guard size for the specified thread type
a61af66fc99e Initial load duke parents: diff changeset	191 static size_t default_stack_size(os::ThreadType thr_type);
a61af66fc99e Initial load duke parents: diff changeset	192 static size_t default_guard_size(os::ThreadType thr_type);
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 static void capture_initial_stack(size_t max_size);
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 // Stack overflow handling
a61af66fc99e Initial load duke parents: diff changeset	197 static bool manually_expand_stack(JavaThread * t, address addr);
a61af66fc99e Initial load duke parents: diff changeset	198 static int max_register_window_saves_before_flushing();
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 // Real-time clock functions
a61af66fc99e Initial load duke parents: diff changeset	201 static void clock_init(void);
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 // fast POSIX clocks support
a61af66fc99e Initial load duke parents: diff changeset	204 static void fast_thread_clock_init(void);
a61af66fc99e Initial load duke parents: diff changeset	205
6630 fa9253dcd4df 7194409: os::javaTimeNanos() shows hot on CPU_CLK_UNHALTED profiles johnc parents: 6197 diff changeset	206 static inline bool supports_monotonic_clock() {
0 a61af66fc99e Initial load duke parents: diff changeset	207 return _clock_gettime != NULL;
a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210 static int clock_gettime(clockid_t clock_id, struct timespec *tp) {
a61af66fc99e Initial load duke parents: diff changeset	211 return _clock_gettime ? _clock_gettime(clock_id, tp) : -1;
a61af66fc99e Initial load duke parents: diff changeset	212 }
a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214 static int pthread_getcpuclockid(pthread_t tid, clockid_t *clock_id) {
a61af66fc99e Initial load duke parents: diff changeset	215 return _pthread_getcpuclockid ? _pthread_getcpuclockid(tid, clock_id) : -1;
a61af66fc99e Initial load duke parents: diff changeset	216 }
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 static bool supports_fast_thread_cpu_time() {
a61af66fc99e Initial load duke parents: diff changeset	219 return _supports_fast_thread_cpu_time;
a61af66fc99e Initial load duke parents: diff changeset	220 }
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 static jlong fast_thread_cpu_time(clockid_t clockid);
a61af66fc99e Initial load duke parents: diff changeset	223
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	224 // 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	225 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	226 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	227
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 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	229 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	230
0 a61af66fc99e Initial load duke parents: diff changeset	231 // Stack repair handling
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233 // none present
a61af66fc99e Initial load duke parents: diff changeset	234
a61af66fc99e Initial load duke parents: diff changeset	235 // LinuxThreads work-around for 6292965
a61af66fc99e Initial load duke parents: diff changeset	236 static int safe_cond_timedwait(pthread_cond_t _cond, pthread_mutex_t _mutex, const struct timespec *_abstime);
a61af66fc99e Initial load duke parents: diff changeset	237
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	238 private:
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	239 typedef int (*sched_getcpu_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	240 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	241 typedef int (*numa_max_node_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	242 typedef int (*numa_available_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	243 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	244 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	245 typedef void (*numa_set_bind_policy_func_t)(int policy);
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	246
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	247 static sched_getcpu_func_t _sched_getcpu;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	248 static numa_node_to_cpus_func_t _numa_node_to_cpus;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	249 static numa_max_node_func_t _numa_max_node;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	250 static numa_available_func_t _numa_available;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	251 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	252 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	253 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	254 static unsigned long* _numa_all_nodes;
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	255
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	256 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	257 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	258 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	259 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	260 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	261 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	262 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	263 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	264 static int sched_getcpu_syscall(void);
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	265 public:
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	266 static int sched_getcpu() { return _sched_getcpu != NULL ? _sched_getcpu() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	267 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	268 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	269 }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	270 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	271 static int numa_available() { return _numa_available != NULL ? _numa_available() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	272 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	273 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	274 }
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	275 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	276 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	277 _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	278 }
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	279 }
12176 88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	280 static void numa_set_bind_policy(int policy) {
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	281 if (_numa_set_bind_policy != NULL) {
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	282 _numa_set_bind_policy(policy);
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	283 }
88c255656030 8016155: SIGBUS when running Kitchensink with ParallelScavenge and ParallelOld mgerdin parents: 10969 diff changeset	284 }
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	285 static int get_node_by_cpu(int cpu_id);
0 a61af66fc99e Initial load duke parents: diff changeset	286 };
a61af66fc99e Initial load duke parents: diff changeset	287
a61af66fc99e Initial load duke parents: diff changeset	288
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6080 diff changeset	289 class PlatformEvent : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	290 private:
a61af66fc99e Initial load duke parents: diff changeset	291 double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line
a61af66fc99e Initial load duke parents: diff changeset	292 volatile int _Event ;
a61af66fc99e Initial load duke parents: diff changeset	293 volatile int _nParked ;
a61af66fc99e Initial load duke parents: diff changeset	294 pthread_mutex_t _mutex [1] ;
a61af66fc99e Initial load duke parents: diff changeset	295 pthread_cond_t _cond [1] ;
a61af66fc99e Initial load duke parents: diff changeset	296 double PostPad [2] ;
a61af66fc99e Initial load duke parents: diff changeset	297 Thread * _Assoc ;
a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 public: // TODO-FIXME: make dtor private
a61af66fc99e Initial load duke parents: diff changeset	300 ~PlatformEvent() { guarantee (0, "invariant") ; }
a61af66fc99e Initial load duke parents: diff changeset	301
a61af66fc99e Initial load duke parents: diff changeset	302 public:
a61af66fc99e Initial load duke parents: diff changeset	303 PlatformEvent() {
a61af66fc99e Initial load duke parents: diff changeset	304 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	305 status = pthread_cond_init (_cond, os::Linux::condAttr());
0 a61af66fc99e Initial load duke parents: diff changeset	306 assert_status(status == 0, status, "cond_init");
a61af66fc99e Initial load duke parents: diff changeset	307 status = pthread_mutex_init (_mutex, NULL);
a61af66fc99e Initial load duke parents: diff changeset	308 assert_status(status == 0, status, "mutex_init");
a61af66fc99e Initial load duke parents: diff changeset	309 _Event = 0 ;
a61af66fc99e Initial load duke parents: diff changeset	310 _nParked = 0 ;
a61af66fc99e Initial load duke parents: diff changeset	311 _Assoc = NULL ;
a61af66fc99e Initial load duke parents: diff changeset	312 }
a61af66fc99e Initial load duke parents: diff changeset	313
a61af66fc99e Initial load duke parents: diff changeset	314 // Use caution with reset() and fired() -- they may require MEMBARs
a61af66fc99e Initial load duke parents: diff changeset	315 void reset() { _Event = 0 ; }
a61af66fc99e Initial load duke parents: diff changeset	316 int fired() { return _Event; }
a61af66fc99e Initial load duke parents: diff changeset	317 void park () ;
a61af66fc99e Initial load duke parents: diff changeset	318 void unpark () ;
a61af66fc99e Initial load duke parents: diff changeset	319 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	320 int park (jlong millis) ; // relative timed-wait only
0 a61af66fc99e Initial load duke parents: diff changeset	321 void SetAssociation (Thread * a) { _Assoc = a ; }
a61af66fc99e Initial load duke parents: diff changeset	322 } ;
a61af66fc99e Initial load duke parents: diff changeset	323
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6080 diff changeset	324 class PlatformParker : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	325 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	326 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	327 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	328 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	329 };
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 int _cur_index; // which cond is in use: -1, 0, 1
0 a61af66fc99e Initial load duke parents: diff changeset	331 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	332 pthread_cond_t _cond [2] ; // one for relative times and one for abs.
0 a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 public: // TODO-FIXME: make dtor private
a61af66fc99e Initial load duke parents: diff changeset	335 ~PlatformParker() { guarantee (0, "invariant") ; }
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 public:
a61af66fc99e Initial load duke parents: diff changeset	338 PlatformParker() {
a61af66fc99e Initial load duke parents: diff changeset	339 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	340 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	341 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	342 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	343 assert_status(status == 0, status, "cond_init abs");
0 a61af66fc99e Initial load duke parents: diff changeset	344 status = pthread_mutex_init (_mutex, NULL);
a61af66fc99e Initial load duke parents: diff changeset	345 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	346 _cur_index = -1; // mark as unused
0 a61af66fc99e Initial load duke parents: diff changeset	347 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10164 diff changeset	348 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	349
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	350 #endif // OS_LINUX_VM_OS_LINUX_HPP

Mercurial > hg > truffle

annotate src/os/linux/vm/os_linux.hpp @ 17716:cdb71841f4bc