]>
Commit | Line | Data |
---|---|---|
3038054c BI |
1 | /* full_frame.c -*-C++-*- |
2 | * | |
3 | ************************************************************************* | |
4 | * | |
2e01cda6 | 5 | * Copyright (C) 2010-2016, Intel Corporation |
3038054c BI |
6 | * All rights reserved. |
7 | * | |
3038054c BI |
8 | * Redistribution and use in source and binary forms, with or without |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * | |
12 | * * Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions and the following disclaimer. | |
14 | * * Redistributions in binary form must reproduce the above copyright | |
15 | * notice, this list of conditions and the following disclaimer in | |
16 | * the documentation and/or other materials provided with the | |
17 | * distribution. | |
18 | * * Neither the name of Intel Corporation nor the names of its | |
19 | * contributors may be used to endorse or promote products derived | |
20 | * from this software without specific prior written permission. | |
21 | * | |
3038054c BI |
22 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
23 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
24 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
25 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
26 | * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, | |
27 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | |
28 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS | |
29 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED | |
30 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
31 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY | |
32 | * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
33 | * POSSIBILITY OF SUCH DAMAGE. | |
2e01cda6 IV |
34 | * |
35 | * ********************************************************************* | |
36 | * | |
37 | * PLEASE NOTE: This file is a downstream copy of a file mainitained in | |
38 | * a repository at cilkplus.org. Changes made to this file that are not | |
39 | * submitted through the contribution process detailed at | |
40 | * http://www.cilkplus.org/submit-cilk-contribution will be lost the next | |
41 | * time that a new version is released. Changes only submitted to the | |
42 | * GNU compiler collection or posted to the git repository at | |
43 | * https://bitbucket.org/intelcilkruntime/intel-cilk-runtime.git are | |
44 | * not tracked. | |
45 | * | |
46 | * We welcome your contributions to this open source project. Thank you | |
47 | * for your assistance in helping us improve Cilk Plus. | |
3038054c BI |
48 | * |
49 | **************************************************************************/ | |
50 | ||
51 | #include "full_frame.h" | |
52 | #include "stats.h" | |
53 | #include "os.h" | |
54 | #include "bug.h" | |
55 | #include "jmpbuf.h" | |
56 | #include "frame_malloc.h" | |
57 | ||
58 | COMMON_PORTABLE | |
59 | full_frame *__cilkrts_make_full_frame(__cilkrts_worker *w, | |
60 | __cilkrts_stack_frame *sf) | |
61 | { | |
62 | full_frame *ff; | |
63 | ||
64 | START_INTERVAL(w, INTERVAL_ALLOC_FULL_FRAME) { | |
65 | ff = (full_frame *)__cilkrts_frame_malloc(w, sizeof(*ff)); | |
66 | __cilkrts_mutex_init(&ff->lock); | |
67 | ||
68 | ff->full_frame_magic_0 = FULL_FRAME_MAGIC_0; | |
69 | ff->join_counter = 0; | |
70 | ff->parent = 0; | |
71 | ff->rightmost_child = 0; | |
72 | ff->left_sibling = ff->right_sibling = 0; | |
73 | ff->call_stack = sf; | |
74 | ff->is_call_child = 0; | |
75 | ff->simulated_stolen = 0; | |
76 | ff->children_reducer_map = ff->right_reducer_map = 0; | |
77 | ff->pending_exception = | |
78 | ff->child_pending_exception = | |
79 | ff->right_pending_exception = NULL; | |
80 | ||
81 | ff->sync_sp = 0; | |
82 | #ifdef _WIN32 | |
83 | ff->exception_sp = 0; | |
84 | ff->trylevel = (unsigned long)-1; | |
85 | ff->registration = 0; | |
86 | #endif | |
87 | ff->frame_size = 0; | |
88 | ff->fiber_self = 0; | |
89 | ff->fiber_child = 0; | |
90 | ||
91 | ff->sync_master = 0; | |
92 | ||
93 | /*__cilkrts_init_full_frame_sysdep(w, ff);*/ | |
94 | ff->full_frame_magic_1 = FULL_FRAME_MAGIC_1; | |
95 | } STOP_INTERVAL(w, INTERVAL_ALLOC_FULL_FRAME); | |
96 | return ff; | |
97 | } | |
98 | ||
99 | COMMON_PORTABLE void __cilkrts_put_stack(full_frame *ff, | |
100 | __cilkrts_stack_frame *sf) | |
101 | { | |
102 | /* When suspending frame ff prior to stealing it, __cilkrts_put_stack is | |
103 | * used to store the stack pointer for eventual sync. When suspending | |
104 | * frame ff prior to a sync, __cilkrts_put_stack is called to re-establish | |
105 | * the sync stack pointer, offsetting it by any change in the stack depth | |
106 | * that occured between the spawn and the sync. | |
107 | * Although it is not usually meaningful to add two pointers, the value of | |
108 | * ff->sync_sp at the time of this call is really an integer, not a | |
109 | * pointer. | |
110 | */ | |
111 | ptrdiff_t sync_sp_i = (ptrdiff_t) ff->sync_sp; | |
112 | char* sp = (char*) __cilkrts_get_sp(sf); | |
113 | ||
114 | ff->sync_sp = sp + sync_sp_i; | |
115 | ||
116 | DBGPRINTF("%d- __cilkrts_put_stack - adjust (+) sync " | |
117 | "stack of full frame %p (+sp: %p) to %p\n", | |
118 | __cilkrts_get_tls_worker()->self, ff, sp, ff->sync_sp); | |
119 | } | |
120 | ||
121 | COMMON_PORTABLE void __cilkrts_take_stack(full_frame *ff, void *sp) | |
122 | { | |
123 | /* When resuming the parent after a steal, __cilkrts_take_stack is used to | |
124 | * subtract the new stack pointer from the current stack pointer, storing | |
125 | * the offset in ff->sync_sp. When resuming after a sync, | |
126 | * __cilkrts_take_stack is used to subtract the new stack pointer from | |
127 | * itself, leaving ff->sync_sp at zero (null). Although the pointers being | |
128 | * subtracted are not part of the same contiguous chunk of memory, the | |
129 | * flat memory model allows us to subtract them and get a useable offset. | |
130 | */ | |
131 | ptrdiff_t sync_sp_i = ff->sync_sp - (char*) sp; | |
132 | ||
133 | ff->sync_sp = (char *) sync_sp_i; | |
134 | ||
135 | DBGPRINTF("%d- __cilkrts_take_stack - adjust (-) sync " | |
136 | "stack of full frame %p to %p (-sp: %p)\n", | |
137 | __cilkrts_get_tls_worker()->self, ff, ff->sync_sp, sp); | |
138 | } | |
139 | ||
140 | COMMON_PORTABLE void __cilkrts_adjust_stack(full_frame *ff, size_t size) | |
141 | { | |
142 | /* When resuming the parent after a steal, __cilkrts_take_stack is used to | |
143 | * subtract the new stack pointer from the current stack pointer, storing | |
144 | * the offset in ff->sync_sp. When resuming after a sync, | |
145 | * __cilkrts_take_stack is used to subtract the new stack pointer from | |
146 | * itself, leaving ff->sync_sp at zero (null). Although the pointers being | |
147 | * subtracted are not part of the same contiguous chunk of memory, the | |
148 | * flat memory model allows us to subtract them and get a useable offset. | |
149 | * | |
150 | * __cilkrts_adjust_stack() is used to deallocate a Variable Length Array | |
151 | * by adding it's size to ff->sync_sp. | |
152 | */ | |
153 | ff->sync_sp = ff->sync_sp + size; | |
154 | ||
155 | DBGPRINTF("%d- __cilkrts_adjust_stack - adjust (+) sync " | |
156 | "stack of full frame %p to %p (+ size: 0x%x)\n", | |
157 | __cilkrts_get_tls_worker()->self, ff, ff->sync_sp, size); | |
158 | } | |
159 | ||
160 | COMMON_PORTABLE | |
161 | void __cilkrts_destroy_full_frame(__cilkrts_worker *w, full_frame *ff) | |
162 | { | |
163 | validate_full_frame(ff); | |
164 | CILK_ASSERT(ff->children_reducer_map == 0); | |
165 | CILK_ASSERT(ff->right_reducer_map == 0); | |
166 | CILK_ASSERT(NULL == ff->pending_exception); | |
167 | CILK_ASSERT(NULL == ff->child_pending_exception); | |
168 | CILK_ASSERT(NULL == ff->right_pending_exception); | |
169 | __cilkrts_mutex_destroy(w, &ff->lock); | |
170 | __cilkrts_frame_free(w, ff, sizeof(*ff)); | |
171 | } | |
172 | ||
173 | COMMON_PORTABLE void validate_full_frame(full_frame *ff) | |
174 | { | |
175 | /* check the magic numbers, for debugging purposes */ | |
176 | if (ff->full_frame_magic_0 != FULL_FRAME_MAGIC_0 || | |
177 | ff->full_frame_magic_1 != FULL_FRAME_MAGIC_1) | |
178 | abort_because_rts_is_corrupted(); | |
179 | } | |
180 | ||
181 | void __cilkrts_frame_lock(__cilkrts_worker *w, full_frame *ff) | |
182 | { | |
183 | validate_full_frame(ff); | |
184 | __cilkrts_mutex_lock(w, &ff->lock); | |
185 | } | |
186 | ||
187 | void __cilkrts_frame_unlock(__cilkrts_worker *w, full_frame *ff) | |
188 | { | |
189 | __cilkrts_mutex_unlock(w, &ff->lock); | |
190 | } | |
191 | ||
192 | /* End full_frame.c */ |