src/os/linux/vm/os_linux.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 1999, 2015, 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.
--- 1,7 ----
  /*
!  * 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.
*** 30,39 ****
--- 30,40 ----
  #include "code/vtableStubs.hpp"
  #include "compiler/compileBroker.hpp"
  #include "compiler/disassembler.hpp"
  #include "interpreter/interpreter.hpp"
  #include "jvm_linux.h"
+ #include "logging/log.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/filemap.hpp"
  #include "mutex_linux.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "os_linux.inline.hpp"
*** 104,113 ****
--- 105,122 ----
  # include <link.h>
  # include <stdint.h>
  # include <inttypes.h>
  # include <sys/ioctl.h>
  
+ #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 */
  #endif
*** 4760,4775 ****
    if (!linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) {
      fatal("Could not enable polling page");
    }
  }
  
  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;
  }
  
  void os::set_native_thread_name(const char *name) {
    if (Linux::_pthread_setname_np) {
      char buf [16]; // according to glibc manpage, 16 chars incl. '/0'
--- 4769,4844 ----
    if (!linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) {
      fatal("Could not enable polling page");
    }
  }
  
+ // 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 it appears there may be more than 1024 processors then we do a
+ // dynamic check - see 6515172 for details.
+ // 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() {
!   cpu_set_t cpus;  // can represent at most 1024 (CPU_SETSIZE) processors
!   cpu_set_t* cpus_p = &cpus;
!   int cpus_size = sizeof(cpu_set_t);
! 
!   int configured_cpus = processor_count();  // upper bound on available cpus
!   int cpu_count = 0;
! 
!   // To enable easy testing of the dynamic path on different platforms we
!   // introduce an experimental flag: UseCpuAllocPath
!   if (configured_cpus >= CPU_SETSIZE || UseCpuAllocPath) {
!     // kernel may use a mask bigger than cpu_set_t
!     log_trace(os)("active_processor_count: using dynamic path %s"
!                   "- configured processors: %d",
!                   UseCpuAllocPath ? "(forced) " : "",
!                   configured_cpus);
!     cpus_p = CPU_ALLOC(configured_cpus);
!     if (cpus_p != NULL) {
!       cpus_size = CPU_ALLOC_SIZE(configured_cpus);
!       // zero it just to be safe
!       CPU_ZERO_S(cpus_size, cpus_p);
!     }
!     else {
!        // failed to allocate so fallback to online cpus
         int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
!        log_trace(os)("active_processor_count: "
!                      "CPU_ALLOC failed (%s) - using "
!                      "online processor count: %d",
!                      strerror(errno), online_cpus);
         return online_cpus;
+     }
+   }
+   else {
+     log_trace(os)("active_processor_count: using static path - configured processors: %d",
+                   configured_cpus);
+   }
+        
+   // pid 0 means the current thread - which we have to assume represents the process
+   if (sched_getaffinity(0, cpus_size, cpus_p) == 0) {
+     if (cpus_p != &cpus) {
+       cpu_count = CPU_COUNT_S(cpus_size, cpus_p);
+     }
+     else {
+       cpu_count = CPU_COUNT(cpus_p);
+     }
+     log_trace(os)("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);
+   }
+ 
+   if (cpus_p != &cpus) {
+     CPU_FREE(cpus_p);
+   }  
+ 
+   assert(cpu_count > 0 && cpu_count <= processor_count(), "sanity check");
+   return cpu_count;
  }
  
  void os::set_native_thread_name(const char *name) {
    if (Linux::_pthread_setname_np) {
      char buf [16]; // according to glibc manpage, 16 chars incl. '/0'