gcc/libcilkrts/runtime/global_state.cpp

629 lines
22 KiB
C++
Raw Normal View History

/* global_state.cpp -*-C++-*-
*
*************************************************************************
*
* @copyright
* Copyright (C) 2009-2013, Intel Corporation
* All rights reserved.
*
* @copyright
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* @copyright
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
**************************************************************************/
#include "global_state.h"
#include "os.h"
#include "bug.h"
#include "metacall_impl.h"
#include "stats.h"
#include "cilk/cilk_api.h"
#include "cilk_malloc.h"
#include "record-replay.h"
#include <algorithm> // For max()
#include <cstring>
#include <cstdlib>
#include <climits>
#include <cerrno>
#ifdef _WIN32
# include <wchar.h>
#endif
// TBD: There is a race when multiple threads try to initialize the
// user_settable_values??
//
// Set to true if the user settable values portion of the global state
// singleton is initialized, even if the rest of the singleton is not
// initialized.
int cilkg_user_settable_values_initialized = false;
namespace {
// Single copy of the global state. Zero-filled until
// cilkg_get_user_settable_values() is called and partially-zero-filled until
// cilkg_init_global_state() is called. The first field is filled in with
// the size of a void* for the debugger and must be valid before initialization
global_state_t global_state_singleton =
{
sizeof(void *), // addr_size
};
// Variables that need to export C-style names
extern "C"
{
// Pointer to the global state singleton.
global_state_t *cilkg_singleton_ptr = NULL;
// __cilkrts_global_state is exported and referenced by the debugger.
// The debugger expects it to be valid when the module loads.
// CILK_EXPORT_DATA
global_state_t *__cilkrts_global_state = &global_state_singleton;
}
// Returns true if 'a' and 'b' are equal null-terminated strings
inline bool strmatch(const char* a, const char* b)
{
return 0 == std::strcmp(a, b);
}
// Returns the integer value represented by the null-terminated string at 's'.
inline long to_long(const char* s)
{
char *end;
errno = 0;
return std::strtol(s, &end, 0);
}
#ifdef _WIN32
// Returns true if 'a' and 'b' are equal null-terminated wide-char strings
inline bool strmatch(const wchar_t* a, const wchar_t* b)
{
return 0 == wcscmp(a, b);
}
// Returns true if the multi-byte character string at 'a' represents the same
// character sequence as the wide-character string at 'b'. The behavior is
// undefined if 'a' contains more than 30 multi-byte characters.
bool strmatch(const char* a, const wchar_t* b)
{
// Convert 'a' to wide-characters, then compare.
wchar_t wa[31];
std::size_t count;
errno_t err = mbstowcs_s(&count, wa, a, 30);
CILK_ASSERT(0 == err);
if (err) return false;
return strmatch(wa, b);
}
// Returns true if the wide-character string at 'a' represents the same
// character sequence as the multi-byte character string at 'b'. The behavior
// id undefined if 'b' contains more than 30 multi-byte characters.
inline
bool strmatch(const wchar_t* a, const char* b)
{
return strmatch(b, a);
}
// Returns the integer value represented by the null-terminated wide-char
// string at 's'.
inline long to_long(const wchar_t* s)
{
wchar_t *end;
errno = 0;
return wcstol(s, &end, 0);
}
#endif
// Check if Cilkscreen or other sequential ptool wants to force reducers.
bool always_force_reduce()
{
// Metacall *looks* like a no-op. volatile needed to keep compiler from
// optimizing away variable.
volatile char not_force_reduce = '\377';
__cilkrts_metacall(METACALL_TOOL_SYSTEM, HYPER_ZERO_IF_FORCE_REDUCE,
const_cast<char*>(&not_force_reduce));
return ! not_force_reduce;
}
// Stores the boolean value represented by the null-terminated string at 'val'
// into the integer object at 'out'. Returns '__CILKRTS_SET_PARAM_SUCCESS' if
// 'val' is "true", "false", "0" or "1" and '__CILKRTS_SET_PARAM_INVALID'
// otherwise.
template <typename INT_T, typename CHAR_T>
int store_bool(INT_T *out, const CHAR_T *val)
{
static const char* const s_zero = "0";
static const char* const s_one = "1";
static const char* const s_true = "true";
static const char* const s_false = "false";
if (val == 0)
return __CILKRTS_SET_PARAM_INVALID;
if (strmatch(s_false, val) || strmatch(s_zero, val)) {
*out = 0;
return __CILKRTS_SET_PARAM_SUCCESS;
}
if (strmatch(s_true, val) || strmatch(s_one, val)) {
*out = 1;
return __CILKRTS_SET_PARAM_SUCCESS;
}
return __CILKRTS_SET_PARAM_INVALID;
}
// Stores the integer value represented by the null-terminated string at 'val'
// into the integer object at 'out', restricting the result to the range 'min'
// to 'max', inclusive. Returns '__CILKRTS_SET_PARAM_SUCCESS' if the conversion
// succeeds and is in range, '__CILKRTS_SET_PARAM_XRANGE' if the conversion
// succeeds but is out of range, and '__CILKRTS_SET_PARAM_INVALID' otherwise. In
// the case of any error, '*out' is unchanged.
template <typename INT_T, typename CHAR_T>
int store_int(INT_T *out, const CHAR_T *val, INT_T min, INT_T max)
{
errno = 0;
long val_as_long = to_long(val);
if (val_as_long == 0 && errno != 0)
return __CILKRTS_SET_PARAM_INVALID;
if (val_as_long < min || val_as_long == LONG_MIN)
return __CILKRTS_SET_PARAM_XRANGE;
else if (val_as_long > max || val_as_long == LONG_MAX)
return __CILKRTS_SET_PARAM_XRANGE;
*out = val_as_long;
return __CILKRTS_SET_PARAM_SUCCESS;
}
// Implementaton of cilkg_set_param templatized on character type.
// Windows will instantiate with both char and wchar_t.
// Note that g must have its user settable values set, but need not be fully
// initialized.
template <class CHAR_T>
int set_param_imp(global_state_t* g, const CHAR_T* param, const CHAR_T* value)
{
static const char* const s_force_reduce = "force reduce";
static const char* const s_nworkers = "nworkers";
static const char* const s_max_user_workers = "max user workers";
static const char* const s_local_stacks = "local stacks";
static const char* const s_shared_stacks = "shared stacks";
static const char* const s_nstacks = "nstacks";
static const char* const s_stack_size = "stack size";
// We must have a parameter and a value
if (0 == param)
return __CILKRTS_SET_PARAM_INVALID;
if (0 == value)
return __CILKRTS_SET_PARAM_INVALID;
if (strmatch(param, s_force_reduce))
{
// Sets whether we force a reduce operation at every sync. Useful for
// debugging reducers. Off by default. Overridden by Cilkscreen
//
// Documented in cilk_api_<os>.h
if (always_force_reduce())
// Force reduce is set by cilkscreen. User cannot change it.
return __CILKRTS_SET_PARAM_LATE;
return store_bool(&g->force_reduce, value);
}
else if (strmatch(param, s_nworkers))
{
// Set the total number of workers. Overrides count of cores we get
// from the OS and the setting of the CILK_NWORKERS environment
// variable. Setting to 0 indicates that the default worker count
// should be used.
//
// Documented in cilk_api_<os>.h
if (cilkg_singleton_ptr)
return __CILKRTS_SET_PARAM_LATE;
// Fetch the number of cores. There must be at last 1, since we're
// executing on *something*, aren't we!?
int hardware_cpu_count = __cilkrts_hardware_cpu_count();
CILK_ASSERT(hardware_cpu_count > 0);
int max_cpu_count = 16 * hardware_cpu_count;
if (__cilkrts_running_under_sequential_ptool())
{
hardware_cpu_count = 1;
max_cpu_count = 1;
}
// Allow a value of 0, which means "set to hardware thread count".
int ret = store_int(&g->P, value, 0, max_cpu_count);
if (0 == g->P)
g->P = hardware_cpu_count;
return ret;
}
else if (strmatch(param, s_max_user_workers))
{
// ** UNDOCUMENTED **
//
// Sets the number of slots allocated for user worker threads
int hardware_cpu_count = __cilkrts_hardware_cpu_count();
CILK_ASSERT (hardware_cpu_count > 0);
return store_int(&g->max_user_workers, value, 1,
16 * hardware_cpu_count);
}
else if (strmatch(param, s_local_stacks))
{
// ** UNDOCUMENTED **
//
// Number of stacks we'll hold in the per-worker stack cache. Maximum
// value is 42. See __cilkrts_make_global_state for details.
return store_int(&g->fiber_pool_size, value, 0, 42);
}
else if (strmatch(param, s_shared_stacks))
{
// ** UNDOCUMENTED **
//
// Maximum number of stacks we'll hold in the global stack
// cache. Maximum value is 42. See __cilkrts_make_global_state for
// details.
return store_int(&g->global_fiber_pool_size, value, 0, 42);
}
else if (strmatch(param, s_nstacks))
{
// Sets the maximum number of stacks permitted at one time. If the
// runtime reaches this maximum, it will cease to allocate stacks and
// the app will lose parallelism. 0 means unlimited. Default is
// unlimited. Minimum is twice the number of worker threads, though
// that cannot be tested at this time.
//
// Undocumented at this time, though there are plans to expose it.
// The current implentation is for Linux debugging only and is not
// robust enough for users.
if (cilkg_singleton_ptr)
return __CILKRTS_SET_PARAM_LATE;
return store_int<unsigned>(&g->max_stacks, value, 0, INT_MAX);
}
else if (strmatch(param, s_stack_size))
{
// ** UNDOCUMENTED **
//
// Sets the size (in bytes) of the stacks that Cilk creates.
// Can only be set before the runtime starts.
if (cilkg_singleton_ptr)
return __CILKRTS_SET_PARAM_LATE;
// Maximum value that can be parsed is MAX_INT (32-bit).
int ret = store_int<size_t>(&g->stack_size, value, 0, INT_MAX);
// Process the value the user set (or 0 if the user didn't set
// anything) into something nice for the current OS. This
// processing is done immediately and stored into
// g->stack_size so that a call to get stack size will return
// the value that the runtime will actually use.
g->stack_size = cilkos_validate_stack_size(g->stack_size);
return ret;
}
// If got here, then didn't match any of the strings
return __CILKRTS_SET_PARAM_UNIMP;
}
inline
int calc_max_user_workers(global_state_t *g)
{
// If it's been set by the user, give back what we got
if (g->max_user_workers > 0)
return g->max_user_workers;
// Calculate it
return std::max(3, g->P * 2);
}
} // end unnamed namespace
__CILKRTS_BEGIN_EXTERN_C
/**
* @brief Returns the global state object. If called for the first time,
* initializes the user-settable values in the global state, but does not
* initialize the rest of the structure.
*/
global_state_t* cilkg_get_user_settable_values()
{
// Environment variable value. More than big enough for a 64-bit signed
// integer.
char envstr[24];
// Abbreviating &global_state_singleton as g is not only shorter, it also
// facilitates grepping for the string "g->", which appears ubiquitously
// in the runtime code.
global_state_t* g = &global_state_singleton;
// TBD: We need synchronization around this loop to prevent
// multiple threads from initializing this data.
if (! cilkg_user_settable_values_initialized)
{
size_t len;
// Preserve stealing disabled since it may have been set by the
// debugger
int stealing_disabled = g->stealing_disabled;
// All fields will be zero until set. In particular
std::memset(g, 0, sizeof(global_state_t));
// Fetch the number of cores. There must be at last 1, since we're
// executing on *something*, aren't we!?
int hardware_cpu_count = __cilkrts_hardware_cpu_count();
CILK_ASSERT(hardware_cpu_count > 0);
bool under_ptool = __cilkrts_running_under_sequential_ptool();
if (under_ptool)
hardware_cpu_count = 1;
g->stealing_disabled = stealing_disabled;
g->under_ptool = under_ptool;
g->force_reduce = 0; // Default Off
g->P = hardware_cpu_count; // Defaults to hardware CPU count
g->max_user_workers = 0; // 0 unless set by user
g->fiber_pool_size = 7; // Arbitrary default
g->global_fiber_pool_size = 3 * 3* g->P; // Arbitrary default
// 3*P was the default size of the worker array (including
// space for extra user workers). This parameter was chosen
// to match previous versions of the runtime.
if (4 == sizeof(void *))
g->max_stacks = 1200; // Only 1GB on 32-bit machines
else
g->max_stacks = 2400; // 2GB on 64-bit machines
// If we have 2400 1MB stacks, that is 2 gb. If we reach this
// limit on a single-socket machine, we may have other
// problems. Is 2400 too small for large multicore machines?
// TBD(jsukha, 11/27/2012): I set this limit on stacks to be a
// value independent of P. When running on a Xeon Phi with
// small values of P, I recall seeing a few microbenchmarks
// (e.g., fib) where a limit of 10*P seemed to be
// unnecessarily slowing things down.
//
// That being said, the code has changed sufficiently that
// this observation may no longer be true.
//
// Note: in general, the worst-case number of stacks required
// for a Cilk computation with spawn depth "d" on P workers is
// O(Pd). Code with unbalanced recursion may run into issues
// with this stack usage.
g->max_steal_failures = 128; // TBD: depend on max_workers?
g->stack_size = 0; // 0 unless set by the user
// Assume no record or replay log for now
g->record_replay_file_name = NULL;
g->record_or_replay = RECORD_REPLAY_NONE; // set by user
if (always_force_reduce())
g->force_reduce = true;
else if (cilkos_getenv(envstr, sizeof(envstr), "CILK_FORCE_REDUCE"))
store_bool(&g->force_reduce, envstr);
if (under_ptool)
g->P = 1; // Ignore environment variable if under cilkscreen
else if (cilkos_getenv(envstr, sizeof(envstr), "CILK_NWORKERS"))
// Set P to environment variable, but limit to no less than 1
// and no more than 16 times the number of hardware threads.
store_int(&g->P, envstr, 1, 16 * hardware_cpu_count);
if (cilkos_getenv(envstr, sizeof(envstr), "CILK_MAX_USER_WORKERS"))
// Set max_user_workers to environment variable, but limit to no
// less than 1 and no more 16 times the number of hardware
// threads. If not specified, defaults (somewhat arbitrarily) to
// the larger of 3 and twice the number of hardware threads.
store_int(&g->max_user_workers, envstr, 1, 16*hardware_cpu_count);
if (cilkos_getenv(envstr, sizeof(envstr), "CILK_STEAL_FAILURES"))
// Set the number of times a worker should fail to steal before
// it looks to see whether it should suspend itself.
store_int<unsigned>(&g->max_steal_failures, envstr, 1, INT_MAX);
// Compute the total number of workers to allocate. Subtract one from
// nworkers and user workers so that the first user worker isn't
// factored in twice.
//
// total_workers must be computed now to support __cilkrts_get_total_workers
g->total_workers = g->P + calc_max_user_workers(g) - 1;
#ifdef CILK_RECORD_REPLAY
// RecordReplay: See if we've been asked to replay a log
len = cilkos_getenv(envstr, 0, "CILK_REPLAY_LOG");
if (len > 0)
{
len += 1; // Allow for trailing NUL
g->record_or_replay = REPLAY_LOG;
g->record_replay_file_name = (char *)__cilkrts_malloc(len);
cilkos_getenv(g->record_replay_file_name, len, "CILK_REPLAY_LOG");
}
// RecordReplay: See if we've been asked to record a log
len = cilkos_getenv(envstr, 0, "CILK_RECORD_LOG");
if (len > 0)
{
if (RECORD_REPLAY_NONE != g->record_or_replay)
cilkos_warning("CILK_RECORD_LOG ignored since CILK_REPLAY_LOG is defined.\n");
else
{
len += 1; // Allow for trailing NUL
g->record_or_replay = RECORD_LOG;
g->record_replay_file_name = (char *)__cilkrts_malloc(len);
cilkos_getenv(g->record_replay_file_name, len, "CILK_RECORD_LOG");
}
}
#endif
cilkg_user_settable_values_initialized = true;
}
return g;
}
int cilkg_calc_total_workers()
{
global_state_t* g = cilkg_get_user_settable_values();
// Compute the total number of workers to allocate. Subtract one from
// nworkers and user workers so that the first user worker isn't
// factored in twice.
return g->P + calc_max_user_workers(g) - 1;
}
// Should be called while holding the global lock.
global_state_t* cilkg_init_global_state()
{
if (cilkg_singleton_ptr)
return cilkg_singleton_ptr;
// Get partially-initialized global state.
global_state_t* g = cilkg_get_user_settable_values();
if (g->max_stacks > 0) {
// nstacks is currently honored on non-Windows systems only.
// Set an upper bound on the number of stacks that are allocated. If
// nstacks is set, each worker gets up to one stack in its cache so that
// no one worker can hog all of the free stacks and keep work from being
// stolen by the other workers.
// nstacks corresponds to the number of stacks that will be allocated by
// the runtime apart from the initial stack created for each thread by
// the system. Therefore, if a user asks for n stacks, and there are
// p workers created, the total number of stacks is actually n + p.
// This feature is primarily for MIC which has flat memory
// instead of virtual addresses and tends to run out really quickly.
// It is not implemented for Windows and it's non-intuitive
// interaction with the local stack cache is specifically to help out
// MIC.
// About max_stacks / P stacks, except we require at least 1
// per pool.
if (((int)g->max_stacks / g->P) < g->fiber_pool_size)
g->fiber_pool_size = g->max_stacks / g->P;
if (g->fiber_pool_size <= 0) {
g->fiber_pool_size = 1;
}
if ((int)g->max_stacks < g->P)
g->max_stacks = g->P;
g->global_fiber_pool_size = g->P * (g->fiber_pool_size+1);
}
// Number of bytes/address - validation for debugger integration
g->addr_size = sizeof(void *);
__cilkrts_init_stats(&g->stats);
__cilkrts_frame_malloc_global_init(g);
g->Q = 0;
g->total_workers = cilkg_calc_total_workers();
g->system_workers = g->P - 1; // system_workers is here for the debugger.
g->work_done = 0;
g->workers_running = 0;
g->ltqsize = 1024; /* FIXME */
g->stack_size = cilkos_validate_stack_size(g->stack_size);
g->failure_to_allocate_stack = 0;
return g;
}
void cilkg_publish_global_state(global_state_t* g)
{
// TBD: which one of these needs to be executed first? I say
// cilkg_singleton_ptr needs to be set last, with a mfence in
// between, since it is the flag that cilkg_is_published_is
// checking for.
__cilkrts_global_state = g;
__cilkrts_fence();
cilkg_singleton_ptr = g;
}
void cilkg_deinit_global_state()
{
cilkg_singleton_ptr = NULL;
__cilkrts_global_state = NULL;
}
int cilkg_is_published(void)
{
return NULL != cilkg_singleton_ptr;
}
int cilkg_set_param(const char* param, const char* value)
{
return set_param_imp(cilkg_get_user_settable_values(), param, value);
}
#ifdef _WIN32
int cilkg_set_param_w(const wchar_t* param, const wchar_t* value)
{
return set_param_imp(cilkg_get_user_settable_values(), param, value);
}
#endif
extern "C++" {
// C++ scheduler function (that may throw exceptions)
typedef void cpp_scheduler_t(__cilkrts_worker *w);
}
void __cilkrts_run_scheduler_with_exceptions(__cilkrts_worker *w)
{
global_state_t* g = cilkg_get_global_state();
CILK_ASSERT(g->scheduler);
cpp_scheduler_t* scheduler = (cpp_scheduler_t*) g->scheduler;
try {
scheduler(w);
} catch (...) {
__cilkrts_bug("Exception escaped Cilk context");
}
}
__CILKRTS_END_EXTERN_C
/* End global_state.cpp */