182 lines
7.0 KiB
C
182 lines
7.0 KiB
C
/* full_frame.c -*-C++-*-
|
|
*
|
|
*************************************************************************
|
|
*
|
|
* @copyright
|
|
* Copyright (C) 2010-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 "full_frame.h"
|
|
#include "stats.h"
|
|
#include "os.h"
|
|
#include "bug.h"
|
|
#include "jmpbuf.h"
|
|
#include "frame_malloc.h"
|
|
|
|
COMMON_PORTABLE
|
|
full_frame *__cilkrts_make_full_frame(__cilkrts_worker *w,
|
|
__cilkrts_stack_frame *sf)
|
|
{
|
|
full_frame *ff;
|
|
|
|
START_INTERVAL(w, INTERVAL_ALLOC_FULL_FRAME) {
|
|
ff = (full_frame *)__cilkrts_frame_malloc(w, sizeof(*ff));
|
|
__cilkrts_mutex_init(&ff->lock);
|
|
|
|
ff->full_frame_magic_0 = FULL_FRAME_MAGIC_0;
|
|
ff->join_counter = 0;
|
|
ff->parent = 0;
|
|
ff->rightmost_child = 0;
|
|
ff->left_sibling = ff->right_sibling = 0;
|
|
ff->call_stack = sf;
|
|
ff->is_call_child = 0;
|
|
ff->simulated_stolen = 0;
|
|
ff->children_reducer_map = ff->right_reducer_map = 0;
|
|
ff->pending_exception =
|
|
ff->child_pending_exception =
|
|
ff->right_pending_exception = NULL;
|
|
|
|
ff->sync_sp = 0;
|
|
#ifdef _WIN32
|
|
ff->exception_sp = 0;
|
|
ff->trylevel = (unsigned long)-1;
|
|
ff->registration = 0;
|
|
#endif
|
|
ff->frame_size = 0;
|
|
ff->fiber_self = 0;
|
|
ff->fiber_child = 0;
|
|
|
|
ff->sync_master = 0;
|
|
|
|
/*__cilkrts_init_full_frame_sysdep(w, ff);*/
|
|
ff->full_frame_magic_1 = FULL_FRAME_MAGIC_1;
|
|
} STOP_INTERVAL(w, INTERVAL_ALLOC_FULL_FRAME);
|
|
return ff;
|
|
}
|
|
|
|
COMMON_PORTABLE void __cilkrts_put_stack(full_frame *ff,
|
|
__cilkrts_stack_frame *sf)
|
|
{
|
|
/* When suspending frame ff prior to stealing it, __cilkrts_put_stack is
|
|
* used to store the stack pointer for eventual sync. When suspending
|
|
* frame ff prior to a sync, __cilkrts_put_stack is called to re-establish
|
|
* the sync stack pointer, offsetting it by any change in the stack depth
|
|
* that occured between the spawn and the sync.
|
|
* Although it is not usually meaningful to add two pointers, the value of
|
|
* ff->sync_sp at the time of this call is really an integer, not a
|
|
* pointer.
|
|
*/
|
|
ptrdiff_t sync_sp_i = (ptrdiff_t) ff->sync_sp;
|
|
char* sp = (char*) __cilkrts_get_sp(sf);
|
|
|
|
ff->sync_sp = sp + sync_sp_i;
|
|
|
|
DBGPRINTF("%d- __cilkrts_put_stack - adjust (+) sync "
|
|
"stack of full frame %p (+sp: %p) to %p\n",
|
|
__cilkrts_get_tls_worker()->self, ff, sp, ff->sync_sp);
|
|
}
|
|
|
|
COMMON_PORTABLE void __cilkrts_take_stack(full_frame *ff, void *sp)
|
|
{
|
|
/* When resuming the parent after a steal, __cilkrts_take_stack is used to
|
|
* subtract the new stack pointer from the current stack pointer, storing
|
|
* the offset in ff->sync_sp. When resuming after a sync,
|
|
* __cilkrts_take_stack is used to subtract the new stack pointer from
|
|
* itself, leaving ff->sync_sp at zero (null). Although the pointers being
|
|
* subtracted are not part of the same contiguous chunk of memory, the
|
|
* flat memory model allows us to subtract them and get a useable offset.
|
|
*/
|
|
ptrdiff_t sync_sp_i = ff->sync_sp - (char*) sp;
|
|
|
|
ff->sync_sp = (char *) sync_sp_i;
|
|
|
|
DBGPRINTF("%d- __cilkrts_take_stack - adjust (-) sync "
|
|
"stack of full frame %p to %p (-sp: %p)\n",
|
|
__cilkrts_get_tls_worker()->self, ff, ff->sync_sp, sp);
|
|
}
|
|
|
|
COMMON_PORTABLE void __cilkrts_adjust_stack(full_frame *ff, size_t size)
|
|
{
|
|
/* When resuming the parent after a steal, __cilkrts_take_stack is used to
|
|
* subtract the new stack pointer from the current stack pointer, storing
|
|
* the offset in ff->sync_sp. When resuming after a sync,
|
|
* __cilkrts_take_stack is used to subtract the new stack pointer from
|
|
* itself, leaving ff->sync_sp at zero (null). Although the pointers being
|
|
* subtracted are not part of the same contiguous chunk of memory, the
|
|
* flat memory model allows us to subtract them and get a useable offset.
|
|
*
|
|
* __cilkrts_adjust_stack() is used to deallocate a Variable Length Array
|
|
* by adding it's size to ff->sync_sp.
|
|
*/
|
|
ff->sync_sp = ff->sync_sp + size;
|
|
|
|
DBGPRINTF("%d- __cilkrts_adjust_stack - adjust (+) sync "
|
|
"stack of full frame %p to %p (+ size: 0x%x)\n",
|
|
__cilkrts_get_tls_worker()->self, ff, ff->sync_sp, size);
|
|
}
|
|
|
|
COMMON_PORTABLE
|
|
void __cilkrts_destroy_full_frame(__cilkrts_worker *w, full_frame *ff)
|
|
{
|
|
validate_full_frame(ff);
|
|
CILK_ASSERT(ff->children_reducer_map == 0);
|
|
CILK_ASSERT(ff->right_reducer_map == 0);
|
|
CILK_ASSERT(NULL == ff->pending_exception);
|
|
CILK_ASSERT(NULL == ff->child_pending_exception);
|
|
CILK_ASSERT(NULL == ff->right_pending_exception);
|
|
__cilkrts_mutex_destroy(w, &ff->lock);
|
|
__cilkrts_frame_free(w, ff, sizeof(*ff));
|
|
}
|
|
|
|
COMMON_PORTABLE void validate_full_frame(full_frame *ff)
|
|
{
|
|
/* check the magic numbers, for debugging purposes */
|
|
if (ff->full_frame_magic_0 != FULL_FRAME_MAGIC_0 ||
|
|
ff->full_frame_magic_1 != FULL_FRAME_MAGIC_1)
|
|
abort_because_rts_is_corrupted();
|
|
}
|
|
|
|
void __cilkrts_frame_lock(__cilkrts_worker *w, full_frame *ff)
|
|
{
|
|
validate_full_frame(ff);
|
|
__cilkrts_mutex_lock(w, &ff->lock);
|
|
}
|
|
|
|
void __cilkrts_frame_unlock(__cilkrts_worker *w, full_frame *ff)
|
|
{
|
|
__cilkrts_mutex_unlock(w, &ff->lock);
|
|
}
|
|
|
|
/* End full_frame.c */
|