hotspot/src/os/linux/vm/os_linux.hpp
author johnc
Wed, 29 Aug 2012 13:02:54 -0700
changeset 13518 86a9027340fb
parent 13195 be27e1b6a4b9
child 15855 2ac9ebea17f3
permissions -rw-r--r--
7194409: os::javaTimeNanos() shows hot on CPU_CLK_UNHALTED profiles Summary: Add inline directives to os::Linux::supports_monotonic_clock() and os::Bsd::supports_monotonic_clock(). Reviewed-by: johnc, azeemj, mikael Contributed-by: Brandon Mitchell <brandon@twitter.com>
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
13518
86a9027340fb 7194409: os::javaTimeNanos() shows hot on CPU_CLK_UNHALTED profiles
johnc
parents: 13195
diff changeset
     2
 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#ifndef OS_LINUX_VM_OS_LINUX_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define OS_LINUX_VM_OS_LINUX_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// Linux_OS defines the interface to Linux operating systems
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
/* pthread_getattr_np comes with LinuxThreads-0.9-7 on RedHat 7.1 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
typedef int (*pthread_getattr_func_type) (pthread_t, pthread_attr_t *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
class Linux {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
  friend class os;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  // For signal-chaining
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
#define MAXSIGNUM 32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  static struct sigaction sigact[MAXSIGNUM]; // saved preinstalled sigactions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  static unsigned int sigs;             // mask of signals that have
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
                                        // preinstalled signal handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  static bool libjsig_is_loaded;        // libjsig that interposes sigaction(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
                                        // __sigaction(), signal() is loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  static struct sigaction *(*get_signal_action)(int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  static struct sigaction *get_preinstalled_handler(int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  static void save_preinstalled_handler(int, struct sigaction&);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  static void check_signal_handler(int sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  // For signal flags diagnostics
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  static int sigflags[MAXSIGNUM];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  static int (*_clock_gettime)(clockid_t, struct timespec *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  static int (*_pthread_getcpuclockid)(pthread_t, clockid_t *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  static address   _initial_thread_stack_bottom;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  static uintptr_t _initial_thread_stack_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
745
47129a5cacd3 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6
xlu
parents: 388
diff changeset
    58
  static const char *_glibc_version;
47129a5cacd3 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6
xlu
parents: 388
diff changeset
    59
  static const char *_libpthread_version;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  static bool _is_floating_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  static bool _is_NPTL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  static bool _supports_fast_thread_cpu_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
    65
  static GrowableArray<int>* _cpu_to_node;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
    66
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  static julong _physical_memory;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  static pthread_t _main_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  static Mutex* _createThread_lock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  static int _page_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  static julong available_memory();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  static julong physical_memory() { return _physical_memory; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  static void initialize_system_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
745
47129a5cacd3 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6
xlu
parents: 388
diff changeset
    78
  static void set_glibc_version(const char *s)      { _glibc_version = s; }
47129a5cacd3 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6
xlu
parents: 388
diff changeset
    79
  static void set_libpthread_version(const char *s) { _libpthread_version = s; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  static bool supports_variable_stack_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  static void set_is_NPTL()                   { _is_NPTL = true;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  static void set_is_LinuxThreads()           { _is_NPTL = false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  static void set_is_floating_stack()         { _is_floating_stack = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
    87
  static void rebuild_cpu_to_node_map();
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
    88
  static GrowableArray<int>* cpu_to_node()    { return _cpu_to_node; }
9335
7bdd2a3ab3d8 7034464: Support transparent large pages on Linux
iveresov
parents: 7397
diff changeset
    89
7bdd2a3ab3d8 7034464: Support transparent large pages on Linux
iveresov
parents: 7397
diff changeset
    90
  static bool hugetlbfs_sanity_check(bool warn, size_t page_size);
7bdd2a3ab3d8 7034464: Support transparent large pages on Linux
iveresov
parents: 7397
diff changeset
    91
12735
3e2e491f4f69 7165755: OS Information much longer on linux than other platforms
nloodin
parents: 10239
diff changeset
    92
  static void print_full_memory_info(outputStream* st);
3e2e491f4f69 7165755: OS Information much longer on linux than other platforms
nloodin
parents: 10239
diff changeset
    93
  static void print_distro_info(outputStream* st);
3e2e491f4f69 7165755: OS Information much longer on linux than other platforms
nloodin
parents: 10239
diff changeset
    94
  static void print_libversion_info(outputStream* st);
3e2e491f4f69 7165755: OS Information much longer on linux than other platforms
nloodin
parents: 10239
diff changeset
    95
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  static void init_thread_fpu_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  static int  get_fpu_control_word();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  static void set_fpu_control_word(int fpu_control);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  static pthread_t main_thread(void)                                { return _main_thread; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // returns kernel thread id (similar to LWP id on Solaris), which can be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // used to access /proc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  static pid_t gettid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  static void set_createThread_lock(Mutex* lk)                      { _createThread_lock = lk; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  static Mutex* createThread_lock(void)                             { return _createThread_lock; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  static void hotspot_sigmask(Thread* thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  static address   initial_thread_stack_bottom(void)                { return _initial_thread_stack_bottom; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  static uintptr_t initial_thread_stack_size(void)                  { return _initial_thread_stack_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  static bool is_initial_thread(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  static int page_size(void)                                        { return _page_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  static void set_page_size(int val)                                { _page_size = val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  static address   ucontext_get_pc(ucontext_t* uc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  static intptr_t* ucontext_get_sp(ucontext_t* uc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  static intptr_t* ucontext_get_fp(ucontext_t* uc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // For Analyzer Forte AsyncGetCallTrace profiling support:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // This interface should be declared in os_linux_i486.hpp, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // that file provides extensions to the os class and not the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // Linux class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  static ExtendedPC fetch_frame_from_ucontext(Thread* thread, ucontext_t* uc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    intptr_t** ret_sp, intptr_t** ret_fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // This boolean allows users to forward their own non-matching signals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // to JVM_handle_linux_signal, harmlessly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  static bool signal_handlers_are_installed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  static int get_our_sigflags(int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  static void set_our_sigflags(int, int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  static void signal_sets_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  static void install_signal_handlers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  static void set_signal_handler(int, bool);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  static bool is_sig_ignored(int sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  static sigset_t* unblocked_signals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  static sigset_t* vm_signals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  static sigset_t* allowdebug_blocked_signals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // For signal-chaining
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  static struct sigaction *get_chained_signal_action(int sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // GNU libc and libpthread version strings
745
47129a5cacd3 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6
xlu
parents: 388
diff changeset
   147
  static const char *glibc_version()          { return _glibc_version; }
47129a5cacd3 6681796: hotspot build failure on gcc 4.2.x (ubuntu 8.04) w/ openjdk 6
xlu
parents: 388
diff changeset
   148
  static const char *libpthread_version()     { return _libpthread_version; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // NPTL or LinuxThreads?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  static bool is_LinuxThreads()               { return !_is_NPTL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  static bool is_NPTL()                       { return _is_NPTL;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // NPTL is always floating stack. LinuxThreads could be using floating
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // stack or fixed stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  static bool is_floating_stack()             { return _is_floating_stack; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  static void libpthread_init();
1615
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   159
  static bool libnuma_init();
2753
1e9bbaae891b 6840196: NUMA allocator: crash in fastdebug during startup on Linux
iveresov
parents: 1615
diff changeset
   160
  static void* libnuma_dlsym(void* handle, const char* name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // Minimum stack size a thread can be created with (allowing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // the VM to completely create the thread and enter user code)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  static size_t min_stack_allowed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // Return default stack size or guard size for the specified thread type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  static size_t default_stack_size(os::ThreadType thr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  static size_t default_guard_size(os::ThreadType thr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  static void capture_initial_stack(size_t max_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // Stack overflow handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  static bool manually_expand_stack(JavaThread * t, address addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  static int max_register_window_saves_before_flushing();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // Real-time clock functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  static void clock_init(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // fast POSIX clocks support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  static void fast_thread_clock_init(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
13518
86a9027340fb 7194409: os::javaTimeNanos() shows hot on CPU_CLK_UNHALTED profiles
johnc
parents: 13195
diff changeset
   181
  static inline bool supports_monotonic_clock() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    return _clock_gettime != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  static int clock_gettime(clockid_t clock_id, struct timespec *tp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    return _clock_gettime ? _clock_gettime(clock_id, tp) : -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  static int pthread_getcpuclockid(pthread_t tid, clockid_t *clock_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    return _pthread_getcpuclockid ? _pthread_getcpuclockid(tid, clock_id) : -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  static bool supports_fast_thread_cpu_time() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    return _supports_fast_thread_cpu_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  static jlong fast_thread_cpu_time(clockid_t clockid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  // Stack repair handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // none present
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  // LinuxThreads work-around for 6292965
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  static int safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  // Linux suspend/resume support - this helper is a shadow of its former
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  // self now that low-level suspension is barely used, and old workarounds
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  // for LinuxThreads are no longer needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  class SuspendResume {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    volatile int _suspend_action;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    // values for suspend_action:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    #define SR_NONE               (0x00)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    #define SR_SUSPEND            (0x01)  // suspend request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    #define SR_CONTINUE           (0x02)  // resume request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    volatile jint _state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    // values for _state: + SR_NONE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    #define SR_SUSPENDED          (0x20)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    SuspendResume() { _suspend_action = SR_NONE; _state = SR_NONE; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    int suspend_action() const     { return _suspend_action; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    void set_suspend_action(int x) { _suspend_action = x;    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    // atomic updates for _state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    void set_suspended()           {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
      jint temp, temp2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
      do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
        temp = _state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
        temp2 = Atomic::cmpxchg(temp | SR_SUSPENDED, &_state, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
      } while (temp2 != temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    void clear_suspended()        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
      jint temp, temp2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
      do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
        temp = _state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
        temp2 = Atomic::cmpxchg(temp & ~SR_SUSPENDED, &_state, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
      } while (temp2 != temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    bool is_suspended()            { return _state & SR_SUSPENDED;       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    #undef SR_SUSPENDED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  };
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   246
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   247
private:
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   248
  typedef int (*sched_getcpu_func_t)(void);
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   249
  typedef int (*numa_node_to_cpus_func_t)(int node, unsigned long *buffer, int bufferlen);
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   250
  typedef int (*numa_max_node_func_t)(void);
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   251
  typedef int (*numa_available_func_t)(void);
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   252
  typedef int (*numa_tonode_memory_func_t)(void *start, size_t size, int node);
1615
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   253
  typedef void (*numa_interleave_memory_func_t)(void *start, size_t size, unsigned long *nodemask);
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   254
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   255
  static sched_getcpu_func_t _sched_getcpu;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   256
  static numa_node_to_cpus_func_t _numa_node_to_cpus;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   257
  static numa_max_node_func_t _numa_max_node;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   258
  static numa_available_func_t _numa_available;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   259
  static numa_tonode_memory_func_t _numa_tonode_memory;
1615
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   260
  static numa_interleave_memory_func_t _numa_interleave_memory;
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   261
  static unsigned long* _numa_all_nodes;
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   262
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   263
  static void set_sched_getcpu(sched_getcpu_func_t func) { _sched_getcpu = func; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   264
  static void set_numa_node_to_cpus(numa_node_to_cpus_func_t func) { _numa_node_to_cpus = func; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   265
  static void set_numa_max_node(numa_max_node_func_t func) { _numa_max_node = func; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   266
  static void set_numa_available(numa_available_func_t func) { _numa_available = func; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   267
  static void set_numa_tonode_memory(numa_tonode_memory_func_t func) { _numa_tonode_memory = func; }
1615
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   268
  static void set_numa_interleave_memory(numa_interleave_memory_func_t func) { _numa_interleave_memory = func; }
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   269
  static void set_numa_all_nodes(unsigned long* ptr) { _numa_all_nodes = ptr; }
10239
c7af330d33d9 7060836: RHEL 5.5 and 5.6 should support UseNUMA
iveresov
parents: 9335
diff changeset
   270
  static int sched_getcpu_syscall(void);
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   271
public:
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   272
  static int sched_getcpu()  { return _sched_getcpu != NULL ? _sched_getcpu() : -1; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   273
  static int numa_node_to_cpus(int node, unsigned long *buffer, int bufferlen) {
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   274
    return _numa_node_to_cpus != NULL ? _numa_node_to_cpus(node, buffer, bufferlen) : -1;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   275
  }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   276
  static int numa_max_node() { return _numa_max_node != NULL ? _numa_max_node() : -1; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   277
  static int numa_available() { return _numa_available != NULL ? _numa_available() : -1; }
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   278
  static int numa_tonode_memory(void *start, size_t size, int node) {
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   279
    return _numa_tonode_memory != NULL ? _numa_tonode_memory(start, size, node) : -1;
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   280
  }
1615
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   281
  static void numa_interleave_memory(void *start, size_t size) {
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   282
    if (_numa_interleave_memory != NULL && _numa_all_nodes != NULL) {
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   283
      _numa_interleave_memory(start, size, _numa_all_nodes);
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   284
    }
b46d9f19bde2 6779436: NUMA allocator: libnuma expects certain size of the buffer in numa_node_to_cpus()
iveresov
parents: 781
diff changeset
   285
  }
388
bcc631c5bbec 6684395: Port NUMA-aware allocator to linux
iveresov
parents: 1
diff changeset
   286
  static int get_node_by_cpu(int cpu_id);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12735
diff changeset
   290
class PlatformEvent : public CHeapObj<mtInternal> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    double CachePad [4] ;   // increase odds that _mutex is sole occupant of cache line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    volatile int _Event ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    volatile int _nParked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    pthread_mutex_t _mutex  [1] ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    pthread_cond_t  _cond   [1] ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
    double PostPad  [2] ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    Thread * _Assoc ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  public:       // TODO-FIXME: make dtor private
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    ~PlatformEvent() { guarantee (0, "invariant") ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    PlatformEvent() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
      int status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
      status = pthread_cond_init (_cond, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
      assert_status(status == 0, status, "cond_init");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
      status = pthread_mutex_init (_mutex, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
      assert_status(status == 0, status, "mutex_init");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
      _Event   = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
      _nParked = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
      _Assoc   = NULL ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    // Use caution with reset() and fired() -- they may require MEMBARs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    void reset() { _Event = 0 ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    int  fired() { return _Event; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    void park () ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    void unpark () ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    int  TryPark () ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    int  park (jlong millis) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    void SetAssociation (Thread * a) { _Assoc = a ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
} ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12735
diff changeset
   325
class PlatformParker : public CHeapObj<mtInternal> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    pthread_mutex_t _mutex [1] ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    pthread_cond_t  _cond  [1] ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  public:       // TODO-FIXME: make dtor private
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    ~PlatformParker() { guarantee (0, "invariant") ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    PlatformParker() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
      int status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
      status = pthread_cond_init (_cond, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
      assert_status(status == 0, status, "cond_init");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
      status = pthread_mutex_init (_mutex, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
      assert_status(status == 0, status, "mutex_init");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
} ;
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   342
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   343
#endif // OS_LINUX_VM_OS_LINUX_HPP