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

annotate src/os/linux/vm/os_linux.hpp @ 12110:4c84d351cca9

8007074: SIGSEGV at ParMarkBitMap::verify_clear() Summary: Replace the broken large pages implementation on Linux. New flag: -XX:+UseTransparentHugePages - Linux specific flag to turn on transparent huge page hinting with madvise(..., MAP_HUGETLB). Changed behavior: -XX:+UseLargePages - tries to use -XX:+UseTransparentHugePages before trying other large pages implementations (on Linux). Changed behavior: -XX:+UseHugeTLBFS - Use upfront allocation of Large Pages instead of using the broken implementation to dynamically committing large pages. Changed behavior: -XX:LargePageSizeInBytes - Turned off the ability to use this flag on Linux and provides warning to user if set to a value different than the OS chosen large page size. Changed behavior: Setting no large page size - Now defaults to use -XX:UseTransparentHugePages if the OS supports it. Previously, -XX:+UseHugeTLBFS was chosen if the OS was configured to use large pages. Reviewed-by: tschatzl, dcubed, brutisso

author	stefank
date	Fri, 16 Aug 2013 13:22:32 +0200
parents	a837fa3d3f86
children	0d59407e7e09

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
a61af66fc99e Initial load duke parents: diff changeset	224 // Stack repair handling
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 // none present
a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 // LinuxThreads work-around for 6292965
a61af66fc99e Initial load duke parents: diff changeset	229 static int safe_cond_timedwait(pthread_cond_t _cond, pthread_mutex_t _mutex, const struct timespec *_abstime);
a61af66fc99e Initial load duke parents: diff changeset	230
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	231 private:
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	232 typedef int (*sched_getcpu_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	233 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	234 typedef int (*numa_max_node_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	235 typedef int (*numa_available_func_t)(void);
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	236 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	237 typedef void (numa_interleave_memory_func_t)(void start, size_t size, unsigned long *nodemask);
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	238
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	239 static sched_getcpu_func_t _sched_getcpu;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	240 static numa_node_to_cpus_func_t _numa_node_to_cpus;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	241 static numa_max_node_func_t _numa_max_node;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	242 static numa_available_func_t _numa_available;
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	243 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	244 static numa_interleave_memory_func_t _numa_interleave_memory;
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	245 static unsigned long* _numa_all_nodes;
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 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	248 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	249 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	250 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	251 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	252 static void set_numa_interleave_memory(numa_interleave_memory_func_t func) { _numa_interleave_memory = func; }
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	253 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	254 static int sched_getcpu_syscall(void);
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	255 public:
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	256 static int sched_getcpu() { return _sched_getcpu != NULL ? _sched_getcpu() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	257 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	258 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	259 }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	260 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	261 static int numa_available() { return _numa_available != NULL ? _numa_available() : -1; }
fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	262 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	263 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	264 }
462 85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	265 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	266 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	267 _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	268 }
85f1b9537f70 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus() iveresov parents: 235 diff changeset	269 }
141 fcbfc50865ab 6684395: Port NUMA-aware allocator to linux iveresov parents: 0 diff changeset	270 static int get_node_by_cpu(int cpu_id);
0 a61af66fc99e Initial load duke parents: diff changeset	271 };
a61af66fc99e Initial load duke parents: diff changeset	272
a61af66fc99e Initial load duke parents: diff changeset	273
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6080 diff changeset	274 class PlatformEvent : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	275 private:
a61af66fc99e Initial load duke parents: diff changeset	276 double CachePad [4] ; // increase odds that _mutex is sole occupant of cache line
a61af66fc99e Initial load duke parents: diff changeset	277 volatile int _Event ;
a61af66fc99e Initial load duke parents: diff changeset	278 volatile int _nParked ;
a61af66fc99e Initial load duke parents: diff changeset	279 pthread_mutex_t _mutex [1] ;
a61af66fc99e Initial load duke parents: diff changeset	280 pthread_cond_t _cond [1] ;
a61af66fc99e Initial load duke parents: diff changeset	281 double PostPad [2] ;
a61af66fc99e Initial load duke parents: diff changeset	282 Thread * _Assoc ;
a61af66fc99e Initial load duke parents: diff changeset	283
a61af66fc99e Initial load duke parents: diff changeset	284 public: // TODO-FIXME: make dtor private
a61af66fc99e Initial load duke parents: diff changeset	285 ~PlatformEvent() { guarantee (0, "invariant") ; }
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 public:
a61af66fc99e Initial load duke parents: diff changeset	288 PlatformEvent() {
a61af66fc99e Initial load duke parents: diff changeset	289 int status;
a61af66fc99e Initial load duke parents: diff changeset	290 status = pthread_cond_init (_cond, NULL);
a61af66fc99e Initial load duke parents: diff changeset	291 assert_status(status == 0, status, "cond_init");
a61af66fc99e Initial load duke parents: diff changeset	292 status = pthread_mutex_init (_mutex, NULL);
a61af66fc99e Initial load duke parents: diff changeset	293 assert_status(status == 0, status, "mutex_init");
a61af66fc99e Initial load duke parents: diff changeset	294 _Event = 0 ;
a61af66fc99e Initial load duke parents: diff changeset	295 _nParked = 0 ;
a61af66fc99e Initial load duke parents: diff changeset	296 _Assoc = NULL ;
a61af66fc99e Initial load duke parents: diff changeset	297 }
a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 // Use caution with reset() and fired() -- they may require MEMBARs
a61af66fc99e Initial load duke parents: diff changeset	300 void reset() { _Event = 0 ; }
a61af66fc99e Initial load duke parents: diff changeset	301 int fired() { return _Event; }
a61af66fc99e Initial load duke parents: diff changeset	302 void park () ;
a61af66fc99e Initial load duke parents: diff changeset	303 void unpark () ;
a61af66fc99e Initial load duke parents: diff changeset	304 int TryPark () ;
a61af66fc99e Initial load duke parents: diff changeset	305 int park (jlong millis) ;
a61af66fc99e Initial load duke parents: diff changeset	306 void SetAssociation (Thread * a) { _Assoc = a ; }
a61af66fc99e Initial load duke parents: diff changeset	307 } ;
a61af66fc99e Initial load duke parents: diff changeset	308
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6080 diff changeset	309 class PlatformParker : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	310 protected:
a61af66fc99e Initial load duke parents: diff changeset	311 pthread_mutex_t _mutex [1] ;
a61af66fc99e Initial load duke parents: diff changeset	312 pthread_cond_t _cond [1] ;
a61af66fc99e Initial load duke parents: diff changeset	313
a61af66fc99e Initial load duke parents: diff changeset	314 public: // TODO-FIXME: make dtor private
a61af66fc99e Initial load duke parents: diff changeset	315 ~PlatformParker() { guarantee (0, "invariant") ; }
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 public:
a61af66fc99e Initial load duke parents: diff changeset	318 PlatformParker() {
a61af66fc99e Initial load duke parents: diff changeset	319 int status;
a61af66fc99e Initial load duke parents: diff changeset	320 status = pthread_cond_init (_cond, NULL);
a61af66fc99e Initial load duke parents: diff changeset	321 assert_status(status == 0, status, "cond_init");
a61af66fc99e Initial load duke parents: diff changeset	322 status = pthread_mutex_init (_mutex, NULL);
a61af66fc99e Initial load duke parents: diff changeset	323 assert_status(status == 0, status, "mutex_init");
a61af66fc99e Initial load duke parents: diff changeset	324 }
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10164 diff changeset	325 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	326
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	327 #endif // OS_LINUX_VM_OS_LINUX_HPP

Mercurial > hg > truffle

annotate src/os/linux/vm/os_linux.hpp @ 12110:4c84d351cca9