rpms/java-1.8.0-openjdk
7
0
Fork 0
Code Issues Pull Requests Releases Activity
93b65a6825
java-1.8.0-openjdk/6515172-pr3346.patch
Jiri 0fb9d78c0f Patche adapted to current surces
2017-04-21 09:58:39 +02:00

214 lines
8.6 KiB
Diff
Raw Blame History

# HG changeset patch
# User shshahma
# Date 1474535080 25200
# Thu Sep 22 02:04:40 2016 -0700
# Node ID baf64c88538f477d7f5a0cf90b670108ac312375
# Parent 62212568179b76b5ebe7b0129ddeed7b268b0bc0
6515172, PR3346: Runtime.availableProcessors() ignores Linux taskset command
Summary: extract processor count from sched_getaffinity mask
Reviewed-by: dholmes, gthornbr
diff --git a/src/os/linux/vm/globals_linux.hpp b/src/os/linux/vm/globals_linux.hpp
--- openjdk/hotspot/src/os/linux/vm/globals_linux.hpp
+++ openjdk/hotspot/src/os/linux/vm/globals_linux.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -47,7 +47,10 @@
"Load DLLs with executable-stack attribute in the VM Thread") \
\
product(bool, UseSHM, false, \
- "Use SYSV shared memory for large pages")
+ "Use SYSV shared memory for large pages") \
+ \
+ diagnostic(bool, PrintActiveCpus, false, \
+ "Print the number of CPUs detected in os::active_processor_count")
//
// Defines Linux-specific default values. The flags are available on all
diff --git a/src/os/linux/vm/os_linux.cpp b/src/os/linux/vm/os_linux.cpp
--- openjdk/hotspot/src/os/linux/vm/os_linux.cpp
+++ openjdk/hotspot/src/os/linux/vm/os_linux.cpp
@@ -1,5 +1,5 @@
/*
- * 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
@@ -104,6 +104,14 @@
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
@@ -5027,12 +5035,42 @@
}
};
+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,
- // so just return the number of online processors.
- int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
- assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
- return online_cpus;
+ cpu_set_t cpus; // can represent at most 1024 (CPU_SETSIZE) processors
+ int cpus_size = sizeof(cpu_set_t);
+ int cpu_count = 0;
+
+ // 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) {
diff --git a/test/runtime/os/AvailableProcessors.java b/test/runtime/os/AvailableProcessors.java
new file mode 100644
--- /dev/null
+++ openjdk/hotspot/test/runtime/os/AvailableProcessors.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+import java.io.File;
+import com.oracle.java.testlibrary.ProcessTools;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import java.util.ArrayList;
+
+/*
+ * @test
+ * @bug 6515172
+ * @summary Check that availableProcessors reports the correct value when running in a cpuset on linux
+ * @requires os.family == "linux"
+ * @library /testlibrary
+ * @build com.oracle.java.testlibrary.*
+ * @run driver AvailableProcessors
+ */
+public class AvailableProcessors {
+
+ static final String SUCCESS_STRING = "Found expected processors: ";
+
+ public static void main(String[] args) throws Throwable {
+ if (args.length > 0)
+ checkProcessors(Integer.parseInt(args[0]));
+ else {
+ // run ourselves under different cpu configurations
+ // using the taskset command
+ String taskset;
+ final String taskset1 = "/bin/taskset";
+ final String taskset2 = "/usr/bin/taskset";
+ if (new File(taskset1).exists())
+ taskset = taskset1;
+ else if (new File(taskset2).exists())
+ taskset = taskset2;
+ else {
+ System.out.println("Skipping test: could not find taskset command");
+ return;
+ }
+
+ int available = Runtime.getRuntime().availableProcessors();
+
+ if (available == 1) {
+ System.out.println("Skipping test: only one processor available");
+ return;
+ }
+
+ // Get the java command we want to execute
+ // Enable logging for easier failure diagnosis
+ ProcessBuilder master =
+ ProcessTools.createJavaProcessBuilder(false,
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:+PrintActiveCpus",
+ "AvailableProcessors");
+
+ int[] expected = new int[] { 1, available/2, available-1, available };
+
+ for (int i : expected) {
+ System.out.println("Testing for " + i + " processors ...");
+ int max = i - 1;
+ ArrayList<String> cmdline = new ArrayList<>(master.command());
+ // prepend taskset command
+ cmdline.add(0, "0-" + max);
+ cmdline.add(0, "-c");
+ cmdline.add(0, taskset);
+ // append expected processor count
+ cmdline.add(String.valueOf(i));
+ ProcessBuilder pb = new ProcessBuilder(cmdline);
+ System.out.println("Final command line: " +
+ ProcessTools.getCommandLine(pb));
+ OutputAnalyzer output = ProcessTools.executeProcess(pb);
+ output.shouldContain(SUCCESS_STRING);
+ }
+ }
+ }
+
+ static void checkProcessors(int expected) {
+ int available = Runtime.getRuntime().availableProcessors();
+ if (available != expected)
+ throw new Error("Expected " + expected + " processors, but found "
+ + available);
+ else
+ System.out.println(SUCCESS_STRING + available);
+ }
+}
Reference in New Issue View Git Blame Copy Permalink