static void lock_all_subtree(starpu_data_handle handle)
{
if (handle->nchildren == 0)
{
/* this is a leaf */
while (_starpu_spin_trylock(&handle->header_lock))
_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
}
else {
/* lock all sub-subtrees children */
unsigned child;
for (child = 0; child < handle->nchildren; child++)
{
lock_all_subtree(&handle->children[child]);
}
}
}
/* No lock is held, this acquires and releases the handle header lock */
static unsigned _starpu_attempt_to_submit_data_request(unsigned request_from_codelet,
starpu_data_handle_t handle, enum starpu_data_access_mode mode,
void (*callback)(void *), void *argcb,
struct _starpu_job *j, unsigned buffer_index)
{
if (handle->arbiter)
return _starpu_attempt_to_submit_arbitered_data_request(request_from_codelet, handle, mode, callback, argcb, j, buffer_index);
if (mode == STARPU_RW)
mode = STARPU_W;
/* Take the lock protecting the header. We try to do some progression
* in case this is called from a worker, otherwise we just wait for the
* lock to be available. */
if (request_from_codelet)
{
int cpt = 0;
while (cpt < STARPU_SPIN_MAXTRY && _starpu_spin_trylock(&handle->header_lock))
{
cpt++;
_starpu_datawizard_progress(_starpu_memory_node_get_local_key(), 0);
}
if (cpt == STARPU_SPIN_MAXTRY)
_starpu_spin_lock(&handle->header_lock);
}
else
{
_starpu_spin_lock(&handle->header_lock);
}
/* If we have a request that is not used for the reduction, and that a
* reduction is pending, we put it at the end of normal list, and we
* use the reduction_req_list instead */
unsigned pending_reduction = (handle->reduction_refcnt > 0);
unsigned frozen = 0;
/* If we are currently performing a reduction, we freeze any request
* that is not explicitely a reduction task. */
unsigned is_a_reduction_task = (request_from_codelet && j->reduction_task);
if (pending_reduction && !is_a_reduction_task)
frozen = 1;
/* If there is currently nobody accessing the piece of data, or it's
* not another writter and if this is the same type of access as the
* current one, we can proceed. */
unsigned put_in_list = 1;
enum starpu_data_access_mode previous_mode = handle->current_mode;
if (!frozen && ((handle->refcnt == 0) || (!(mode == STARPU_W) && (handle->current_mode == mode))))
{
/* Detect whether this is the end of a reduction phase */
/* We don't want to start multiple reductions of the
* same handle at the same time ! */
if ((handle->reduction_refcnt == 0) && (previous_mode == STARPU_REDUX) && (mode != STARPU_REDUX))
{
_starpu_data_end_reduction_mode(handle);
/* Since we need to perform a mode change, we freeze
* the request if needed. */
put_in_list = (handle->reduction_refcnt > 0);
}
else
{
put_in_list = 0;
}
}
if (put_in_list)
{
/* there cannot be multiple writers or a new writer
* while the data is in read mode */
handle->busy_count++;
/* enqueue the request */
struct _starpu_data_requester *r = _starpu_data_requester_new();
r->mode = mode;
r->is_requested_by_codelet = request_from_codelet;
r->j = j;
r->buffer_index = buffer_index;
r->ready_data_callback = callback;
r->argcb = argcb;
/* We put the requester in a specific list if this is a reduction task */
struct _starpu_data_requester_list *req_list =
is_a_reduction_task?&handle->reduction_req_list:&handle->req_list;
_starpu_data_requester_list_push_back(req_list, r);
/* failed */
put_in_list = 1;
}
else
{
handle->refcnt++;
handle->busy_count++;
/* Do not write to handle->current_mode if it is already
* R. This avoids a spurious warning from helgrind when
* the following happens:
* acquire(R) in thread A
* acquire(R) in thread B
* release_data_on_node() in thread A
* helgrind would shout that the latter reads current_mode
* unsafely.
*
* This actually basically explains helgrind that it is a
* shared R acquisition.
*/
if (mode != STARPU_R || handle->current_mode != mode)
handle->current_mode = mode;
if ((mode == STARPU_REDUX) && (previous_mode != STARPU_REDUX))
_starpu_data_start_reduction_mode(handle);
/* success */
put_in_list = 0;
}
_starpu_spin_unlock(&handle->header_lock);
return put_in_list;
}
