graal-jvmci-8: src/os/linux/vm/os

comparison src/os/linux/vm/os_linux.cpp @ 24218:719853999215 jvmci-0.32

Merge with jdk8u141-b15

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 14 Aug 2017 23:20:38 +0200
parents	9b69cec6d01b 75021e6fe108
children	8128b98d4736

comparison

equal deleted inserted replaced

-:ac6f03d5b89e
+:719853999215
 /*
-* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 # include <stdint.h>
 # include <inttypes.h>
 # include <sys/ioctl.h>
 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#include <sched.h>
+#undef _GNU_SOURCE
+#else
+#include <sched.h>
+#endif
 // if RUSAGE_THREAD for getrusage() has not been defined, do it here. The code calling
 // getrusage() is prepared to handle the associated failure.
 #ifndef RUSAGE_THREAD
 #define RUSAGE_THREAD   (1)               /* only the calling thread */
 return false;
 }
 // Locate initial thread stack. This special handling of initial thread stack
 // is needed because pthread_getattr_np() on most (all?) Linux distros returns
-// bogus value for initial thread.
+// bogus value for the primordial process thread. While the launcher has created
+// the VM in a new thread since JDK 6, we still have to allow for the use of the
+// JNI invocation API from a primordial thread.
 void os::Linux::capture_initial_stack(size_t max_size) {
-// stack size is the easy part, get it from RLIMIT_STACK
-size_t stack_size;
+// max_size is either 0 (which means accept OS default for thread stacks) or
+// a user-specified value known to be at least the minimum needed. If we
+// are actually on the primordial thread we can make it appear that we have a
+// smaller max_size stack by inserting the guard pages at that location. But we
+// cannot do anything to emulate a larger stack than what has been provided by
+// the OS or threading library. In fact if we try to use a stack greater than
+// what is set by rlimit then we will crash the hosting process.
+// Maximum stack size is the easy part, get it from RLIMIT_STACK.
+// If this is "unlimited" then it will be a huge value.
 struct rlimit rlim;
 getrlimit(RLIMIT_STACK, &rlim);
-stack_size = rlim.rlim_cur;
+size_t stack_size = rlim.rlim_cur;
 // 6308388: a bug in ld.so will relocate its own .data section to the
 //   lower end of primordial stack; reduce ulimit -s value a little bit
 //   so we won't install guard page on ld.so's data section.
 stack_size -= 2 * page_size();
-// 4441425: avoid crash with "unlimited" stack size on SuSE 7.1 or Redhat
-//   7.1, in both cases we will get 2G in return value.
-// 4466587: glibc 2.2.x compiled w/o "--enable-kernel=2.4.0" (RH 7.0,
-//   SuSE 7.2, Debian) can not handle alternate signal stack correctly
-//   for initial thread if its stack size exceeds 6M. Cap it at 2M,
-//   in case other parts in glibc still assumes 2M max stack size.
-// FIXME: alt signal stack is gone, maybe we can relax this constraint?
-// Problem still exists RH7.2 (IA64 anyway) but 2MB is a little small
-if (stack_size > 2 * K * K IA64_ONLY(*2))
-stack_size = 2 * K * K IA64_ONLY(*2);
 // Try to figure out where the stack base (top) is. This is harder.
 //
 // When an application is started, glibc saves the initial stack pointer in
 // a global variable "__libc_stack_end", which is then used by system
 // libraries. __libc_stack_end should be pretty close to stack top. The
 }
 // stack_top could be partially down the page so align it
 stack_top = align_size_up(stack_top, page_size());
-if (max_size && stack_size > max_size) {
+// Allowed stack value is minimum of max_size and what we derived from rlimit
-_initial_thread_stack_size = max_size;
+if (max_size > 0) {
+_initial_thread_stack_size = MIN2(max_size, stack_size);
 } else {
-_initial_thread_stack_size = stack_size;
+// Accept the rlimit max, but if stack is unlimited then it will be huge, so
+// clamp it at 8MB as we do on Solaris
+_initial_thread_stack_size = MIN2(stack_size, 8*M);
 }
 _initial_thread_stack_size = align_size_down(_initial_thread_stack_size, page_size());
 _initial_thread_stack_bottom = (address)stack_top - _initial_thread_stack_size;
+assert(_initial_thread_stack_bottom < (address)stack_top, "overflow!");
 }
 ////////////////////////////////////////////////////////////////////////////////
 // time support
 if( !linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) {
 fatal("Could not enable polling page");
 }
 };
+static int os_cpu_count(const cpu_set_t* cpus) {
+int count = 0;
+// only look up to the number of configured processors
+for (int i = 0; i < os::processor_count(); i++) {
+if (CPU_ISSET(i, cpus)) {
+count++;
+}
+}
+return count;
+}
+// Get the current number of available processors for this process.
+// This value can change at any time during a process's lifetime.
+// sched_getaffinity gives an accurate answer as it accounts for cpusets.
+// If anything goes wrong we fallback to returning the number of online
+// processors - which can be greater than the number available to the process.
 int os::active_processor_count() {
-// Linux doesn't yet have a (official) notion of processor sets,
+cpu_set_t cpus;  // can represent at most 1024 (CPU_SETSIZE) processors
-// so just return the number of online processors.
+int cpus_size = sizeof(cpu_set_t);
-int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
+int cpu_count = 0;
-assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
-return online_cpus;
+// pid 0 means the current thread - which we have to assume represents the process
+if (sched_getaffinity(0, cpus_size, &cpus) == 0) {
+cpu_count = os_cpu_count(&cpus);
+if (PrintActiveCpus) {
+tty->print_cr("active_processor_count: sched_getaffinity processor count: %d", cpu_count);
+}
+}
+else {
+cpu_count = ::sysconf(_SC_NPROCESSORS_ONLN);
+warning("sched_getaffinity failed (%s)- using online processor count (%d) "
+"which may exceed available processors", strerror(errno), cpu_count);
+}
+assert(cpu_count > 0 && cpu_count <= processor_count(), "sanity check");
+return cpu_count;
 }
 void os::set_native_thread_name(const char *name) {
 // Not yet implemented.
 return;

Mercurial > hg > graal-jvmci-8

comparison src/os/linux/vm/os_linux.cpp @ 24218:719853999215 jvmci-0.32