From 148dd57e8207ebd8cd9bed23d9308c2f348077a7 Mon Sep 17 00:00:00 2001 From: Nathan Hjelm Date: Wed, 18 May 2016 16:00:31 -0600 Subject: [PATCH 1/4] bml/r2: always add btl progress function This commit changes the behavior of bml/r2 from conditionally registering btl progress functions to always registering progress functions. Any progress function beloning to a btl that is not yet in use is registered as low-priority. As soon as a proc is added that will make use of the btl is is re-registered normally. This works around an issue with some btls. In order to progress a first message from an unknown peer both ugni and openib need to have their progress functions called. If either btl is not in use after the first call to add_procs the callback was never happening. This commit ensures the btl progress function is called at some point but the number of progress callbacks is reduced from normal to ensure lower overhead when a btl is not used. The current ratio is 1 low priority progress callback for every 8 calls to opal_progress(). Fixes open-mpi/ompi#1676 Signed-off-by: Nathan Hjelm (cherry picked from commit open-mpi/ompi@a679cc072b9458957671886062c643f6a40b0351) --- ompi/mca/bml/r2/bml_r2.c | 26 +++++++---- opal/runtime/opal_progress.c | 88 ++++++++++++++++++++++++++++++------ opal/runtime/opal_progress.h | 2 + 3 files changed, 93 insertions(+), 23 deletions(-) diff --git a/ompi/mca/bml/r2/bml_r2.c b/ompi/mca/bml/r2/bml_r2.c index 886c43becb..1b6ba0129c 100644 --- a/ompi/mca/bml/r2/bml_r2.c +++ b/ompi/mca/bml/r2/bml_r2.c @@ -165,22 +165,30 @@ static mca_bml_base_endpoint_t *mca_bml_r2_allocate_endpoint (ompi_proc_t *proc) return bml_endpoint; } -static void mca_bml_r2_register_progress (mca_btl_base_module_t *btl) +static void mca_bml_r2_register_progress (mca_btl_base_module_t *btl, bool hp) { if (NULL != btl->btl_component->btl_progress) { bool found = false; + size_t p; - for (size_t p = 0 ; p < mca_bml_r2.num_btl_progress ; ++p) { + for (p = 0 ; p < mca_bml_r2.num_btl_progress ; ++p) { if(mca_bml_r2.btl_progress[p] == btl->btl_component->btl_progress) { found = true; break; } } - if (found == false) { - mca_bml_r2.btl_progress[mca_bml_r2.num_btl_progress++] = - btl->btl_component->btl_progress; - opal_progress_register (btl->btl_component->btl_progress); + if (found == false || hp) { + if (found == false) { + mca_bml_r2.btl_progress[mca_bml_r2.num_btl_progress++] = + btl->btl_component->btl_progress; + } + + if (hp) { + opal_progress_register (btl->btl_component->btl_progress); + } else { + opal_progress_register_lp (btl->btl_component->btl_progress); + } } } } @@ -403,7 +411,7 @@ static int mca_bml_r2_add_proc (struct ompi_proc_t *proc) if (OMPI_SUCCESS != rc) { btl->btl_del_procs (btl, 1, (opal_proc_t **) &proc, &btl_endpoint); } else { - mca_bml_r2_register_progress (btl); + mca_bml_r2_register_progress (btl, true); btl_in_use = true; } } @@ -546,9 +554,7 @@ static int mca_bml_r2_add_procs( size_t nprocs, btl_inuse++; } - if (btl_inuse) { - mca_bml_r2_register_progress (btl); - } + mca_bml_r2_register_progress (btl, !!(btl_inuse)); } free(btl_endpoints); diff --git a/opal/runtime/opal_progress.c b/opal/runtime/opal_progress.c index aa2e713336..f418d086b8 100644 --- a/opal/runtime/opal_progress.c +++ b/opal/runtime/opal_progress.c @@ -10,7 +10,7 @@ * University of Stuttgart. All rights reserved. * Copyright (c) 2004-2005 The Regents of the University of California. * All rights reserved. - * Copyright (c) 2006-2014 Los Alamos National Security, LLC. All rights + * Copyright (c) 2006-2016 Los Alamos National Security, LLC. All rights * reserved. * Copyright (c) 2015-2016 Research Organization for Information Science * and Technology (RIST). All rights reserved. @@ -59,6 +59,10 @@ static opal_progress_callback_t *callbacks = NULL; static size_t callbacks_len = 0; static size_t callbacks_size = 0; +static opal_progress_callback_t *callbacks_lp = NULL; +static size_t callbacks_lp_len = 0; +static size_t callbacks_lp_size = 0; + /* do we want to call sched_yield() if nothing happened */ bool opal_progress_yield_when_idle = false; @@ -151,6 +155,7 @@ opal_progress_finalize(void) void opal_progress(void) { + static volatile uint64_t num_calls = 0; size_t i; int events = 0; @@ -189,6 +194,13 @@ opal_progress(void) events += (callbacks[i])(); } + if ((OPAL_THREAD_ADD64((volatile int64_t *) &num_calls, 1) & 0x7) == 0) { + /* run low priority callbacks once every 8 calls to opal_progress() */ + for (i = 0 ; i < callbacks_lp_len ; ++i) { + events += (callbacks_lp[i])(); + } + } + #if OPAL_HAVE_SCHED_YIELD if (opal_progress_yield_when_idle && events <= 0) { /* If there is nothing to do - yield the processor - otherwise @@ -317,6 +329,9 @@ opal_progress_register(opal_progress_callback_t cb) int ret = OPAL_SUCCESS; size_t index; + /* just in case there is a low-priority callback remove it */ + (void) opal_progress_unregister (cb); + opal_atomic_lock(&progress_lock); /* see if we need to allocate more space */ @@ -345,17 +360,53 @@ opal_progress_register(opal_progress_callback_t cb) return ret; } -int -opal_progress_unregister(opal_progress_callback_t cb) +int opal_progress_register_lp (opal_progress_callback_t cb) +{ + int ret = OPAL_SUCCESS; + size_t index; + + /* just in case there is a high-priority callback remove it */ + (void) opal_progress_unregister (cb); + + opal_atomic_lock(&progress_lock); + + /* see if we need to allocate more space */ + if (callbacks_lp_len + 1 > callbacks_lp_size) { + opal_progress_callback_t *tmp; + tmp = (opal_progress_callback_t*)realloc(callbacks_lp, sizeof(opal_progress_callback_t) * (callbacks_lp_size + 4)); + if (tmp == NULL) { + ret = OPAL_ERR_TEMP_OUT_OF_RESOURCE; + goto cleanup; + } + /* registering fake callbacks_lp to fill callbacks_lp[] */ + for( index = callbacks_lp_len + 1 ; index < callbacks_lp_size + 4 ; index++) { + tmp[index] = &fake_cb; + } + + callbacks_lp = tmp; + callbacks_lp_size += 4; + } + + callbacks_lp[callbacks_lp_len++] = cb; + + cleanup: + + opal_atomic_unlock(&progress_lock); + + return ret; +} + +static int _opal_progress_unregister (opal_progress_callback_t cb, opal_progress_callback_t *callback_array, + size_t callback_array_len) { size_t i; int ret = OPAL_ERR_NOT_FOUND; opal_atomic_lock(&progress_lock); - for (i = 0 ; i < callbacks_len ; ++i) { - if (cb == callbacks[i]) { - callbacks[i] = &fake_cb; + for (i = 0 ; i < callback_array_len ; ++i) { + if (cb == callback_array[i]) { + callback_array[i] = &fake_cb; ret = OPAL_SUCCESS; break; } @@ -367,17 +418,28 @@ opal_progress_unregister(opal_progress_callback_t cb) do any repacking. size_t can be unsigned, so 0 - 1 is bad for a loop condition :). */ if (OPAL_SUCCESS == ret) { - if (callbacks_len > 1 ) { - /* now tightly pack the array */ - for ( ; i < callbacks_len - 1 ; ++i) { - callbacks[i] = callbacks[i + 1]; - } + if (i < callback_array_len - 1) { + memmove (callback_array + i, callback_array + i + 1, + (callback_array_len - i - 1) * sizeof (callback_array[0])); } - callbacks[callbacks_len - 1] = &fake_cb; - callbacks_len--; + + callback_array[callback_array_len - 1] = &fake_cb; + callback_array_len--; } opal_atomic_unlock(&progress_lock); return ret; } + +int opal_progress_unregister (opal_progress_callback_t cb) +{ + int ret = _opal_progress_unregister (cb, callbacks, callbacks_len); + if (OPAL_SUCCESS != ret) { + /* if not in the high-priority array try to remove from the lp array. + * a callback will never be in both. */ + return _opal_progress_unregister (cb, callbacks_lp, callbacks_lp_len); + } + + return ret; +} diff --git a/opal/runtime/opal_progress.h b/opal/runtime/opal_progress.h index 0a27365d9e..5badbd5a45 100644 --- a/opal/runtime/opal_progress.h +++ b/opal/runtime/opal_progress.h @@ -163,6 +163,8 @@ typedef int (*opal_progress_callback_t)(void); */ OPAL_DECLSPEC int opal_progress_register(opal_progress_callback_t cb); +OPAL_DECLSPEC int opal_progress_register_lp (opal_progress_callback_t cb); + /** * Deregister previously registered event From 84ea9886f4d4933dd9e5519ccd742106ec051f3b Mon Sep 17 00:00:00 2001 From: Nathan Hjelm Date: Tue, 24 May 2016 15:08:46 -0600 Subject: [PATCH 2/4] opal_progress: add a MCA variable to control lp progress This commit adds a MCA variable to control how often low-priority callbacks are made relative to high-priority callbacks. This was added per discussion on telcon on May 24, 2016. Signed-off-by: Nathan Hjelm --- opal/runtime/opal_params.c | 23 ++++++++++++++++++++++- opal/runtime/opal_params.h | 6 ++++++ opal/runtime/opal_progress.c | 5 ++++- 3 files changed, 32 insertions(+), 2 deletions(-) diff --git a/opal/runtime/opal_params.c b/opal/runtime/opal_params.c index 837e170560..eef66a253b 100644 --- a/opal/runtime/opal_params.c +++ b/opal/runtime/opal_params.c @@ -14,7 +14,7 @@ * reserved. * Copyright (c) 2008-2015 Cisco Systems, Inc. All rights reserved. * Copyright (c) 2009 Oak Ridge National Labs. All rights reserved. - * Copyright (c) 2010-2015 Los Alamos National Security, LLC. + * Copyright (c) 2010-2016 Los Alamos National Security, LLC. * All rights reserved. * Copyright (c) 2014 Hochschule Esslingen. All rights reserved. * Copyright (c) 2015 Research Organization for Information Science @@ -45,6 +45,7 @@ #include "opal/dss/dss.h" #include "opal/util/show_help.h" #include "opal/util/timings.h" +#include "opal/util/bit_ops.h" char *opal_signal_string = NULL; char *opal_net_private_ipv4 = NULL; @@ -66,6 +67,7 @@ int opal_leave_pinned = -1; bool opal_leave_pinned_pipeline = false; bool opal_abort_print_stack = false; int opal_abort_delay = 0; +unsigned int opal_progress_lp_call_ratio = 8; static bool opal_register_done = false; @@ -279,6 +281,25 @@ int opal_register_params(void) return ret; } + opal_progress_lp_call_ratio = 8; + ret = mca_base_var_register("opal", "opal", NULL, "progress_lp_call_ratio", + "Ratio of calls to high-priority to low-priority progress " + "functions. Higher numbers decrease the frequency of the callback " + "rate. Must be a power of two (default: 8)", + MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, 0, + OPAL_INFO_LVL_5, + MCA_BASE_VAR_SCOPE_READONLY, + &opal_progress_lp_call_ratio); + if (0 > ret) { + return ret; + } + + if (opal_progress_lp_call_ratio & (opal_progress_lp_call_ratio - 1)) { + opal_output(0, "MCA variable progress_lp_call_ratio must be a power of two. value = %u", + opal_progress_lp_call_ratio); + return OPAL_ERR_BAD_PARAM; + } + opal_abort_print_stack = false; ret = mca_base_var_register("opal", "opal", NULL, "abort_print_stack", "If nonzero, print out a stack trace when abort is invoked", diff --git a/opal/runtime/opal_params.h b/opal/runtime/opal_params.h index 1ac387195b..b8d135ffc1 100644 --- a/opal/runtime/opal_params.h +++ b/opal/runtime/opal_params.h @@ -73,6 +73,12 @@ OPAL_DECLSPEC extern bool opal_abort_print_stack; */ OPAL_DECLSPEC extern int opal_abort_delay; +/** + * Ratio of calls to high-priority to low-priority progress functions. + * Must be a power of two. + */ +OPAL_DECLSPEC extern unsigned int opal_progress_lp_call_ratio; + #if OPAL_ENABLE_DEBUG extern bool opal_progress_debug; #endif diff --git a/opal/runtime/opal_progress.c b/opal/runtime/opal_progress.c index f418d086b8..95867261d1 100644 --- a/opal/runtime/opal_progress.c +++ b/opal/runtime/opal_progress.c @@ -62,6 +62,7 @@ static size_t callbacks_size = 0; static opal_progress_callback_t *callbacks_lp = NULL; static size_t callbacks_lp_len = 0; static size_t callbacks_lp_size = 0; +static uint64_t callbacks_lp_mask = 0x7; /* do we want to call sched_yield() if nothing happened */ bool opal_progress_yield_when_idle = false; @@ -109,6 +110,8 @@ opal_progress_init(void) } #endif + callbacks_lp_mask = opal_progress_lp_call_ratio - 1; + OPAL_OUTPUT((debug_output, "progress: initialized event flag to: %x", opal_progress_event_flag)); OPAL_OUTPUT((debug_output, "progress: initialized yield_when_idle to: %s", @@ -194,7 +197,7 @@ opal_progress(void) events += (callbacks[i])(); } - if ((OPAL_THREAD_ADD64((volatile int64_t *) &num_calls, 1) & 0x7) == 0) { + if ((OPAL_THREAD_ADD64((volatile int64_t *) &num_calls, 1) & callbacks_lp_mask) == 0) { /* run low priority callbacks once every 8 calls to opal_progress() */ for (i = 0 ; i < callbacks_lp_len ; ++i) { events += (callbacks_lp[i])(); From 3e6bc08503cbcbdde5e4beb16fcc113c91def1d6 Mon Sep 17 00:00:00 2001 From: Nathan Hjelm Date: Tue, 31 May 2016 12:17:26 -0600 Subject: [PATCH 3/4] opal/progress: make progress function registration mt safe This commit fixes a bug in opal progress registration that can cause crashes when a progress function is registered while another thread is in opal_progress(). Before this commit realloc is used to allocate more space for progress functions but it is possible for a thread in opal_progress() to try to read from the array that is freed by realloc before the array is re-assigned when realloc returns. To prevent this race use malloc + memcpy to fill the new array and atomically swap out the old and new array pointers. Per suggestion we now allocate a default of 8 slots for callbacks and double the current number when we run out of space. This commit also fixes leaking the callbacks_lp array. Signed-off-by: Nathan Hjelm (cherry picked from open-mpi/ompi@2fad3b9bc66e4e78f699e963bdc296cda88cbc8f) Signed-off-by: Nathan Hjelm --- opal/runtime/opal_progress.c | 187 +++++++++++++++++++++-------------- 1 file changed, 112 insertions(+), 75 deletions(-) diff --git a/opal/runtime/opal_progress.c b/opal/runtime/opal_progress.c index 95867261d1..42c31c28be 100644 --- a/opal/runtime/opal_progress.c +++ b/opal/runtime/opal_progress.c @@ -55,11 +55,11 @@ int opal_progress_spin_count = 10000; static opal_atomic_lock_t progress_lock; /* callbacks to progress */ -static opal_progress_callback_t *callbacks = NULL; +static volatile opal_progress_callback_t *callbacks = NULL; static size_t callbacks_len = 0; static size_t callbacks_size = 0; -static opal_progress_callback_t *callbacks_lp = NULL; +static volatile opal_progress_callback_t *callbacks_lp = NULL; static size_t callbacks_lp_len = 0; static size_t callbacks_lp_size = 0; static uint64_t callbacks_lp_mask = 0x7; @@ -94,6 +94,9 @@ static int debug_output = -1; */ static int fake_cb(void) { return 0; } +static int _opal_progress_unregister (opal_progress_callback_t cb, opal_progress_callback_t *callback_array, + size_t *callback_array_len); + /* init the progress engine - called from orte_init */ int opal_progress_init(void) @@ -110,8 +113,30 @@ opal_progress_init(void) } #endif + callbacks_lp_mask = opal_progress_lp_call_ratio - 1; + callbacks_size = callbacks_lp_size = 8; + + callbacks = malloc (callbacks_size * sizeof (callbacks[0])); + callbacks_lp = malloc (callbacks_lp_size * sizeof (callbacks_lp[0])); + + if (NULL == callbacks || NULL == callbacks_lp) { + free (callbacks); + free (callbacks_lp); + callbacks_size = callbacks_lp_size = 0; + callbacks = callbacks_lp = NULL; + return OPAL_ERR_OUT_OF_RESOURCE; + } + + for (size_t i = 0 ; i < callbacks_size ; ++i) { + callbacks[i] = fake_cb; + } + + for (size_t i = 0 ; i < callbacks_lp_size ; ++i) { + callbacks_lp[i] = fake_cb; + } + OPAL_OUTPUT((debug_output, "progress: initialized event flag to: %x", opal_progress_event_flag)); OPAL_OUTPUT((debug_output, "progress: initialized yield_when_idle to: %s", @@ -133,10 +158,13 @@ opal_progress_finalize(void) callbacks_len = 0; callbacks_size = 0; - if (NULL != callbacks) { - free(callbacks); - callbacks = NULL; - } + free(callbacks); + callbacks = NULL; + + callbacks_lp_len = 0; + callbacks_lp_size = 0; + free(callbacks_lp); + callbacks_lp = NULL; opal_atomic_unlock(&progress_lock); @@ -325,38 +353,73 @@ opal_progress_set_event_poll_rate(int polltime) #endif } +static int opal_progress_find_cb (opal_progress_callback_t cb, opal_progress_callback_t *cbs, + size_t cbs_len) +{ + for (size_t i = 0 ; i < cbs_len ; ++i) { + if (cbs[i] == cb) { + return (int) i; + } + } + + return OPAL_ERR_NOT_FOUND; +} -int -opal_progress_register(opal_progress_callback_t cb) +static int _opal_progress_register (opal_progress_callback_t cb, opal_progress_callback_t **cbs, + size_t *cbs_size, size_t *cbs_len) { int ret = OPAL_SUCCESS; - size_t index; - - /* just in case there is a low-priority callback remove it */ - (void) opal_progress_unregister (cb); - opal_atomic_lock(&progress_lock); + if (OPAL_ERR_NOT_FOUND != opal_progress_find_cb (cb, *cbs, *cbs_len)) { + return OPAL_SUCCESS; + } /* see if we need to allocate more space */ - if (callbacks_len + 1 > callbacks_size) { - opal_progress_callback_t *tmp; - tmp = (opal_progress_callback_t*)realloc(callbacks, sizeof(opal_progress_callback_t) * (callbacks_size + 4)); + if (*cbs_len + 1 > *cbs_size) { + opal_progress_callback_t *tmp, *old; + + tmp = (opal_progress_callback_t *) malloc (sizeof (tmp[0]) * 2 * *cbs_size); if (tmp == NULL) { - ret = OPAL_ERR_TEMP_OUT_OF_RESOURCE; - goto cleanup; + return OPAL_ERR_TEMP_OUT_OF_RESOURCE; + } + + if (*cbs) { + /* copy old callbacks */ + memcpy (tmp, *cbs, sizeof(tmp[0]) * *cbs_size); } - /* registering fake callbacks to fill callbacks[] */ - for( index = callbacks_len + 1 ; index < callbacks_size + 4 ; index++) { - tmp[index] = &fake_cb; + + for (size_t i = *cbs_len ; i < 2 * *cbs_size ; ++i) { + tmp[i] = fake_cb; } - callbacks = tmp; - callbacks_size += 4; + opal_atomic_wmb (); + + /* swap out callback array */ + old = opal_atomic_swap_ptr (cbs, tmp); + + opal_atomic_wmb (); + + free (old); + *cbs_size *= 2; } - callbacks[callbacks_len++] = cb; + cbs[0][*cbs_len] = cb; + ++*cbs_len; + + opal_atomic_wmb (); - cleanup: + return ret; +} + +int opal_progress_register (opal_progress_callback_t cb) +{ + int ret; + + opal_atomic_lock(&progress_lock); + + (void) _opal_progress_unregister (cb, callbacks_lp, &callbacks_lp_len); + + ret = _opal_progress_register (cb, &callbacks, &callbacks_size, &callbacks_len); opal_atomic_unlock(&progress_lock); @@ -365,34 +428,13 @@ opal_progress_register(opal_progress_callback_t cb) int opal_progress_register_lp (opal_progress_callback_t cb) { - int ret = OPAL_SUCCESS; - size_t index; - - /* just in case there is a high-priority callback remove it */ - (void) opal_progress_unregister (cb); + int ret; opal_atomic_lock(&progress_lock); - /* see if we need to allocate more space */ - if (callbacks_lp_len + 1 > callbacks_lp_size) { - opal_progress_callback_t *tmp; - tmp = (opal_progress_callback_t*)realloc(callbacks_lp, sizeof(opal_progress_callback_t) * (callbacks_lp_size + 4)); - if (tmp == NULL) { - ret = OPAL_ERR_TEMP_OUT_OF_RESOURCE; - goto cleanup; - } - /* registering fake callbacks_lp to fill callbacks_lp[] */ - for( index = callbacks_lp_len + 1 ; index < callbacks_lp_size + 4 ; index++) { - tmp[index] = &fake_cb; - } + (void) _opal_progress_unregister (cb, callbacks, &callbacks_len); - callbacks_lp = tmp; - callbacks_lp_size += 4; - } - - callbacks_lp[callbacks_lp_len++] = cb; - - cleanup: + ret = _opal_progress_register (cb, &callbacks_lp, &callbacks_lp_size, &callbacks_lp_len); opal_atomic_unlock(&progress_lock); @@ -400,49 +442,44 @@ int opal_progress_register_lp (opal_progress_callback_t cb) } static int _opal_progress_unregister (opal_progress_callback_t cb, opal_progress_callback_t *callback_array, - size_t callback_array_len) + size_t *callback_array_len) { - size_t i; - int ret = OPAL_ERR_NOT_FOUND; - - opal_atomic_lock(&progress_lock); - - for (i = 0 ; i < callback_array_len ; ++i) { - if (cb == callback_array[i]) { - callback_array[i] = &fake_cb; - ret = OPAL_SUCCESS; - break; - } + int ret = opal_progress_find_cb (cb, callback_array, *callback_array_len); + if (OPAL_ERR_NOT_FOUND == ret) { + return ret; } /* If we found the function we're unregistering: If callbacks_len is 0, we're not goig to do anything interesting anyway, so skip. If callbacks_len is 1, it will soon be 0, so no need to - do any repacking. size_t can be unsigned, so 0 - 1 is bad for - a loop condition :). */ - if (OPAL_SUCCESS == ret) { - if (i < callback_array_len - 1) { - memmove (callback_array + i, callback_array + i + 1, - (callback_array_len - i - 1) * sizeof (callback_array[0])); - } - - callback_array[callback_array_len - 1] = &fake_cb; - callback_array_len--; + do any repacking. */ + for (size_t i = (size_t) ret ; i < *callback_array_len - 1 ; ++i) { + /* copy callbacks atomically since another thread may be in + * opal_progress(). */ + (void) opal_atomic_swap_ptr (callback_array + i, callback_array[i+1]); } - opal_atomic_unlock(&progress_lock); + callback_array[*callback_array_len] = fake_cb; + --*callback_array_len; - return ret; + return OPAL_SUCCESS; } int opal_progress_unregister (opal_progress_callback_t cb) { - int ret = _opal_progress_unregister (cb, callbacks, callbacks_len); + int ret; + + opal_atomic_lock(&progress_lock); + + ret = _opal_progress_unregister (cb, callbacks, &callbacks_len); + if (OPAL_SUCCESS != ret) { /* if not in the high-priority array try to remove from the lp array. * a callback will never be in both. */ - return _opal_progress_unregister (cb, callbacks_lp, callbacks_lp_len); + ret = _opal_progress_unregister (cb, callbacks_lp, &callbacks_lp_len); } + opal_atomic_unlock(&progress_lock); + return ret; } From 5faaa6decea59dd696f00d1cd46a9d88e5efa45c Mon Sep 17 00:00:00 2001 From: Nathan Hjelm Date: Mon, 6 Jun 2016 22:15:22 -0600 Subject: [PATCH 4/4] opal/progress: fix warnings This commit fixes several warning introduced by open-mpi/ompi@fc26d9c69f33c88ea6d07acf38aa9b19f751db28 . Signed-off-by: Nathan Hjelm (cherry picked from open-mpi/ompi@e082ed752af545f3c75c35797e56bfabd959b2fc) Signed-off-by: Nathan Hjelm --- opal/runtime/opal_progress.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/opal/runtime/opal_progress.c b/opal/runtime/opal_progress.c index 42c31c28be..76e3be9435 100644 --- a/opal/runtime/opal_progress.c +++ b/opal/runtime/opal_progress.c @@ -94,7 +94,7 @@ static int debug_output = -1; */ static int fake_cb(void) { return 0; } -static int _opal_progress_unregister (opal_progress_callback_t cb, opal_progress_callback_t *callback_array, +static int _opal_progress_unregister (opal_progress_callback_t cb, volatile opal_progress_callback_t *callback_array, size_t *callback_array_len); /* init the progress engine - called from orte_init */ @@ -122,8 +122,8 @@ opal_progress_init(void) callbacks_lp = malloc (callbacks_lp_size * sizeof (callbacks_lp[0])); if (NULL == callbacks || NULL == callbacks_lp) { - free (callbacks); - free (callbacks_lp); + free ((void *) callbacks); + free ((void *) callbacks_lp); callbacks_size = callbacks_lp_size = 0; callbacks = callbacks_lp = NULL; return OPAL_ERR_OUT_OF_RESOURCE; @@ -158,12 +158,12 @@ opal_progress_finalize(void) callbacks_len = 0; callbacks_size = 0; - free(callbacks); + free ((void *) callbacks); callbacks = NULL; callbacks_lp_len = 0; callbacks_lp_size = 0; - free(callbacks_lp); + free ((void *) callbacks_lp); callbacks_lp = NULL; opal_atomic_unlock(&progress_lock); @@ -353,7 +353,7 @@ opal_progress_set_event_poll_rate(int polltime) #endif } -static int opal_progress_find_cb (opal_progress_callback_t cb, opal_progress_callback_t *cbs, +static int opal_progress_find_cb (opal_progress_callback_t cb, volatile opal_progress_callback_t *cbs, size_t cbs_len) { for (size_t i = 0 ; i < cbs_len ; ++i) { @@ -365,7 +365,7 @@ static int opal_progress_find_cb (opal_progress_callback_t cb, opal_progress_cal return OPAL_ERR_NOT_FOUND; } -static int _opal_progress_register (opal_progress_callback_t cb, opal_progress_callback_t **cbs, +static int _opal_progress_register (opal_progress_callback_t cb, volatile opal_progress_callback_t **cbs, size_t *cbs_size, size_t *cbs_len) { int ret = OPAL_SUCCESS; @@ -385,7 +385,7 @@ static int _opal_progress_register (opal_progress_callback_t cb, opal_progress_c if (*cbs) { /* copy old callbacks */ - memcpy (tmp, *cbs, sizeof(tmp[0]) * *cbs_size); + memcpy (tmp, (void *) *cbs, sizeof(tmp[0]) * *cbs_size); } for (size_t i = *cbs_len ; i < 2 * *cbs_size ; ++i) { @@ -441,7 +441,7 @@ int opal_progress_register_lp (opal_progress_callback_t cb) return ret; } -static int _opal_progress_unregister (opal_progress_callback_t cb, opal_progress_callback_t *callback_array, +static int _opal_progress_unregister (opal_progress_callback_t cb, volatile opal_progress_callback_t *callback_array, size_t *callback_array_len) { int ret = opal_progress_find_cb (cb, callback_array, *callback_array_len);