< prev index next >
src/hotspot/os/solaris/os_solaris.cpp
Print this page
rev 56578 : 8232211: Remove dead code from os.hpp|cpp
Reviewed-by: TBD
*** 263,274 ****
if (enabler) {
enabler(-1, -1);
}
}
- static int _processors_online = 0;
-
jint os::Solaris::_os_thread_limit = 0;
volatile jint os::Solaris::_os_thread_count = 0;
julong os::available_memory() {
return Solaris::available_memory();
--- 263,272 ----
*** 289,299 ****
static volatile hrtime_t max_hrtime = 0;
void os::Solaris::initialize_system_info() {
set_processor_count(sysconf(_SC_NPROCESSORS_CONF));
- _processors_online = sysconf(_SC_NPROCESSORS_ONLN);
_physical_memory = (julong)sysconf(_SC_PHYS_PAGES) *
(julong)sysconf(_SC_PAGESIZE);
}
uint os::processor_id() {
--- 287,296 ----
*** 318,465 ****
if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {
uint_t pset_cpus;
// Query the number of cpus available to us.
if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {
assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");
- _processors_online = pset_cpus;
return pset_cpus;
}
}
// Otherwise return number of online cpus
return online_cpus;
}
- static bool find_processors_in_pset(psetid_t pset,
- processorid_t** id_array,
- uint_t* id_length) {
- bool result = false;
- // Find the number of processors in the processor set.
- if (pset_info(pset, NULL, id_length, NULL) == 0) {
- // Make up an array to hold their ids.
- *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
- // Fill in the array with their processor ids.
- if (pset_info(pset, NULL, id_length, *id_array) == 0) {
- result = true;
- }
- }
- return result;
- }
-
- // Callers of find_processors_online() must tolerate imprecise results --
- // the system configuration can change asynchronously because of DR
- // or explicit psradm operations.
- //
- // We also need to take care that the loop (below) terminates as the
- // number of processors online can change between the _SC_NPROCESSORS_ONLN
- // request and the loop that builds the list of processor ids. Unfortunately
- // there's no reliable way to determine the maximum valid processor id,
- // so we use a manifest constant, MAX_PROCESSOR_ID, instead. See p_online
- // man pages, which claim the processor id set is "sparse, but
- // not too sparse". MAX_PROCESSOR_ID is used to ensure that we eventually
- // exit the loop.
- //
- // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's
- // not available on S8.0.
-
- static bool find_processors_online(processorid_t** id_array,
- uint* id_length) {
- const processorid_t MAX_PROCESSOR_ID = 100000;
- // Find the number of processors online.
- *id_length = sysconf(_SC_NPROCESSORS_ONLN);
- // Make up an array to hold their ids.
- *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
- // Processors need not be numbered consecutively.
- long found = 0;
- processorid_t next = 0;
- while (found < *id_length && next < MAX_PROCESSOR_ID) {
- processor_info_t info;
- if (processor_info(next, &info) == 0) {
- // NB, PI_NOINTR processors are effectively online ...
- if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {
- (*id_array)[found] = next;
- found += 1;
- }
- }
- next += 1;
- }
- if (found < *id_length) {
- // The loop above didn't identify the expected number of processors.
- // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)
- // and re-running the loop, above, but there's no guarantee of progress
- // if the system configuration is in flux. Instead, we just return what
- // we've got. Note that in the worst case find_processors_online() could
- // return an empty set. (As a fall-back in the case of the empty set we
- // could just return the ID of the current processor).
- *id_length = found;
- }
-
- return true;
- }
-
- static bool assign_distribution(processorid_t* id_array,
- uint id_length,
- uint* distribution,
- uint distribution_length) {
- // We assume we can assign processorid_t's to uint's.
- assert(sizeof(processorid_t) == sizeof(uint),
- "can't convert processorid_t to uint");
- // Quick check to see if we won't succeed.
- if (id_length < distribution_length) {
- return false;
- }
- // Assign processor ids to the distribution.
- // Try to shuffle processors to distribute work across boards,
- // assuming 4 processors per board.
- const uint processors_per_board = ProcessDistributionStride;
- // Find the maximum processor id.
- processorid_t max_id = 0;
- for (uint m = 0; m < id_length; m += 1) {
- max_id = MAX2(max_id, id_array[m]);
- }
- // The next id, to limit loops.
- const processorid_t limit_id = max_id + 1;
- // Make up markers for available processors.
- bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal);
- for (uint c = 0; c < limit_id; c += 1) {
- available_id[c] = false;
- }
- for (uint a = 0; a < id_length; a += 1) {
- available_id[id_array[a]] = true;
- }
- // Step by "boards", then by "slot", copying to "assigned".
- // NEEDS_CLEANUP: The assignment of processors should be stateful,
- // remembering which processors have been assigned by
- // previous calls, etc., so as to distribute several
- // independent calls of this method. What we'd like is
- // It would be nice to have an API that let us ask
- // how many processes are bound to a processor,
- // but we don't have that, either.
- // In the short term, "board" is static so that
- // subsequent distributions don't all start at board 0.
- static uint board = 0;
- uint assigned = 0;
- // Until we've found enough processors ....
- while (assigned < distribution_length) {
- // ... find the next available processor in the board.
- for (uint slot = 0; slot < processors_per_board; slot += 1) {
- uint try_id = board * processors_per_board + slot;
- if ((try_id < limit_id) && (available_id[try_id] == true)) {
- distribution[assigned] = try_id;
- available_id[try_id] = false;
- assigned += 1;
- break;
- }
- }
- board += 1;
- if (board * processors_per_board + 0 >= limit_id) {
- board = 0;
- }
- }
- FREE_C_HEAP_ARRAY(bool, available_id);
- return true;
- }
-
void os::set_native_thread_name(const char *name) {
if (Solaris::_pthread_setname_np != NULL) {
// Only the first 31 bytes of 'name' are processed by pthread_setname_np
// but we explicitly copy into a size-limited buffer to avoid any
// possible overflow.
--- 315,331 ----
*** 468,502 ****
buf[sizeof(buf) - 1] = '\0';
Solaris::_pthread_setname_np(pthread_self(), buf);
}
}
- bool os::distribute_processes(uint length, uint* distribution) {
- bool result = false;
- // Find the processor id's of all the available CPUs.
- processorid_t* id_array = NULL;
- uint id_length = 0;
- // There are some races between querying information and using it,
- // since processor sets can change dynamically.
- psetid_t pset = PS_NONE;
- // Are we running in a processor set?
- if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {
- result = find_processors_in_pset(pset, &id_array, &id_length);
- } else {
- result = find_processors_online(&id_array, &id_length);
- }
- if (result == true) {
- if (id_length >= length) {
- result = assign_distribution(id_array, id_length, distribution, length);
- } else {
- result = false;
- }
- }
- FREE_C_HEAP_ARRAY(processorid_t, id_array);
- return result;
- }
-
bool os::bind_to_processor(uint processor_id) {
// We assume that a processorid_t can be stored in a uint.
assert(sizeof(uint) == sizeof(processorid_t),
"can't convert uint to processorid_t");
int bind_result =
--- 334,343 ----
*** 1235,1246 ****
return true;
}
}
bool os::supports_vtime() { return true; }
- bool os::enable_vtime() { return false; }
- bool os::vtime_enabled() { return false; }
double os::elapsedVTime() {
return (double)gethrvtime() / (double)hrtime_hz;
}
--- 1076,1085 ----
< prev index next >