diff options
Diffstat (limited to 'final/runtime/src/kmp_error.cpp')
-rw-r--r-- | final/runtime/src/kmp_error.cpp | 462 |
1 files changed, 462 insertions, 0 deletions
diff --git a/final/runtime/src/kmp_error.cpp b/final/runtime/src/kmp_error.cpp new file mode 100644 index 0000000..1a708b5 --- /dev/null +++ b/final/runtime/src/kmp_error.cpp @@ -0,0 +1,462 @@ +/* + * kmp_error.cpp -- KPTS functions for error checking at runtime + */ + +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.txt for details. +// +//===----------------------------------------------------------------------===// + +#include "kmp.h" +#include "kmp_error.h" +#include "kmp_i18n.h" +#include "kmp_str.h" + +/* ------------------------------------------------------------------------ */ + +#define MIN_STACK 100 + +static char const *cons_text_c[] = { + "(none)", "\"parallel\"", "work-sharing", /* this is not called "for" + because of lowering of + "sections" pragmas */ + "\"ordered\" work-sharing", /* this is not called "for ordered" because of + lowering of "sections" pragmas */ + "\"sections\"", + "work-sharing", /* this is not called "single" because of lowering of + "sections" pragmas */ + "\"taskq\"", "\"taskq\"", "\"taskq ordered\"", "\"critical\"", + "\"ordered\"", /* in PARALLEL */ + "\"ordered\"", /* in PDO */ + "\"ordered\"", /* in TASKQ */ + "\"master\"", "\"reduce\"", "\"barrier\""}; + +#define get_src(ident) ((ident) == NULL ? NULL : (ident)->psource) + +#define PUSH_MSG(ct, ident) \ + "\tpushing on stack: %s (%s)\n", cons_text_c[(ct)], get_src((ident)) +#define POP_MSG(p) \ + "\tpopping off stack: %s (%s)\n", cons_text_c[(p)->stack_data[tos].type], \ + get_src((p)->stack_data[tos].ident) + +static int const cons_text_c_num = sizeof(cons_text_c) / sizeof(char const *); + +/* --------------- START OF STATIC LOCAL ROUTINES ------------------------- */ + +static void __kmp_check_null_func(void) { /* nothing to do */ +} + +static void __kmp_expand_cons_stack(int gtid, struct cons_header *p) { + int i; + struct cons_data *d; + + /* TODO for monitor perhaps? */ + if (gtid < 0) + __kmp_check_null_func(); + + KE_TRACE(10, ("expand cons_stack (%d %d)\n", gtid, __kmp_get_gtid())); + + d = p->stack_data; + + p->stack_size = (p->stack_size * 2) + 100; + + /* TODO free the old data */ + p->stack_data = (struct cons_data *)__kmp_allocate(sizeof(struct cons_data) * + (p->stack_size + 1)); + + for (i = p->stack_top; i >= 0; --i) + p->stack_data[i] = d[i]; + + /* NOTE: we do not free the old stack_data */ +} + +// NOTE: Function returns allocated memory, caller must free it! +static char *__kmp_pragma(int ct, ident_t const *ident) { + char const *cons = NULL; // Construct name. + char *file = NULL; // File name. + char *func = NULL; // Function (routine) name. + char *line = NULL; // Line number. + kmp_str_buf_t buffer; + kmp_msg_t prgm; + __kmp_str_buf_init(&buffer); + if (0 < ct && ct < cons_text_c_num) { + cons = cons_text_c[ct]; + } else { + KMP_DEBUG_ASSERT(0); + } + if (ident != NULL && ident->psource != NULL) { + char *tail = NULL; + __kmp_str_buf_print(&buffer, "%s", + ident->psource); // Copy source to buffer. + // Split string in buffer to file, func, and line. + tail = buffer.str; + __kmp_str_split(tail, ';', NULL, &tail); + __kmp_str_split(tail, ';', &file, &tail); + __kmp_str_split(tail, ';', &func, &tail); + __kmp_str_split(tail, ';', &line, &tail); + } + prgm = __kmp_msg_format(kmp_i18n_fmt_Pragma, cons, file, func, line); + __kmp_str_buf_free(&buffer); + return prgm.str; +} // __kmp_pragma + +/* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */ + +void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier. + enum cons_type ct, // Construct type. + ident_t const *ident // Construct ident. + ) { + char *construct = __kmp_pragma(ct, ident); + __kmp_fatal(__kmp_msg_format(id, construct), __kmp_msg_null); + KMP_INTERNAL_FREE(construct); +} + +void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier. + enum cons_type ct, // First construct type. + ident_t const *ident, // First construct ident. + struct cons_data const *cons // Second construct. + ) { + char *construct1 = __kmp_pragma(ct, ident); + char *construct2 = __kmp_pragma(cons->type, cons->ident); + __kmp_fatal(__kmp_msg_format(id, construct1, construct2), __kmp_msg_null); + KMP_INTERNAL_FREE(construct1); + KMP_INTERNAL_FREE(construct2); +} + +struct cons_header *__kmp_allocate_cons_stack(int gtid) { + struct cons_header *p; + + /* TODO for monitor perhaps? */ + if (gtid < 0) { + __kmp_check_null_func(); + } + KE_TRACE(10, ("allocate cons_stack (%d)\n", gtid)); + p = (struct cons_header *)__kmp_allocate(sizeof(struct cons_header)); + p->p_top = p->w_top = p->s_top = 0; + p->stack_data = (struct cons_data *)__kmp_allocate(sizeof(struct cons_data) * + (MIN_STACK + 1)); + p->stack_size = MIN_STACK; + p->stack_top = 0; + p->stack_data[0].type = ct_none; + p->stack_data[0].prev = 0; + p->stack_data[0].ident = NULL; + return p; +} + +void __kmp_free_cons_stack(void *ptr) { + struct cons_header *p = (struct cons_header *)ptr; + if (p != NULL) { + if (p->stack_data != NULL) { + __kmp_free(p->stack_data); + p->stack_data = NULL; + } + __kmp_free(p); + } +} + +#if KMP_DEBUG +static void dump_cons_stack(int gtid, struct cons_header *p) { + int i; + int tos = p->stack_top; + kmp_str_buf_t buffer; + __kmp_str_buf_init(&buffer); + __kmp_str_buf_print( + &buffer, + "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n"); + __kmp_str_buf_print(&buffer, + "Begin construct stack with %d items for thread %d\n", + tos, gtid); + __kmp_str_buf_print(&buffer, " stack_top=%d { P=%d, W=%d, S=%d }\n", tos, + p->p_top, p->w_top, p->s_top); + for (i = tos; i > 0; i--) { + struct cons_data *c = &(p->stack_data[i]); + __kmp_str_buf_print( + &buffer, " stack_data[%2d] = { %s (%s) %d %p }\n", i, + cons_text_c[c->type], get_src(c->ident), c->prev, c->name); + } + __kmp_str_buf_print(&buffer, "End construct stack for thread %d\n", gtid); + __kmp_str_buf_print( + &buffer, + "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-\n"); + __kmp_debug_printf("%s", buffer.str); + __kmp_str_buf_free(&buffer); +} +#endif + +void __kmp_push_parallel(int gtid, ident_t const *ident) { + int tos; + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + + KMP_DEBUG_ASSERT(__kmp_threads[gtid]->th.th_cons); + KE_TRACE(10, ("__kmp_push_parallel (%d %d)\n", gtid, __kmp_get_gtid())); + KE_TRACE(100, (PUSH_MSG(ct_parallel, ident))); + if (p->stack_top >= p->stack_size) { + __kmp_expand_cons_stack(gtid, p); + } + tos = ++p->stack_top; + p->stack_data[tos].type = ct_parallel; + p->stack_data[tos].prev = p->p_top; + p->stack_data[tos].ident = ident; + p->stack_data[tos].name = NULL; + p->p_top = tos; + KE_DUMP(1000, dump_cons_stack(gtid, p)); +} + +void __kmp_check_workshare(int gtid, enum cons_type ct, ident_t const *ident) { + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + + KMP_DEBUG_ASSERT(__kmp_threads[gtid]->th.th_cons); + KE_TRACE(10, ("__kmp_check_workshare (%d %d)\n", gtid, __kmp_get_gtid())); + + if (p->stack_top >= p->stack_size) { + __kmp_expand_cons_stack(gtid, p); + } + if (p->w_top > p->p_top && + !(IS_CONS_TYPE_TASKQ(p->stack_data[p->w_top].type) && + IS_CONS_TYPE_TASKQ(ct))) { + // We are already in a WORKSHARE construct for this PARALLEL region. + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[p->w_top]); + } + if (p->s_top > p->p_top) { + // We are already in a SYNC construct for this PARALLEL region. + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[p->s_top]); + } +} + +void __kmp_push_workshare(int gtid, enum cons_type ct, ident_t const *ident) { + int tos; + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + KE_TRACE(10, ("__kmp_push_workshare (%d %d)\n", gtid, __kmp_get_gtid())); + __kmp_check_workshare(gtid, ct, ident); + KE_TRACE(100, (PUSH_MSG(ct, ident))); + tos = ++p->stack_top; + p->stack_data[tos].type = ct; + p->stack_data[tos].prev = p->w_top; + p->stack_data[tos].ident = ident; + p->stack_data[tos].name = NULL; + p->w_top = tos; + KE_DUMP(1000, dump_cons_stack(gtid, p)); +} + +void +#if KMP_USE_DYNAMIC_LOCK +__kmp_check_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck, kmp_uint32 seq ) +#else +__kmp_check_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck ) +#endif +{ + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + + KE_TRACE(10, ("__kmp_check_sync (gtid=%d)\n", __kmp_get_gtid())); + + if (p->stack_top >= p->stack_size) + __kmp_expand_cons_stack(gtid, p); + + if (ct == ct_ordered_in_parallel || ct == ct_ordered_in_pdo || + ct == ct_ordered_in_taskq) { + if (p->w_top <= p->p_top) { +/* we are not in a worksharing construct */ +#ifdef BUILD_PARALLEL_ORDERED + /* do not report error messages for PARALLEL ORDERED */ + KMP_ASSERT(ct == ct_ordered_in_parallel); +#else + __kmp_error_construct(kmp_i18n_msg_CnsBoundToWorksharing, ct, ident); +#endif /* BUILD_PARALLEL_ORDERED */ + } else { + /* inside a WORKSHARING construct for this PARALLEL region */ + if (!IS_CONS_TYPE_ORDERED(p->stack_data[p->w_top].type)) { + if (p->stack_data[p->w_top].type == ct_taskq) { + __kmp_error_construct2(kmp_i18n_msg_CnsNotInTaskConstruct, ct, ident, + &p->stack_data[p->w_top]); + } else { + __kmp_error_construct2(kmp_i18n_msg_CnsNoOrderedClause, ct, ident, + &p->stack_data[p->w_top]); + } + } + } + if (p->s_top > p->p_top && p->s_top > p->w_top) { + /* inside a sync construct which is inside a worksharing construct */ + int index = p->s_top; + enum cons_type stack_type; + + stack_type = p->stack_data[index].type; + + if (stack_type == ct_critical || + ((stack_type == ct_ordered_in_parallel || + stack_type == ct_ordered_in_pdo || + stack_type == + ct_ordered_in_taskq) && /* C doesn't allow named ordered; + ordered in ordered gets error */ + p->stack_data[index].ident != NULL && + (p->stack_data[index].ident->flags & KMP_IDENT_KMPC))) { + /* we are in ORDERED which is inside an ORDERED or CRITICAL construct */ + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[index]); + } + } + } else if (ct == ct_critical) { +#if KMP_USE_DYNAMIC_LOCK + if (lck != NULL && + __kmp_get_user_lock_owner(lck, seq) == + gtid) { /* this thread already has lock for this critical section */ +#else + if (lck != NULL && + __kmp_get_user_lock_owner(lck) == + gtid) { /* this thread already has lock for this critical section */ +#endif + int index = p->s_top; + struct cons_data cons = {NULL, ct_critical, 0, NULL}; + /* walk up construct stack and try to find critical with matching name */ + while (index != 0 && p->stack_data[index].name != lck) { + index = p->stack_data[index].prev; + } + if (index != 0) { + /* found match on the stack (may not always because of interleaved + * critical for Fortran) */ + cons = p->stack_data[index]; + } + /* we are in CRITICAL which is inside a CRITICAL construct of same name */ + __kmp_error_construct2(kmp_i18n_msg_CnsNestingSameName, ct, ident, &cons); + } + } else if (ct == ct_master || ct == ct_reduce) { + if (p->w_top > p->p_top) { + /* inside a WORKSHARING construct for this PARALLEL region */ + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[p->w_top]); + } + if (ct == ct_reduce && p->s_top > p->p_top) { + /* inside a another SYNC construct for this PARALLEL region */ + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[p->s_top]); + } + } +} + +void +#if KMP_USE_DYNAMIC_LOCK +__kmp_push_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck, kmp_uint32 seq ) +#else +__kmp_push_sync( int gtid, enum cons_type ct, ident_t const * ident, kmp_user_lock_p lck ) +#endif +{ + int tos; + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + + KMP_ASSERT(gtid == __kmp_get_gtid()); + KE_TRACE(10, ("__kmp_push_sync (gtid=%d)\n", gtid)); +#if KMP_USE_DYNAMIC_LOCK + __kmp_check_sync(gtid, ct, ident, lck, seq); +#else + __kmp_check_sync(gtid, ct, ident, lck); +#endif + KE_TRACE(100, (PUSH_MSG(ct, ident))); + tos = ++p->stack_top; + p->stack_data[tos].type = ct; + p->stack_data[tos].prev = p->s_top; + p->stack_data[tos].ident = ident; + p->stack_data[tos].name = lck; + p->s_top = tos; + KE_DUMP(1000, dump_cons_stack(gtid, p)); +} + +/* ------------------------------------------------------------------------ */ + +void __kmp_pop_parallel(int gtid, ident_t const *ident) { + int tos; + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + tos = p->stack_top; + KE_TRACE(10, ("__kmp_pop_parallel (%d %d)\n", gtid, __kmp_get_gtid())); + if (tos == 0 || p->p_top == 0) { + __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct_parallel, ident); + } + if (tos != p->p_top || p->stack_data[tos].type != ct_parallel) { + __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct_parallel, ident, + &p->stack_data[tos]); + } + KE_TRACE(100, (POP_MSG(p))); + p->p_top = p->stack_data[tos].prev; + p->stack_data[tos].type = ct_none; + p->stack_data[tos].ident = NULL; + p->stack_top = tos - 1; + KE_DUMP(1000, dump_cons_stack(gtid, p)); +} + +enum cons_type __kmp_pop_workshare(int gtid, enum cons_type ct, + ident_t const *ident) { + int tos; + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + + tos = p->stack_top; + KE_TRACE(10, ("__kmp_pop_workshare (%d %d)\n", gtid, __kmp_get_gtid())); + if (tos == 0 || p->w_top == 0) { + __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct, ident); + } + + if (tos != p->w_top || + (p->stack_data[tos].type != ct && + // below are two exceptions to the rule that construct types must match + !(p->stack_data[tos].type == ct_pdo_ordered && ct == ct_pdo) && + !(p->stack_data[tos].type == ct_task_ordered && ct == ct_task))) { + __kmp_check_null_func(); + __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct, ident, + &p->stack_data[tos]); + } + KE_TRACE(100, (POP_MSG(p))); + p->w_top = p->stack_data[tos].prev; + p->stack_data[tos].type = ct_none; + p->stack_data[tos].ident = NULL; + p->stack_top = tos - 1; + KE_DUMP(1000, dump_cons_stack(gtid, p)); + return p->stack_data[p->w_top].type; +} + +void __kmp_pop_sync(int gtid, enum cons_type ct, ident_t const *ident) { + int tos; + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + tos = p->stack_top; + KE_TRACE(10, ("__kmp_pop_sync (%d %d)\n", gtid, __kmp_get_gtid())); + if (tos == 0 || p->s_top == 0) { + __kmp_error_construct(kmp_i18n_msg_CnsDetectedEnd, ct, ident); + } + if (tos != p->s_top || p->stack_data[tos].type != ct) { + __kmp_check_null_func(); + __kmp_error_construct2(kmp_i18n_msg_CnsExpectedEnd, ct, ident, + &p->stack_data[tos]); + } + if (gtid < 0) { + __kmp_check_null_func(); + } + KE_TRACE(100, (POP_MSG(p))); + p->s_top = p->stack_data[tos].prev; + p->stack_data[tos].type = ct_none; + p->stack_data[tos].ident = NULL; + p->stack_top = tos - 1; + KE_DUMP(1000, dump_cons_stack(gtid, p)); +} + +/* ------------------------------------------------------------------------ */ + +void __kmp_check_barrier(int gtid, enum cons_type ct, ident_t const *ident) { + struct cons_header *p = __kmp_threads[gtid]->th.th_cons; + KE_TRACE(10, ("__kmp_check_barrier (loc: %p, gtid: %d %d)\n", ident, gtid, + __kmp_get_gtid())); + if (ident != 0) { + __kmp_check_null_func(); + } + if (p->w_top > p->p_top) { + /* we are already in a WORKSHARING construct for this PARALLEL region */ + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[p->w_top]); + } + if (p->s_top > p->p_top) { + /* we are already in a SYNC construct for this PARALLEL region */ + __kmp_error_construct2(kmp_i18n_msg_CnsInvalidNesting, ct, ident, + &p->stack_data[p->s_top]); + } +} |