15 #include "kmp_error.h" 23 static char const *cons_text_c[] = {
24 "(none)",
"\"parallel\"",
"work-sharing",
27 "\"ordered\" work-sharing",
32 "\"taskq\"",
"\"taskq\"",
"\"taskq ordered\"",
"\"critical\"",
36 "\"master\"",
"\"reduce\"",
"\"barrier\""};
38 #define get_src(ident) ((ident) == NULL ? NULL : (ident)->psource) 40 #define PUSH_MSG(ct, ident) \ 41 "\tpushing on stack: %s (%s)\n", cons_text_c[(ct)], get_src((ident)) 43 "\tpopping off stack: %s (%s)\n", cons_text_c[(p)->stack_data[tos].type], \ 44 get_src((p)->stack_data[tos].ident) 46 static int const cons_text_c_num =
sizeof(cons_text_c) /
sizeof(
char const *);
50 static void __kmp_check_null_func(
void) {
53 static void __kmp_expand_cons_stack(
int gtid,
struct cons_header *p) {
59 __kmp_check_null_func();
61 KE_TRACE(10, (
"expand cons_stack (%d %d)\n", gtid, __kmp_get_gtid()));
65 p->stack_size = (p->stack_size * 2) + 100;
68 p->stack_data = (
struct cons_data *)__kmp_allocate(
sizeof(
struct cons_data) *
71 for (i = p->stack_top; i >= 0; --i)
72 p->stack_data[i] = d[i];
78 static char *__kmp_pragma(
int ct,
ident_t const *
ident) {
79 char const *cons = NULL;
85 __kmp_str_buf_init(&buffer);
86 if (0 < ct && ct < cons_text_c_num) {
87 cons = cons_text_c[ct];
91 if (ident != NULL && ident->
psource != NULL) {
93 __kmp_str_buf_print(&buffer,
"%s",
97 __kmp_str_split(tail,
';', NULL, &tail);
98 __kmp_str_split(tail,
';', &file, &tail);
99 __kmp_str_split(tail,
';', &func, &tail);
100 __kmp_str_split(tail,
';', &line, &tail);
102 prgm = __kmp_msg_format(kmp_i18n_fmt_Pragma, cons, file, func, line);
103 __kmp_str_buf_free(&buffer);
109 void __kmp_error_construct(kmp_i18n_id_t
id,
113 char *construct = __kmp_pragma(ct, ident);
114 __kmp_fatal(__kmp_msg_format(
id, construct), __kmp_msg_null);
115 KMP_INTERNAL_FREE(construct);
118 void __kmp_error_construct2(kmp_i18n_id_t
id,
121 struct cons_data
const *cons
123 char *construct1 = __kmp_pragma(ct, ident);
124 char *construct2 = __kmp_pragma(cons->type, cons->ident);
125 __kmp_fatal(__kmp_msg_format(
id, construct1, construct2), __kmp_msg_null);
126 KMP_INTERNAL_FREE(construct1);
127 KMP_INTERNAL_FREE(construct2);
130 struct cons_header *__kmp_allocate_cons_stack(
int gtid) {
131 struct cons_header *p;
135 __kmp_check_null_func();
137 KE_TRACE(10, (
"allocate cons_stack (%d)\n", gtid));
138 p = (
struct cons_header *)__kmp_allocate(
sizeof(
struct cons_header));
139 p->p_top = p->w_top = p->s_top = 0;
140 p->stack_data = (
struct cons_data *)__kmp_allocate(
sizeof(
struct cons_data) *
142 p->stack_size = MIN_STACK;
144 p->stack_data[0].type = ct_none;
145 p->stack_data[0].prev = 0;
146 p->stack_data[0].ident = NULL;
150 void __kmp_free_cons_stack(
void *ptr) {
151 struct cons_header *p = (
struct cons_header *)ptr;
153 if (p->stack_data != NULL) {
154 __kmp_free(p->stack_data);
155 p->stack_data = NULL;
162 static void dump_cons_stack(
int gtid,
struct cons_header *p) {
164 int tos = p->stack_top;
165 kmp_str_buf_t buffer;
166 __kmp_str_buf_init(&buffer);
169 "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n");
170 __kmp_str_buf_print(&buffer,
171 "Begin construct stack with %d items for thread %d\n",
173 __kmp_str_buf_print(&buffer,
" stack_top=%d { P=%d, W=%d, S=%d }\n", tos,
174 p->p_top, p->w_top, p->s_top);
175 for (i = tos; i > 0; i--) {
176 struct cons_data *c = &(p->stack_data[i]);
178 &buffer,
" stack_data[%2d] = { %s (%s) %d %p }\n", i,
179 cons_text_c[c->type], get_src(c->ident), c->prev, c->name);
181 __kmp_str_buf_print(&buffer,
"End construct stack for thread %d\n", gtid);
184 "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n");
185 __kmp_debug_printf(
"%s", buffer.str);
186 __kmp_str_buf_free(&buffer);
190 void __kmp_push_parallel(
int gtid,
ident_t const *ident) {
192 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
194 KMP_DEBUG_ASSERT(__kmp_threads[gtid]->th.th_cons);
195 KE_TRACE(10, (
"__kmp_push_parallel (%d %d)\n", gtid, __kmp_get_gtid()));
196 KE_TRACE(100, (PUSH_MSG(ct_parallel, ident)));
197 if (p->stack_top >= p->stack_size) {
198 __kmp_expand_cons_stack(gtid, p);
200 tos = ++p->stack_top;
201 p->stack_data[tos].type = ct_parallel;
202 p->stack_data[tos].prev = p->p_top;
203 p->stack_data[tos].ident = ident;
204 p->stack_data[tos].name = NULL;
206 KE_DUMP(1000, dump_cons_stack(gtid, p));
209 void __kmp_check_workshare(
int gtid,
enum cons_type ct,
ident_t const *ident) {
210 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
212 KMP_DEBUG_ASSERT(__kmp_threads[gtid]->th.th_cons);
213 KE_TRACE(10, (
"__kmp_check_workshare (%d %d)\n", gtid, __kmp_get_gtid()));
215 if (p->stack_top >= p->stack_size) {
216 __kmp_expand_cons_stack(gtid, p);
218 if (p->w_top > p->p_top &&
219 !(IS_CONS_TYPE_TASKQ(p->stack_data[p->w_top].type) &&
220 IS_CONS_TYPE_TASKQ(ct))) {
222 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
223 &p->stack_data[p->w_top]);
225 if (p->s_top > p->p_top) {
227 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
228 &p->stack_data[p->s_top]);
232 void __kmp_push_workshare(
int gtid,
enum cons_type ct,
ident_t const *ident) {
234 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
235 KE_TRACE(10, (
"__kmp_push_workshare (%d %d)\n", gtid, __kmp_get_gtid()));
236 __kmp_check_workshare(gtid, ct, ident);
237 KE_TRACE(100, (PUSH_MSG(ct, ident)));
238 tos = ++p->stack_top;
239 p->stack_data[tos].type = ct;
240 p->stack_data[tos].prev = p->w_top;
241 p->stack_data[tos].ident = ident;
242 p->stack_data[tos].name = NULL;
244 KE_DUMP(1000, dump_cons_stack(gtid, p));
248 #if KMP_USE_DYNAMIC_LOCK 249 __kmp_check_sync(
int gtid,
enum cons_type ct,
ident_t const * ident, kmp_user_lock_p lck, kmp_uint32 seq )
251 __kmp_check_sync(
int gtid,
enum cons_type ct,
ident_t const * ident, kmp_user_lock_p lck )
254 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
256 KE_TRACE(10, (
"__kmp_check_sync (gtid=%d)\n", __kmp_get_gtid()));
258 if (p->stack_top >= p->stack_size)
259 __kmp_expand_cons_stack(gtid, p);
261 if (ct == ct_ordered_in_parallel || ct == ct_ordered_in_pdo ||
262 ct == ct_ordered_in_taskq) {
263 if (p->w_top <= p->p_top) {
265 #ifdef BUILD_PARALLEL_ORDERED 267 KMP_ASSERT(ct == ct_ordered_in_parallel);
269 __kmp_error_construct(kmp_i18n_msg_CnsBoundToWorksharing, ct, ident);
273 if (!IS_CONS_TYPE_ORDERED(p->stack_data[p->w_top].type)) {
274 if (p->stack_data[p->w_top].type == ct_taskq) {
275 __kmp_error_construct2(kmp_i18n_msg_CnsNotInTaskConstruct, ct, ident,
276 &p->stack_data[p->w_top]);
278 __kmp_error_construct2(kmp_i18n_msg_CnsNoOrderedClause, ct, ident,
279 &p->stack_data[p->w_top]);
283 if (p->s_top > p->p_top && p->s_top > p->w_top) {
285 int index = p->s_top;
286 enum cons_type stack_type;
288 stack_type = p->stack_data[index].type;
290 if (stack_type == ct_critical ||
291 ((stack_type == ct_ordered_in_parallel ||
292 stack_type == ct_ordered_in_pdo ||
294 ct_ordered_in_taskq) &&
296 p->stack_data[index].ident != NULL &&
299 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
300 &p->stack_data[index]);
303 }
else if (ct == ct_critical) {
304 #if KMP_USE_DYNAMIC_LOCK 306 __kmp_get_user_lock_owner(lck, seq) ==
310 __kmp_get_user_lock_owner(lck) ==
313 int index = p->s_top;
314 struct cons_data cons = {NULL, ct_critical, 0, NULL};
316 while (index != 0 && p->stack_data[index].name != lck) {
317 index = p->stack_data[index].prev;
322 cons = p->stack_data[index];
325 __kmp_error_construct2(kmp_i18n_msg_CnsNestingSameName, ct, ident, &cons);
327 }
else if (ct == ct_master || ct == ct_reduce) {
328 if (p->w_top > p->p_top) {
330 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
331 &p->stack_data[p->w_top]);
333 if (ct == ct_reduce && p->s_top > p->p_top) {
335 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
336 &p->stack_data[p->s_top]);
342 #if KMP_USE_DYNAMIC_LOCK 343 __kmp_push_sync(
int gtid,
enum cons_type ct,
ident_t const * ident, kmp_user_lock_p lck, kmp_uint32 seq )
345 __kmp_push_sync(
int gtid,
enum cons_type ct,
ident_t const * ident, kmp_user_lock_p lck )
349 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
351 KMP_ASSERT(gtid == __kmp_get_gtid());
352 KE_TRACE(10, (
"__kmp_push_sync (gtid=%d)\n", gtid));
353 #if KMP_USE_DYNAMIC_LOCK 354 __kmp_check_sync(gtid, ct, ident, lck, seq);
356 __kmp_check_sync(gtid, ct, ident, lck);
358 KE_TRACE(100, (PUSH_MSG(ct, ident)));
359 tos = ++p->stack_top;
360 p->stack_data[tos].type = ct;
361 p->stack_data[tos].prev = p->s_top;
362 p->stack_data[tos].ident = ident;
363 p->stack_data[tos].name = lck;
365 KE_DUMP(1000, dump_cons_stack(gtid, p));
370 void __kmp_pop_parallel(
int gtid,
ident_t const *ident) {
372 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
374 KE_TRACE(10, (
"__kmp_pop_parallel (%d %d)\n", gtid, __kmp_get_gtid()));
375 if (tos == 0 || p->p_top == 0) {
376 __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct_parallel, ident);
378 if (tos != p->p_top || p->stack_data[tos].type != ct_parallel) {
379 __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct_parallel, ident,
380 &p->stack_data[tos]);
382 KE_TRACE(100, (POP_MSG(p)));
383 p->p_top = p->stack_data[tos].prev;
384 p->stack_data[tos].type = ct_none;
385 p->stack_data[tos].ident = NULL;
386 p->stack_top = tos - 1;
387 KE_DUMP(1000, dump_cons_stack(gtid, p));
390 enum cons_type __kmp_pop_workshare(
int gtid,
enum cons_type ct,
393 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
396 KE_TRACE(10, (
"__kmp_pop_workshare (%d %d)\n", gtid, __kmp_get_gtid()));
397 if (tos == 0 || p->w_top == 0) {
398 __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct, ident);
401 if (tos != p->w_top ||
402 (p->stack_data[tos].type != ct &&
404 !(p->stack_data[tos].type == ct_pdo_ordered && ct == ct_pdo) &&
405 !(p->stack_data[tos].type == ct_task_ordered && ct == ct_task))) {
406 __kmp_check_null_func();
407 __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct, ident,
408 &p->stack_data[tos]);
410 KE_TRACE(100, (POP_MSG(p)));
411 p->w_top = p->stack_data[tos].prev;
412 p->stack_data[tos].type = ct_none;
413 p->stack_data[tos].ident = NULL;
414 p->stack_top = tos - 1;
415 KE_DUMP(1000, dump_cons_stack(gtid, p));
416 return p->stack_data[p->w_top].type;
419 void __kmp_pop_sync(
int gtid,
enum cons_type ct,
ident_t const *ident) {
421 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
423 KE_TRACE(10, (
"__kmp_pop_sync (%d %d)\n", gtid, __kmp_get_gtid()));
424 if (tos == 0 || p->s_top == 0) {
425 __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct, ident);
427 if (tos != p->s_top || p->stack_data[tos].type != ct) {
428 __kmp_check_null_func();
429 __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct, ident,
430 &p->stack_data[tos]);
433 __kmp_check_null_func();
435 KE_TRACE(100, (POP_MSG(p)));
436 p->s_top = p->stack_data[tos].prev;
437 p->stack_data[tos].type = ct_none;
438 p->stack_data[tos].ident = NULL;
439 p->stack_top = tos - 1;
440 KE_DUMP(1000, dump_cons_stack(gtid, p));
445 void __kmp_check_barrier(
int gtid,
enum cons_type ct,
ident_t const *ident) {
446 struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
447 KE_TRACE(10, (
"__kmp_check_barrier (loc: %p, gtid: %d %d)\n", ident, gtid,
450 __kmp_check_null_func();
452 if (p->w_top > p->p_top) {
454 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
455 &p->stack_data[p->w_top]);
457 if (p->s_top > p->p_top) {
459 __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident,
460 &p->stack_data[p->s_top]);