diff options
Diffstat (limited to 'final/runtime/test/ompt')
77 files changed, 5810 insertions, 0 deletions
diff --git a/final/runtime/test/ompt/callback.h b/final/runtime/test/ompt/callback.h new file mode 100755 index 0000000..a7bd7fe --- /dev/null +++ b/final/runtime/test/ompt/callback.h @@ -0,0 +1,780 @@ +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#define _DEFAULT_SOURCE +#include <stdio.h> +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif +#include <inttypes.h> +#include <omp.h> +#include <omp-tools.h> +#include "ompt-signal.h" + +// Used to detect architecture +#include "../../src/kmp_platform.h" + +static const char* ompt_thread_t_values[] = { + NULL, + "ompt_thread_initial", + "ompt_thread_worker", + "ompt_thread_other" +}; + +static const char* ompt_task_status_t_values[] = { + NULL, + "ompt_task_complete", // 1 + "ompt_task_yield", // 2 + "ompt_task_cancel", // 3 + "ompt_task_detach", // 4 + "ompt_task_early_fulfill", // 5 + "ompt_task_late_fulfill", // 6 + "ompt_task_switch" // 7 +}; +static const char* ompt_cancel_flag_t_values[] = { + "ompt_cancel_parallel", + "ompt_cancel_sections", + "ompt_cancel_loop", + "ompt_cancel_taskgroup", + "ompt_cancel_activated", + "ompt_cancel_detected", + "ompt_cancel_discarded_task" +}; + +static void format_task_type(int type, char *buffer) { + char *progress = buffer; + if (type & ompt_task_initial) + progress += sprintf(progress, "ompt_task_initial"); + if (type & ompt_task_implicit) + progress += sprintf(progress, "ompt_task_implicit"); + if (type & ompt_task_explicit) + progress += sprintf(progress, "ompt_task_explicit"); + if (type & ompt_task_target) + progress += sprintf(progress, "ompt_task_target"); + if (type & ompt_task_undeferred) + progress += sprintf(progress, "|ompt_task_undeferred"); + if (type & ompt_task_untied) + progress += sprintf(progress, "|ompt_task_untied"); + if (type & ompt_task_final) + progress += sprintf(progress, "|ompt_task_final"); + if (type & ompt_task_mergeable) + progress += sprintf(progress, "|ompt_task_mergeable"); + if (type & ompt_task_merged) + progress += sprintf(progress, "|ompt_task_merged"); +} + +static ompt_set_callback_t ompt_set_callback; +static ompt_get_callback_t ompt_get_callback; +static ompt_get_state_t ompt_get_state; +static ompt_get_task_info_t ompt_get_task_info; +static ompt_get_thread_data_t ompt_get_thread_data; +static ompt_get_parallel_info_t ompt_get_parallel_info; +static ompt_get_unique_id_t ompt_get_unique_id; +static ompt_get_num_procs_t ompt_get_num_procs; +static ompt_get_num_places_t ompt_get_num_places; +static ompt_get_place_proc_ids_t ompt_get_place_proc_ids; +static ompt_get_place_num_t ompt_get_place_num; +static ompt_get_partition_place_nums_t ompt_get_partition_place_nums; +static ompt_get_proc_id_t ompt_get_proc_id; +static ompt_enumerate_states_t ompt_enumerate_states; +static ompt_enumerate_mutex_impls_t ompt_enumerate_mutex_impls; + +static void print_ids(int level) +{ + int task_type, thread_num; + ompt_frame_t *frame; + ompt_data_t *task_parallel_data; + ompt_data_t *task_data; + int exists_task = ompt_get_task_info(level, &task_type, &task_data, &frame, + &task_parallel_data, &thread_num); + char buffer[2048]; + format_task_type(task_type, buffer); + if (frame) + printf("%" PRIu64 ": task level %d: parallel_id=%" PRIu64 + ", task_id=%" PRIu64 ", exit_frame=%p, reenter_frame=%p, " + "task_type=%s=%d, thread_num=%d\n", + ompt_get_thread_data()->value, level, + exists_task ? task_parallel_data->value : 0, + exists_task ? task_data->value : 0, frame->exit_frame.ptr, + frame->enter_frame.ptr, buffer, task_type, thread_num); +} + +#define get_frame_address(level) __builtin_frame_address(level) + +#define print_frame(level) \ + printf("%" PRIu64 ": __builtin_frame_address(%d)=%p\n", \ + ompt_get_thread_data()->value, level, get_frame_address(level)) + +// clang (version 5.0 and above) adds an intermediate function call with debug flag (-g) +#if defined(TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN) + #if defined(DEBUG) && defined(__clang__) && __clang_major__ >= 5 + #define print_frame_from_outlined_fn(level) print_frame(level+1) + #else + #define print_frame_from_outlined_fn(level) print_frame(level) + #endif + + #if defined(__clang__) && __clang_major__ >= 5 + #warning "Clang 5.0 and later add an additional wrapper for outlined functions when compiling with debug information." + #warning "Please define -DDEBUG iff you manually pass in -g to make the tests succeed!" + #endif +#endif + +// This macro helps to define a label at the current position that can be used +// to get the current address in the code. +// +// For print_current_address(): +// To reliably determine the offset between the address of the label and the +// actual return address, we insert a NOP instruction as a jump target as the +// compiler would otherwise insert an instruction that we can't control. The +// instruction length is target dependent and is explained below. +// +// (The empty block between "#pragma omp ..." and the __asm__ statement is a +// workaround for a bug in the Intel Compiler.) +#define define_ompt_label(id) \ + {} \ + __asm__("nop"); \ +ompt_label_##id: + +// This macro helps to get the address of a label that is inserted by the above +// macro define_ompt_label(). The address is obtained with a GNU extension +// (&&label) that has been tested with gcc, clang and icc. +#define get_ompt_label_address(id) (&& ompt_label_##id) + +// This macro prints the exact address that a previously called runtime function +// returns to. +#define print_current_address(id) \ + define_ompt_label(id) \ + print_possible_return_addresses(get_ompt_label_address(id)) + +#if KMP_ARCH_X86 || KMP_ARCH_X86_64 +// On X86 the NOP instruction is 1 byte long. In addition, the comiler inserts +// a MOV instruction for non-void runtime functions which is 3 bytes long. +#define print_possible_return_addresses(addr) \ + printf("%" PRIu64 ": current_address=%p or %p for non-void functions\n", \ + ompt_get_thread_data()->value, ((char *)addr) - 1, ((char *)addr) - 4) +#elif KMP_ARCH_PPC64 +// On Power the NOP instruction is 4 bytes long. In addition, the compiler +// inserts an LD instruction which accounts for another 4 bytes. In contrast to +// X86 this instruction is always there, even for void runtime functions. +#define print_possible_return_addresses(addr) \ + printf("%" PRIu64 ": current_address=%p\n", ompt_get_thread_data()->value, \ + ((char *)addr) - 8) +#elif KMP_ARCH_AARCH64 +// On AArch64 the NOP instruction is 4 bytes long, can be followed by inserted +// store instruction (another 4 bytes long). +#define print_possible_return_addresses(addr) \ + printf("%" PRIu64 ": current_address=%p or %p\n", ompt_get_thread_data()->value, \ + ((char *)addr) - 4, ((char *)addr) - 8) +#else +#error Unsupported target architecture, cannot determine address offset! +#endif + + +// This macro performs a somewhat similar job to print_current_address(), except +// that it discards a certain number of nibbles from the address and only prints +// the most significant bits / nibbles. This can be used for cases where the +// return address can only be approximated. +// +// To account for overflows (ie the most significant bits / nibbles have just +// changed as we are a few bytes above the relevant power of two) the addresses +// of the "current" and of the "previous block" are printed. +#define print_fuzzy_address(id) \ + define_ompt_label(id) \ + print_fuzzy_address_blocks(get_ompt_label_address(id)) + +// If you change this define you need to adapt all capture patterns in the tests +// to include or discard the new number of nibbles! +#define FUZZY_ADDRESS_DISCARD_NIBBLES 2 +#define FUZZY_ADDRESS_DISCARD_BYTES (1 << ((FUZZY_ADDRESS_DISCARD_NIBBLES) * 4)) +#define print_fuzzy_address_blocks(addr) \ + printf("%" PRIu64 ": fuzzy_address=0x%" PRIx64 " or 0x%" PRIx64 \ + " or 0x%" PRIx64 " or 0x%" PRIx64 " (%p)\n", \ + ompt_get_thread_data()->value, \ + ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES - 1, \ + ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES, \ + ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES + 1, \ + ((uint64_t)addr) / FUZZY_ADDRESS_DISCARD_BYTES + 2, addr) + +static void +on_ompt_callback_mutex_acquire( + ompt_mutex_t kind, + unsigned int hint, + unsigned int impl, + ompt_wait_id_t wait_id, + const void *codeptr_ra) +{ + switch(kind) + { + case ompt_mutex_lock: + printf("%" PRIu64 ": ompt_event_wait_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + case ompt_mutex_nest_lock: + printf("%" PRIu64 ": ompt_event_wait_nest_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + case ompt_mutex_critical: + printf("%" PRIu64 ": ompt_event_wait_critical: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + case ompt_mutex_atomic: + printf("%" PRIu64 ": ompt_event_wait_atomic: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + case ompt_mutex_ordered: + printf("%" PRIu64 ": ompt_event_wait_ordered: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + default: + break; + } +} + +static void +on_ompt_callback_mutex_acquired( + ompt_mutex_t kind, + ompt_wait_id_t wait_id, + const void *codeptr_ra) +{ + switch(kind) + { + case ompt_mutex_lock: + printf("%" PRIu64 ": ompt_event_acquired_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_nest_lock: + printf("%" PRIu64 ": ompt_event_acquired_nest_lock_first: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_critical: + printf("%" PRIu64 ": ompt_event_acquired_critical: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_atomic: + printf("%" PRIu64 ": ompt_event_acquired_atomic: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_ordered: + printf("%" PRIu64 ": ompt_event_acquired_ordered: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + default: + break; + } +} + +static void +on_ompt_callback_mutex_released( + ompt_mutex_t kind, + ompt_wait_id_t wait_id, + const void *codeptr_ra) +{ + switch(kind) + { + case ompt_mutex_lock: + printf("%" PRIu64 ": ompt_event_release_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_nest_lock: + printf("%" PRIu64 ": ompt_event_release_nest_lock_last: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_critical: + printf("%" PRIu64 ": ompt_event_release_critical: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_atomic: + printf("%" PRIu64 ": ompt_event_release_atomic: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_ordered: + printf("%" PRIu64 ": ompt_event_release_ordered: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + default: + break; + } +} + +static void +on_ompt_callback_nest_lock( + ompt_scope_endpoint_t endpoint, + ompt_wait_id_t wait_id, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + printf("%" PRIu64 ": ompt_event_acquired_nest_lock_next: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_scope_end: + printf("%" PRIu64 ": ompt_event_release_nest_lock_prev: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + } +} + +static void +on_ompt_callback_sync_region( + ompt_sync_region_t kind, + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + switch(kind) + { + case ompt_sync_region_barrier: + case ompt_sync_region_barrier_implicit: + case ompt_sync_region_barrier_explicit: + case ompt_sync_region_barrier_implementation: + printf("%" PRIu64 ": ompt_event_barrier_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + print_ids(0); + break; + case ompt_sync_region_taskwait: + printf("%" PRIu64 ": ompt_event_taskwait_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskgroup: + printf("%" PRIu64 ": ompt_event_taskgroup_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_sync_region_reduction: + break; + } + break; + case ompt_scope_end: + switch(kind) + { + case ompt_sync_region_barrier: + case ompt_sync_region_barrier_implicit: + case ompt_sync_region_barrier_explicit: + case ompt_sync_region_barrier_implementation: + printf("%" PRIu64 ": ompt_event_barrier_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskwait: + printf("%" PRIu64 ": ompt_event_taskwait_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskgroup: + printf("%" PRIu64 ": ompt_event_taskgroup_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + case ompt_sync_region_reduction: + break; + } + break; + } +} + +static void +on_ompt_callback_sync_region_wait( + ompt_sync_region_t kind, + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + switch(kind) + { + case ompt_sync_region_barrier: + case ompt_sync_region_barrier_implicit: + case ompt_sync_region_barrier_explicit: + case ompt_sync_region_barrier_implementation: + printf("%" PRIu64 ": ompt_event_wait_barrier_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskwait: + printf("%" PRIu64 ": ompt_event_wait_taskwait_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskgroup: + printf("%" PRIu64 ": ompt_event_wait_taskgroup_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_sync_region_reduction: + break; + } + break; + case ompt_scope_end: + switch(kind) + { + case ompt_sync_region_barrier: + case ompt_sync_region_barrier_implicit: + case ompt_sync_region_barrier_explicit: + case ompt_sync_region_barrier_implementation: + printf("%" PRIu64 ": ompt_event_wait_barrier_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskwait: + printf("%" PRIu64 ": ompt_event_wait_taskwait_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + case ompt_sync_region_taskgroup: + printf("%" PRIu64 ": ompt_event_wait_taskgroup_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + case ompt_sync_region_reduction: + break; + } + break; + } +} + +static void +on_ompt_callback_flush( + ompt_data_t *thread_data, + const void *codeptr_ra) +{ + printf("%" PRIu64 ": ompt_event_flush: codeptr_ra=%p\n", thread_data->value, codeptr_ra); +} + +static void +on_ompt_callback_cancel( + ompt_data_t *task_data, + int flags, + const void *codeptr_ra) +{ + const char* first_flag_value; + const char* second_flag_value; + if(flags & ompt_cancel_parallel) + first_flag_value = ompt_cancel_flag_t_values[0]; + else if(flags & ompt_cancel_sections) + first_flag_value = ompt_cancel_flag_t_values[1]; + else if(flags & ompt_cancel_loop) + first_flag_value = ompt_cancel_flag_t_values[2]; + else if(flags & ompt_cancel_taskgroup) + first_flag_value = ompt_cancel_flag_t_values[3]; + + if(flags & ompt_cancel_activated) + second_flag_value = ompt_cancel_flag_t_values[4]; + else if(flags & ompt_cancel_detected) + second_flag_value = ompt_cancel_flag_t_values[5]; + else if(flags & ompt_cancel_discarded_task) + second_flag_value = ompt_cancel_flag_t_values[6]; + + printf("%" PRIu64 ": ompt_event_cancel: task_data=%" PRIu64 ", flags=%s|%s=%" PRIu32 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, task_data->value, first_flag_value, second_flag_value, flags, codeptr_ra); +} + +static void +on_ompt_callback_implicit_task( + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + unsigned int team_size, + unsigned int thread_num, + int flags) +{ + switch(endpoint) + { + case ompt_scope_begin: + if(task_data->ptr) + printf("%s\n", "0: task_data initially not null"); + task_data->value = ompt_get_unique_id(); + printf("%" PRIu64 ": ompt_event_implicit_task_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", team_size=%" PRIu32 ", thread_num=%" PRIu32 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, team_size, thread_num); + break; + case ompt_scope_end: + printf("%" PRIu64 ": ompt_event_implicit_task_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", team_size=%" PRIu32 ", thread_num=%" PRIu32 "\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, team_size, thread_num); + break; + } +} + +static void +on_ompt_callback_lock_init( + ompt_mutex_t kind, + unsigned int hint, + unsigned int impl, + ompt_wait_id_t wait_id, + const void *codeptr_ra) +{ + switch(kind) + { + case ompt_mutex_lock: + printf("%" PRIu64 ": ompt_event_init_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + case ompt_mutex_nest_lock: + printf("%" PRIu64 ": ompt_event_init_nest_lock: wait_id=%" PRIu64 ", hint=%" PRIu32 ", impl=%" PRIu32 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, hint, impl, codeptr_ra); + break; + default: + break; + } +} + +static void +on_ompt_callback_lock_destroy( + ompt_mutex_t kind, + ompt_wait_id_t wait_id, + const void *codeptr_ra) +{ + switch(kind) + { + case ompt_mutex_lock: + printf("%" PRIu64 ": ompt_event_destroy_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + case ompt_mutex_nest_lock: + printf("%" PRIu64 ": ompt_event_destroy_nest_lock: wait_id=%" PRIu64 ", codeptr_ra=%p \n", ompt_get_thread_data()->value, wait_id, codeptr_ra); + break; + default: + break; + } +} + +static void +on_ompt_callback_work( + ompt_work_t wstype, + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + uint64_t count, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + switch(wstype) + { + case ompt_work_loop: + printf("%" PRIu64 ": ompt_event_loop_begin: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_sections: + printf("%" PRIu64 ": ompt_event_sections_begin: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_single_executor: + printf("%" PRIu64 ": ompt_event_single_in_block_begin: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_single_other: + printf("%" PRIu64 ": ompt_event_single_others_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_workshare: + //impl + break; + case ompt_work_distribute: + printf("%" PRIu64 ": ompt_event_distribute_begin: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_taskloop: + //impl + printf("%" PRIu64 ": ompt_event_taskloop_begin: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + } + break; + case ompt_scope_end: + switch(wstype) + { + case ompt_work_loop: + printf("%" PRIu64 ": ompt_event_loop_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_sections: + printf("%" PRIu64 ": ompt_event_sections_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_single_executor: + printf("%" PRIu64 ": ompt_event_single_in_block_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_single_other: + printf("%" PRIu64 ": ompt_event_single_others_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_workshare: + //impl + break; + case ompt_work_distribute: + printf("%" PRIu64 ": ompt_event_distribute_end: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + case ompt_work_taskloop: + //impl + printf("%" PRIu64 ": ompt_event_taskloop_end: parallel_id=%" PRIu64 ", parent_task_id=%" PRIu64 ", codeptr_ra=%p, count=%" PRIu64 "\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra, count); + break; + } + break; + } +} + +static void +on_ompt_callback_master( + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + printf("%" PRIu64 ": ompt_event_master_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_scope_end: + printf("%" PRIu64 ": ompt_event_master_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + } +} + +static void on_ompt_callback_parallel_begin( + ompt_data_t *encountering_task_data, + const ompt_frame_t *encountering_task_frame, ompt_data_t *parallel_data, + uint32_t requested_team_size, int flag, const void *codeptr_ra) { + if(parallel_data->ptr) + printf("0: parallel_data initially not null\n"); + parallel_data->value = ompt_get_unique_id(); + printf("%" PRIu64 ": ompt_event_parallel_begin: parent_task_id=%" PRIu64 + ", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, " + "parallel_id=%" PRIu64 ", requested_team_size=%" PRIu32 + ", codeptr_ra=%p, invoker=%d\n", + ompt_get_thread_data()->value, encountering_task_data->value, + encountering_task_frame->exit_frame.ptr, + encountering_task_frame->enter_frame.ptr, parallel_data->value, + requested_team_size, codeptr_ra, flag); +} + +static void on_ompt_callback_parallel_end(ompt_data_t *parallel_data, + ompt_data_t *encountering_task_data, + int flag, const void *codeptr_ra) { + printf("%" PRIu64 ": ompt_event_parallel_end: parallel_id=%" PRIu64 + ", task_id=%" PRIu64 ", invoker=%d, codeptr_ra=%p\n", + ompt_get_thread_data()->value, parallel_data->value, + encountering_task_data->value, flag, codeptr_ra); +} + +static void +on_ompt_callback_task_create( + ompt_data_t *encountering_task_data, + const ompt_frame_t *encountering_task_frame, + ompt_data_t* new_task_data, + int type, + int has_dependences, + const void *codeptr_ra) +{ + if(new_task_data->ptr) + printf("0: new_task_data initially not null\n"); + new_task_data->value = ompt_get_unique_id(); + char buffer[2048]; + + format_task_type(type, buffer); + + //there is no parallel_begin callback for implicit parallel region + //thus it is initialized in initial task + if(type & ompt_task_initial) + { + ompt_data_t *parallel_data; + ompt_get_parallel_info(0, ¶llel_data, NULL); + if(parallel_data->ptr) + printf("%s\n", "0: parallel_data initially not null"); + parallel_data->value = ompt_get_unique_id(); + } + + printf("%" PRIu64 ": ompt_event_task_create: parent_task_id=%" PRIu64 ", parent_task_frame.exit=%p, parent_task_frame.reenter=%p, new_task_id=%" PRIu64 ", codeptr_ra=%p, task_type=%s=%d, has_dependences=%s\n", ompt_get_thread_data()->value, encountering_task_data ? encountering_task_data->value : 0, encountering_task_frame ? encountering_task_frame->exit_frame.ptr : NULL, encountering_task_frame ? encountering_task_frame->enter_frame.ptr : NULL, new_task_data->value, codeptr_ra, buffer, type, has_dependences ? "yes" : "no"); +} + +static void +on_ompt_callback_task_schedule( + ompt_data_t *first_task_data, + ompt_task_status_t prior_task_status, + ompt_data_t *second_task_data) +{ + printf("%" PRIu64 ": ompt_event_task_schedule: first_task_id=%" PRIu64 ", second_task_id=%" PRIu64 ", prior_task_status=%s=%d\n", ompt_get_thread_data()->value, first_task_data->value, second_task_data->value, ompt_task_status_t_values[prior_task_status], prior_task_status); + if(prior_task_status == ompt_task_complete) + { + printf("%" PRIu64 ": ompt_event_task_end: task_id=%" PRIu64 "\n", ompt_get_thread_data()->value, first_task_data->value); + } +} + +static void +on_ompt_callback_dependences( + ompt_data_t *task_data, + const ompt_dependence_t *deps, + int ndeps) +{ + printf("%" PRIu64 ": ompt_event_task_dependences: task_id=%" PRIu64 ", deps=%p, ndeps=%d\n", ompt_get_thread_data()->value, task_data->value, (void *)deps, ndeps); +} + +static void +on_ompt_callback_task_dependence( + ompt_data_t *first_task_data, + ompt_data_t *second_task_data) +{ + printf("%" PRIu64 ": ompt_event_task_dependence_pair: first_task_id=%" PRIu64 ", second_task_id=%" PRIu64 "\n", ompt_get_thread_data()->value, first_task_data->value, second_task_data->value); +} + +static void +on_ompt_callback_thread_begin( + ompt_thread_t thread_type, + ompt_data_t *thread_data) +{ + if(thread_data->ptr) + printf("%s\n", "0: thread_data initially not null"); + thread_data->value = ompt_get_unique_id(); + printf("%" PRIu64 ": ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, ompt_thread_t_values[thread_type], thread_type, thread_data->value); +} + +static void +on_ompt_callback_thread_end( + ompt_data_t *thread_data) +{ + printf("%" PRIu64 ": ompt_event_thread_end: thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, thread_data->value); +} + +static int +on_ompt_callback_control_tool( + uint64_t command, + uint64_t modifier, + void *arg, + const void *codeptr_ra) +{ + ompt_frame_t* omptTaskFrame; + ompt_get_task_info(0, NULL, (ompt_data_t**) NULL, &omptTaskFrame, NULL, NULL); + printf("%" PRIu64 ": ompt_event_control_tool: command=%" PRIu64 ", modifier=%" PRIu64 ", arg=%p, codeptr_ra=%p, current_task_frame.exit=%p, current_task_frame.reenter=%p \n", ompt_get_thread_data()->value, command, modifier, arg, codeptr_ra, omptTaskFrame->exit_frame.ptr, omptTaskFrame->enter_frame.ptr); + return 0; //success +} + +#define register_callback_t(name, type) \ +do{ \ + type f_##name = &on_##name; \ + if (ompt_set_callback(name, (ompt_callback_t)f_##name) == \ + ompt_set_never) \ + printf("0: Could not register callback '" #name "'\n"); \ +}while(0) + +#define register_callback(name) register_callback_t(name, name##_t) + +int ompt_initialize( + ompt_function_lookup_t lookup, + int initial_device_num, + ompt_data_t *tool_data) +{ + ompt_set_callback = (ompt_set_callback_t) lookup("ompt_set_callback"); + ompt_get_callback = (ompt_get_callback_t) lookup("ompt_get_callback"); + ompt_get_state = (ompt_get_state_t) lookup("ompt_get_state"); + ompt_get_task_info = (ompt_get_task_info_t) lookup("ompt_get_task_info"); + ompt_get_thread_data = (ompt_get_thread_data_t) lookup("ompt_get_thread_data"); + ompt_get_parallel_info = (ompt_get_parallel_info_t) lookup("ompt_get_parallel_info"); + ompt_get_unique_id = (ompt_get_unique_id_t) lookup("ompt_get_unique_id"); + + ompt_get_num_procs = (ompt_get_num_procs_t) lookup("ompt_get_num_procs"); + ompt_get_num_places = (ompt_get_num_places_t) lookup("ompt_get_num_places"); + ompt_get_place_proc_ids = (ompt_get_place_proc_ids_t) lookup("ompt_get_place_proc_ids"); + ompt_get_place_num = (ompt_get_place_num_t) lookup("ompt_get_place_num"); + ompt_get_partition_place_nums = (ompt_get_partition_place_nums_t) lookup("ompt_get_partition_place_nums"); + ompt_get_proc_id = (ompt_get_proc_id_t) lookup("ompt_get_proc_id"); + ompt_enumerate_states = (ompt_enumerate_states_t) lookup("ompt_enumerate_states"); + ompt_enumerate_mutex_impls = (ompt_enumerate_mutex_impls_t) lookup("ompt_enumerate_mutex_impls"); + + register_callback(ompt_callback_mutex_acquire); + register_callback_t(ompt_callback_mutex_acquired, ompt_callback_mutex_t); + register_callback_t(ompt_callback_mutex_released, ompt_callback_mutex_t); + register_callback(ompt_callback_nest_lock); + register_callback(ompt_callback_sync_region); + register_callback_t(ompt_callback_sync_region_wait, ompt_callback_sync_region_t); + register_callback(ompt_callback_control_tool); + register_callback(ompt_callback_flush); + register_callback(ompt_callback_cancel); + register_callback(ompt_callback_implicit_task); + register_callback_t(ompt_callback_lock_init, ompt_callback_mutex_acquire_t); + register_callback_t(ompt_callback_lock_destroy, ompt_callback_mutex_t); + register_callback(ompt_callback_work); + register_callback(ompt_callback_master); + register_callback(ompt_callback_parallel_begin); + register_callback(ompt_callback_parallel_end); + register_callback(ompt_callback_task_create); + register_callback(ompt_callback_task_schedule); + register_callback(ompt_callback_dependences); + register_callback(ompt_callback_task_dependence); + register_callback(ompt_callback_thread_begin); + register_callback(ompt_callback_thread_end); + printf("0: NULL_POINTER=%p\n", (void*)NULL); + return 1; //success +} + +void ompt_finalize(ompt_data_t *tool_data) +{ + printf("0: ompt_event_runtime_shutdown\n"); +} + +#ifdef __cplusplus +extern "C" { +#endif +ompt_start_tool_result_t* ompt_start_tool( + unsigned int omp_version, + const char *runtime_version) +{ + static ompt_start_tool_result_t ompt_start_tool_result = {&ompt_initialize,&ompt_finalize, 0}; + return &ompt_start_tool_result; +} +#ifdef __cplusplus +} +#endif diff --git a/final/runtime/test/ompt/cancel/cancel_parallel.c b/final/runtime/test/ompt/cancel/cancel_parallel.c new file mode 100644 index 0000000..b03239d --- /dev/null +++ b/final/runtime/test/ompt/cancel/cancel_parallel.c @@ -0,0 +1,40 @@ +// RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// Current GOMP interface implementation does not support cancellation +// XFAIL: gcc + +#include "callback.h" +#include "omp.h" + +int main() { + #pragma omp parallel num_threads(2) + { + if (omp_get_thread_num() == 0) { + print_fuzzy_address_blocks(get_ompt_label_address(1)); + #pragma omp cancel parallel + define_ompt_label(1); + // We cannot print at this location because the parallel region is cancelled! + } else { + delay(100); + print_fuzzy_address_blocks(get_ompt_label_address(2)); + #pragma omp cancellation point parallel + define_ompt_label(2); + // We cannot print at this location because the parallel region is cancelled! + } + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel' + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=[[NULL]], new_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[NULL]], task_type=ompt_task_initial=1, has_dependences=no + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_parallel|ompt_cancel_activated=17, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-DAG: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_parallel|ompt_cancel_detected=33, codeptr_ra=[[OTHER_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-DAG: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[OTHER_RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/cancel/cancel_taskgroup.c b/final/runtime/test/ompt/cancel/cancel_taskgroup.c new file mode 100644 index 0000000..fce39c9 --- /dev/null +++ b/final/runtime/test/ompt/cancel/cancel_taskgroup.c @@ -0,0 +1,89 @@ +// RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: clang-3, clang-4.0.0 +// Current GOMP interface implementation does not support cancellation; icc 16 has a bug +// XFAIL: gcc, icc-16 + +#include "callback.h" +#include <unistd.h> +#include <stdio.h> + +int main() +{ + int condition=0; + #pragma omp parallel num_threads(2) + {} + + print_frame(0); + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + #pragma omp taskgroup + { + #pragma omp task shared(condition) + { + printf("start execute task 1\n"); + OMPT_SIGNAL(condition); + OMPT_WAIT(condition,2); + #pragma omp cancellation point taskgroup + printf("end execute task 1\n"); + } + #pragma omp task shared(condition) + { + printf("start execute task 2\n"); + OMPT_SIGNAL(condition); + OMPT_WAIT(condition,2); + #pragma omp cancellation point taskgroup + printf("end execute task 2\n"); + } + #pragma omp task shared(condition) + { + printf("start execute task 3\n"); + OMPT_SIGNAL(condition); + OMPT_WAIT(condition,2); + #pragma omp cancellation point taskgroup + printf("end execute task 3\n"); + } + #pragma omp task if(0) shared(condition) + { + printf("start execute task 4\n"); + OMPT_WAIT(condition,1); + #pragma omp cancel taskgroup + printf("end execute task 4\n"); + } + OMPT_SIGNAL(condition); + } + } + #pragma omp barrier + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_master' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_master_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[FIRST_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit=4, has_dependences=no + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[SECOND_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit=4, has_dependences=no + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[THIRD_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit=4, has_dependences=no + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID]], parent_task_frame.exit={{0x[0-f]*}}, parent_task_frame.reenter={{0x[0-f]*}}, new_task_id=[[CANCEL_TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}}, task_type=ompt_task_explicit|ompt_task_undeferred=134217732, has_dependences=no + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[PARENT_TASK_ID]], second_task_id=[[CANCEL_TASK_ID]], prior_task_status=ompt_task_switch=7 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[CANCEL_TASK_ID]], flags=ompt_cancel_taskgroup|ompt_cancel_activated=24, codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[CANCEL_TASK_ID]], second_task_id=[[PARENT_TASK_ID]], prior_task_status=ompt_task_cancel=3 + + // CHECK-DAG: {{^}}{{[0-9]+}}: ompt_event_cancel: task_data={{[0-9]+}}, flags=ompt_cancel_taskgroup|ompt_cancel_discarded_task=72, codeptr_ra=[[NULL]] + // CHECK-DAG: {{^}}{{[0-9]+}}: ompt_event_cancel: task_data={{[0-9]+}}, flags=ompt_cancel_taskgroup|ompt_cancel_discarded_task=72, codeptr_ra=[[NULL]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_cancel: task_data={{[0-9]+}}, flags=ompt_cancel_taskgroup|ompt_cancel_detected=40, codeptr_ra={{0x[0-f]*}} + + return 0; +} diff --git a/final/runtime/test/ompt/cancel/cancel_worksharing.c b/final/runtime/test/ompt/cancel/cancel_worksharing.c new file mode 100644 index 0000000..7fa83b2 --- /dev/null +++ b/final/runtime/test/ompt/cancel/cancel_worksharing.c @@ -0,0 +1,67 @@ +// RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// Current GOMP interface implementation does not support cancellation; icc 16 does not distinguish between sections and loops +// XFAIL: gcc, icc-16 + +#include "callback.h" +#include <unistd.h> + +int main() +{ + int condition=0; + #pragma omp parallel num_threads(2) + { + int x = 0; + int i; + #pragma omp for + for(i = 0; i < 2; i++) + { + if(i == 0) + { + x++; + OMPT_SIGNAL(condition); + #pragma omp cancel for + } + else + { + x++; + OMPT_WAIT(condition,1); + delay(10000); + #pragma omp cancellation point for + } + } + } + #pragma omp parallel num_threads(2) + { + #pragma omp sections + { + #pragma omp section + { + OMPT_SIGNAL(condition); + #pragma omp cancel sections + } + #pragma omp section + { + OMPT_WAIT(condition,2); + delay(10000); + #pragma omp cancellation point sections + } + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel' + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_task_create: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=[[NULL]], new_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[NULL]], task_type=ompt_task_initial=1, has_dependences=no + + // cancel for and sections + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_loop|ompt_cancel_activated=20, codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_sections|ompt_cancel_activated=18, codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[OTHER_THREAD_ID:[0-9]+]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_loop|ompt_cancel_detected=36, codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[OTHER_THREAD_ID:[0-9]+]]: ompt_event_cancel: task_data=[[TASK_ID:[0-9]+]], flags=ompt_cancel_sections|ompt_cancel_detected=34, codeptr_ra={{0x[0-f]*}} + + return 0; +} diff --git a/final/runtime/test/ompt/loadtool/tool_available/tool_available.c b/final/runtime/test/ompt/loadtool/tool_available/tool_available.c new file mode 100644 index 0000000..25187fd --- /dev/null +++ b/final/runtime/test/ompt/loadtool/tool_available/tool_available.c @@ -0,0 +1,74 @@ +// The OpenMP standard defines 3 ways of providing ompt_start_tool: +// 1. "statically-linking the tool’s definition of ompt_start_tool into an OpenMP application" +// RUN: %libomp-compile -DCODE -DTOOL && %libomp-run | FileCheck %s + +// Note: We should compile the tool without -fopenmp as other tools developer +// would do. Otherwise this test may pass for the wrong reasons on Darwin. +// RUN: %clang %flags -DTOOL -shared -fPIC %s -o %T/tool.so +// 2. "introducing a dynamically-linked library that includes the tool’s definition of ompt_start_tool into the application’s address space" +// 2.1 Link with tool during compilation +// RUN: %libomp-compile -DCODE %no-as-needed-flag %T/tool.so && %libomp-run | FileCheck %s +// 2.2 Link with tool during compilation, but AFTER the runtime +// RUN: %libomp-compile -DCODE -lomp %no-as-needed-flag %T/tool.so && %libomp-run | FileCheck %s +// 2.3 Inject tool via the dynamic loader +// RUN: %libomp-compile -DCODE && %preload-tool %libomp-run | FileCheck %s + +// 3. "providing the name of a dynamically-linked library appropriate for the architecture and operating system used by the application in the tool-libraries-var ICV" +// RUN: %libomp-compile -DCODE && env OMP_TOOL_LIBRARIES=%T/tool.so %libomp-run | FileCheck %s + +// REQUIRES: ompt + +/* + * This file contains code for an OMPT shared library tool to be + * loaded and the code for the OpenMP executable. + * -DTOOL enables the code for the tool during compilation + * -DCODE enables the code for the executable during compilation + */ + +#ifdef CODE +#include "omp.h" + +int main() +{ + #pragma omp parallel num_threads(2) + { + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}0: ompt_event_runtime_shutdown + + return 0; +} + +#endif /* CODE */ + +#ifdef TOOL + +#include <stdio.h> +#include <omp-tools.h> + +int ompt_initialize( + ompt_function_lookup_t lookup, + ompt_data_t* tool_data) +{ + printf("0: NULL_POINTER=%p\n", (void*)NULL); + return 1; //success +} + +void ompt_finalize(ompt_data_t* tool_data) +{ + printf("0: ompt_event_runtime_shutdown\n"); +} + +ompt_start_tool_result_t* ompt_start_tool( + unsigned int omp_version, + const char *runtime_version) +{ + static ompt_start_tool_result_t ompt_start_tool_result = {&ompt_initialize,&ompt_finalize, 0}; + return &ompt_start_tool_result; +} +#endif /* TOOL */ diff --git a/final/runtime/test/ompt/loadtool/tool_available_search/tool_available_search.c b/final/runtime/test/ompt/loadtool/tool_available_search/tool_available_search.c new file mode 100644 index 0000000..fedfebe --- /dev/null +++ b/final/runtime/test/ompt/loadtool/tool_available_search/tool_available_search.c @@ -0,0 +1,104 @@ +// RUN: %clang %flags -shared -fPIC %s -o %T/first_tool.so +// RUN: %clang %flags -DTOOL -DSECOND_TOOL -shared -fPIC %s -o %T/second_tool.so +// RUN: %clang %flags -DTOOL -DTHIRD_TOOL -shared -fPIC %s -o %T/third_tool.so +// RUN: %libomp-compile -DCODE && env OMP_TOOL_LIBRARIES=%T/non_existing_file.so:%T/first_tool.so:%T/second_tool.so:%T/third_tool.so %libomp-run | FileCheck %s + +// REQUIRES: ompt + +/* + * This file contains code for three OMPT shared library tool to be + * loaded and the code for the OpenMP executable. + * No option enables code for the first shared library + * (without an implementation of ompt_start_tool) during compilation + * -DTOOL -DSECOND_TOOL enables the code for the second tool during compilation + * -DTOOL -DTHIRD_TOOL enables the code for the third tool during compilation + * -DCODE enables the code for the executable during compilation + */ + +#ifdef CODE +#include "stdio.h" +#include "omp.h" +#include "omp-tools.h" + +int main() +{ + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + int result = omp_control_tool(omp_control_tool_start, 0, NULL); + printf("0: control_tool()=%d\n", result); + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback + + // CHECK: {{^}}0: Do not initialize tool + + // CHECK: {{^}}0: Do initialize tool + // CHECK: {{^}}0: Tool initialized + // CHECK: {{^}}0: ompt_event_thread_begin + // CHECK-DAG: {{^}}0: ompt_event_thread_begin + // CHECK-DAG: {{^}}0: control_tool()=-1 + // CHECK: {{^}}0: Tool finalized + + + return 0; +} + +#endif /* CODE */ + +#ifdef TOOL + +#include <omp-tools.h> +#include "stdio.h" + +#ifdef SECOND_TOOL +// The second tool has an implementation of ompt_start_tool that returns NULL +ompt_start_tool_result_t* ompt_start_tool( + unsigned int omp_version, + const char *runtime_version) +{ + printf("0: Do not initialize tool\n"); + return NULL; +} +#elif defined(THIRD_TOOL) +// The third tool has an implementation of ompt_start_tool that returns a +// pointer to a valid instance of ompt_start_tool_result_t + +static void +on_ompt_callback_thread_begin( + ompt_thread_t thread_type, + ompt_data_t *thread_data) +{ + printf("0: ompt_event_thread_begin\n"); +} + +int ompt_initialize( + ompt_function_lookup_t lookup, + ompt_data_t *tool_data) +{ + ompt_set_callback_t ompt_set_callback = (ompt_set_callback_t) lookup("ompt_set_callback"); + ompt_set_callback(ompt_callback_thread_begin, (ompt_callback_t)on_ompt_callback_thread_begin); + printf("0: Tool initialized\n"); + return 1; +} + +void ompt_finalize(ompt_data_t *tool_data) +{ + printf("0: Tool finalized\n"); +} + +ompt_start_tool_result_t* ompt_start_tool( + unsigned int omp_version, + const char *runtime_version) +{ + printf("0: Do initialize tool\n"); + static ompt_start_tool_result_t ompt_start_tool_result = {&ompt_initialize,&ompt_finalize, 0}; + return &ompt_start_tool_result; +} +#endif + +#endif /* TOOL */ diff --git a/final/runtime/test/ompt/loadtool/tool_not_available/tool_not_available.c b/final/runtime/test/ompt/loadtool/tool_not_available/tool_not_available.c new file mode 100644 index 0000000..ea40468 --- /dev/null +++ b/final/runtime/test/ompt/loadtool/tool_not_available/tool_not_available.c @@ -0,0 +1,69 @@ +// The OpenMP standard defines 3 ways of providing ompt_start_tool: +// 1. "statically-linking the tool’s definition of ompt_start_tool into an OpenMP application" +// RUN: %libomp-compile -DCODE -DTOOL && %libomp-run | FileCheck %s + +// Note: We should compile the tool without -fopenmp as other tools developer +// would do. Otherwise this test may pass for the wrong reasons on Darwin. +// RUN: %clang %flags -DTOOL -shared -fPIC %s -o %T/tool.so +// 2. "introducing a dynamically-linked library that includes the tool’s definition of ompt_start_tool into the application’s address space" +// 2.1 Link with tool during compilation +// RUN: %libomp-compile -DCODE %no-as-needed-flag %T/tool.so && %libomp-run | FileCheck %s +// 2.2 Link with tool during compilation, but AFTER the runtime +// RUN: %libomp-compile -DCODE -lomp %no-as-needed-flag %T/tool.so && %libomp-run | FileCheck %s +// 2.3 Inject tool via the dynamic loader +// RUN: %libomp-compile -DCODE && %preload-tool %libomp-run | FileCheck %s + +// 3. "providing the name of a dynamically-linked library appropriate for the architecture and operating system used by the application in the tool-libraries-var ICV" +// RUN: %libomp-compile -DCODE && env OMP_TOOL_LIBRARIES=%T/tool.so %libomp-run | FileCheck %s + +// REQUIRES: ompt + +/* + * This file contains code for an OMPT shared library tool to be + * loaded and the code for the OpenMP executable. + * -DTOOL enables the code for the tool during compilation + * -DCODE enables the code for the executable during compilation + */ + +#ifdef CODE +#include "stdio.h" +#include "omp.h" +#include "omp-tools.h" + +int main() +{ + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + int result = omp_control_tool(omp_control_tool_start, 0, NULL); + printf("0: control_tool()=%d\n", result); + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback + + // CHECK: {{^}}0: Do not initialize tool + // CHECK: {{^}}0: control_tool()=-2 + + + return 0; +} + +#endif /* CODE */ + +#ifdef TOOL + +#include <omp-tools.h> +#include "stdio.h" + +ompt_start_tool_result_t* ompt_start_tool( + unsigned int omp_version, + const char *runtime_version) +{ + printf("0: Do not initialize tool\n"); + return NULL; +} +#endif /* TOOL */ diff --git a/final/runtime/test/ompt/misc/api_calls_from_other_thread.cpp b/final/runtime/test/ompt/misc/api_calls_from_other_thread.cpp new file mode 100644 index 0000000..e2ef1fc --- /dev/null +++ b/final/runtime/test/ompt/misc/api_calls_from_other_thread.cpp @@ -0,0 +1,92 @@ +// RUN: %libomp-cxx-compile-and-run | FileCheck %s +// REQUIRES: ompt, linux + +#include <thread> +#include "callback.h" + +void f() { + ompt_data_t *tdata = ompt_get_thread_data(); + uint64_t tvalue = tdata ? tdata->value : 0; + + printf("%" PRIu64 ": ompt_get_num_places()=%d\n", tvalue, + ompt_get_num_places()); + + printf("%" PRIu64 ": ompt_get_place_proc_ids()=%d\n", tvalue, + ompt_get_place_proc_ids(0, 0, NULL)); + + printf("%" PRIu64 ": ompt_get_place_num()=%d\n", tvalue, + ompt_get_place_num()); + + printf("%" PRIu64 ": ompt_get_partition_place_nums()=%d\n", tvalue, + ompt_get_partition_place_nums(0, NULL)); + + printf("%" PRIu64 ": ompt_get_proc_id()=%d\n", tvalue, ompt_get_proc_id()); + + printf("%" PRIu64 ": ompt_get_num_procs()=%d\n", tvalue, + ompt_get_num_procs()); + + ompt_callback_t callback; + printf("%" PRIu64 ": ompt_get_callback()=%d\n", tvalue, + ompt_get_callback(ompt_callback_thread_begin, &callback)); + + printf("%" PRIu64 ": ompt_get_state()=%d\n", tvalue, ompt_get_state(NULL)); + + int state = ompt_state_undefined; + const char *state_name; + printf("%" PRIu64 ": ompt_enumerate_states()=%d\n", tvalue, + ompt_enumerate_states(state, &state, &state_name)); + + int impl = ompt_mutex_impl_none; + const char *impl_name; + printf("%" PRIu64 ": ompt_enumerate_mutex_impls()=%d\n", tvalue, + ompt_enumerate_mutex_impls(impl, &impl, &impl_name)); + + printf("%" PRIu64 ": ompt_get_thread_data()=%p\n", tvalue, + ompt_get_thread_data()); + + printf("%" PRIu64 ": ompt_get_parallel_info()=%d\n", tvalue, + ompt_get_parallel_info(0, NULL, NULL)); + + printf("%" PRIu64 ": ompt_get_task_info()=%d\n", tvalue, + ompt_get_task_info(0, NULL, NULL, NULL, NULL, NULL)); +} + +int main() { +#pragma omp parallel num_threads(1) + {} + + std::thread t1(f); + t1.join(); + + // Check if libomp supports the callbacks for this test. + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_get_num_places()={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_place_proc_ids()={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_place_num()=-1 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_partition_place_nums()=0 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_proc_id()=-1 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_num_procs()={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_callback()=1 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_state()=0 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_enumerate_states()=1 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_enumerate_mutex_impls()=1 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_thread_data()=[[NULL]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_parallel_info()=0 + + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_task_info()=0 + + return 0; +} diff --git a/final/runtime/test/ompt/misc/api_calls_misc.c b/final/runtime/test/ompt/misc/api_calls_misc.c new file mode 100644 index 0000000..884421e --- /dev/null +++ b/final/runtime/test/ompt/misc/api_calls_misc.c @@ -0,0 +1,72 @@ +// RUN: %libomp-compile && %libomp-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() { +#pragma omp parallel num_threads(1) + { + // ompt_get_callback() + ompt_callback_t callback; + ompt_get_callback(ompt_callback_thread_begin, &callback); + printf("%" PRIu64 ": &on_ompt_callback_thread_begin=%p\n", + ompt_get_thread_data()->value, &on_ompt_callback_thread_begin); + printf("%" PRIu64 ": ompt_get_callback() result=%p\n", + ompt_get_thread_data()->value, callback); + + // ompt_get_state() + printf("%" PRIu64 ": ompt_get_state()=%d\n", ompt_get_thread_data()->value, + ompt_get_state(NULL)); + + // ompt_enumerate_states() + int state = ompt_state_undefined; + const char *state_name; + int steps = 0; + while (ompt_enumerate_states(state, &state, &state_name) && steps < 1000) { + steps++; + if (!state_name) + printf("%" PRIu64 ": state_name is NULL\n", + ompt_get_thread_data()->value); + } + if (steps >= 1000) { + // enumeration did not end after 1000 steps + printf("%" PRIu64 ": states enumeration did not end\n", + ompt_get_thread_data()->value); + } + + // ompt_enumerate_mutex_impls() + int impl = ompt_mutex_impl_none; + const char *impl_name; + steps = 0; + while (ompt_enumerate_mutex_impls(impl, &impl, &impl_name) && + steps < 1000) { + steps++; + if (!impl_name) + printf("%" PRIu64 ": impl_name is NULL\n", + ompt_get_thread_data()->value); + } + if (steps >= 1000) { + // enumeration did not end after 1000 steps + printf("%" PRIu64 ": mutex_impls enumeration did not end\n", + ompt_get_thread_data()->value); + } + } + + // Check if libomp supports the callbacks for this test. + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: &on_ompt_callback_thread_begin + // CHECK-SAME: =[[FUNCTION_POINTER:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_get_callback() result=[[FUNCTION_POINTER]] + + // CHECK: {{^}}[[THREAD_ID]]: ompt_get_state()=1 + + // CHECK-NOT: {{^}}[[THREAD_ID]]: state_name is NULL + // CHECK-NOT: {{^}}[[THREAD_ID]]: states enumeration did not end + + // CHECK-NOT: {{^}}[[THREAD_ID]]: impl_name is NULL + // CHECK-NOT: {{^}}[[THREAD_ID]]: mutex_impls enumeration did not end + + return 0; +} diff --git a/final/runtime/test/ompt/misc/api_calls_places.c b/final/runtime/test/ompt/misc/api_calls_places.c new file mode 100644 index 0000000..3385c9c --- /dev/null +++ b/final/runtime/test/ompt/misc/api_calls_places.c @@ -0,0 +1,88 @@ +// RUN: %libomp-compile && env OMP_PLACES=cores %libomp-run | FileCheck %s +// REQUIRES: ompt, linux +#include "callback.h" +#include <omp.h> +#define __USE_GNU +#include <sched.h> +#undef __USE_GNU + +void print_list(char *function_name, int size, int list[]) { + printf("%" PRIu64 ": %s(0)=(%d", ompt_get_thread_data()->value, function_name, + list[0]); + int i; + for (i = 1; i < size; i++) { + printf(",%d", list[i]); + } + printf(")\n"); +} + +int main() { +#pragma omp parallel num_threads(1) + { + printf("%" PRIu64 ": omp_get_num_places()=%d\n", + ompt_get_thread_data()->value, omp_get_num_places()); + printf("%" PRIu64 ": ompt_get_num_places()=%d\n", + ompt_get_thread_data()->value, ompt_get_num_places()); + + int omp_ids_size = omp_get_place_num_procs(0); + int omp_ids[omp_ids_size]; + omp_get_place_proc_ids(0, omp_ids); + print_list("omp_get_place_proc_ids", omp_ids_size, omp_ids); + int ompt_ids_size = ompt_get_place_proc_ids(0, 0, NULL); + int ompt_ids[ompt_ids_size]; + ompt_get_place_proc_ids(0, ompt_ids_size, ompt_ids); + print_list("ompt_get_place_proc_ids", ompt_ids_size, ompt_ids); + + printf("%" PRIu64 ": omp_get_place_num()=%d\n", + ompt_get_thread_data()->value, omp_get_place_num()); + printf("%" PRIu64 ": ompt_get_place_num()=%d\n", + ompt_get_thread_data()->value, ompt_get_place_num()); + + int omp_nums_size = omp_get_partition_num_places(); + int omp_nums[omp_nums_size]; + omp_get_partition_place_nums(omp_nums); + print_list("omp_get_partition_place_nums", omp_nums_size, omp_nums); + int ompt_nums_size = ompt_get_partition_place_nums(0, omp_nums); + int ompt_nums[ompt_nums_size]; + ompt_get_partition_place_nums(ompt_nums_size, ompt_nums); + print_list("ompt_get_partition_place_nums", ompt_nums_size, ompt_nums); + + printf("%" PRIu64 ": sched_getcpu()=%d\n", ompt_get_thread_data()->value, + sched_getcpu()); + printf("%" PRIu64 ": ompt_get_proc_id()=%d\n", + ompt_get_thread_data()->value, ompt_get_proc_id()); + + printf("%" PRIu64 ": omp_get_num_procs()=%d\n", + ompt_get_thread_data()->value, omp_get_num_procs()); + printf("%" PRIu64 ": ompt_get_num_procs()=%d\n", + ompt_get_thread_data()->value, ompt_get_num_procs()); + } + + // Check if libomp supports the callbacks for this test. + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: omp_get_num_places + // CHECK-SAME: ()=[[NUM_PLACES:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_num_places()=[[NUM_PLACES]] + + // CHECK: {{^}}[[MASTER_ID]]: omp_get_place_proc_ids + // CHECK-SAME: (0)=([[PROC_IDS:[0-9\,]+]]) + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_place_proc_ids(0)=([[PROC_IDS]]) + + // CHECK: {{^}}[[MASTER_ID]]: omp_get_place_num()=[[PLACE_NUM:[-]?[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_place_num()=[[PLACE_NUM]] + + // CHECK: {{^}}[[MASTER_ID]]: omp_get_partition_place_nums + // CHECK-SAME: (0)=([[PARTITION_PLACE_NUMS:[0-9\,]+]]) + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_partition_place_nums + // CHECK-SAME: (0)=([[PARTITION_PLACE_NUMS]]) + + // CHECK: {{^}}[[MASTER_ID]]: sched_getcpu()=[[CPU_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_proc_id()=[[CPU_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: omp_get_num_procs()=[[NUM_PROCS:[-]?[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_get_num_procs()=[[NUM_PROCS]] + + return 0; +} diff --git a/final/runtime/test/ompt/misc/control_tool.c b/final/runtime/test/ompt/misc/control_tool.c new file mode 100644 index 0000000..7995614 --- /dev/null +++ b/final/runtime/test/ompt/misc/control_tool.c @@ -0,0 +1,30 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +// XFAIL: powerpc64le, ppc64le +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> + +int main() +{ + #pragma omp parallel num_threads(1) + { + print_frame_from_outlined_fn(1); + print_frame(0); + omp_control_tool(omp_control_tool_flush, 1, NULL); + print_current_address(0); + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_control_tool' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: __builtin_frame_address({{.}})=[[EXIT_FRAME:0x[0-f]*]] + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[REENTER_FRAME:0x[0-f]*]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_control_tool: command=3, modifier=1, arg=[[NULL]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]*]], current_task_frame.exit=[[EXIT_FRAME]], current_task_frame.reenter={{0x[0-f]*}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/misc/control_tool_no_ompt_support.c b/final/runtime/test/ompt/misc/control_tool_no_ompt_support.c new file mode 100644 index 0000000..23daf8b --- /dev/null +++ b/final/runtime/test/ompt/misc/control_tool_no_ompt_support.c @@ -0,0 +1,15 @@ +// RUN: %libomp-compile-and-run + +// REQUIRES: openmp-5.0 + +#include <omp.h> + +int main() +{ + #pragma omp parallel num_threads(1) + { + omp_control_tool(omp_control_tool_flush, 1, NULL); + } + + return 0; +} diff --git a/final/runtime/test/ompt/misc/interoperability.cpp b/final/runtime/test/ompt/misc/interoperability.cpp new file mode 100644 index 0000000..b07814e --- /dev/null +++ b/final/runtime/test/ompt/misc/interoperability.cpp @@ -0,0 +1,119 @@ +// RUN: %libomp-cxx-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt + +#include <iostream> +#include <thread> +#if !defined(__NetBSD__) +#include <alloca.h> +#else +#include <cstdlib> +#endif + +#include "callback.h" +#include "omp.h" + +int condition = 0; + +void f() { + // Call OpenMP API function to force initialization of OMPT. + // (omp_get_thread_num() does not work because it just returns 0 if the + // runtime isn't initialized yet...) + omp_get_num_threads(); + + // Call alloca() to force availability of frame pointer + void *p = alloca(0); + + OMPT_SIGNAL(condition); + // Wait for both initial threads to arrive that will eventually become the + // master threads in the following parallel region. + OMPT_WAIT(condition, 2); + +#pragma omp parallel num_threads(2) + { + // Wait for all threads to arrive so that no worker thread can be reused... + OMPT_SIGNAL(condition); + OMPT_WAIT(condition, 6); + } +} + +int main() { + std::thread t1(f); + std::thread t2(f); + t1.join(); + t2.join(); +} + +// Check if libomp supports the callbacks for this test. +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin' + +// CHECK: 0: NULL_POINTER=[[NULL:.*$]] + +// first master thread +// CHECK: {{^}}[[MASTER_ID_1:[0-9]+]]: ompt_event_thread_begin: +// CHECK-SAME: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID_1]] + +// CHECK: {{^}}[[MASTER_ID_1]]: ompt_event_task_create: parent_task_id=0 +// CHECK-SAME: parent_task_frame.exit=[[NULL]] +// CHECK-SAME: parent_task_frame.reenter=[[NULL]] +// CHECK-SAME: new_task_id=[[PARENT_TASK_ID_1:[0-9]+]] +// CHECK-SAME: codeptr_ra=[[NULL]], task_type=ompt_task_initial=1 +// CHECK-SAME: has_dependences=no + +// CHECK: {{^}}[[MASTER_ID_1]]: ompt_event_parallel_begin: +// CHECK-SAME: parent_task_id=[[PARENT_TASK_ID_1]] +// CHECK-SAME: parent_task_frame.exit=[[NULL]] +// CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} +// CHECK-SAME: parallel_id=[[PARALLEL_ID_1:[0-9]+]], requested_team_size=2 +// CHECK-SAME: codeptr_ra=0x{{[0-f]+}}, invoker={{.*}} + +// CHECK: {{^}}[[MASTER_ID_1]]: ompt_event_parallel_end: +// CHECK-SAME: parallel_id=[[PARALLEL_ID_1]], task_id=[[PARENT_TASK_ID_1]] +// CHECK-SAME: invoker={{[0-9]+}} + +// CHECK: {{^}}[[MASTER_ID_1]]: ompt_event_thread_end: +// CHECK-SAME: thread_id=[[MASTER_ID_1]] + +// second master thread +// CHECK: {{^}}[[MASTER_ID_2:[0-9]+]]: ompt_event_thread_begin: +// CHECK-SAME: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID_2]] + +// CHECK: {{^}}[[MASTER_ID_2]]: ompt_event_task_create: parent_task_id=0 +// CHECK-SAME: parent_task_frame.exit=[[NULL]] +// CHECK-SAME: parent_task_frame.reenter=[[NULL]] +// CHECK-SAME: new_task_id=[[PARENT_TASK_ID_2:[0-9]+]] +// CHECK-SAME: codeptr_ra=[[NULL]], task_type=ompt_task_initial=1 +// CHECK-SAME: has_dependences=no + +// CHECK: {{^}}[[MASTER_ID_2]]: ompt_event_parallel_begin: +// CHECK-SAME: parent_task_id=[[PARENT_TASK_ID_2]] +// CHECK-SAME: parent_task_frame.exit=[[NULL]] +// CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} +// CHECK-SAME: parallel_id=[[PARALLEL_ID_2:[0-9]+]] +// CHECK-SAME: requested_team_size=2, codeptr_ra=0x{{[0-f]+}} +// CHECK-SAME: invoker={{.*}} + +// CHECK: {{^}}[[MASTER_ID_2]]: ompt_event_parallel_end: +// CHECK-SAME: parallel_id=[[PARALLEL_ID_2]], task_id=[[PARENT_TASK_ID_2]] +// CHECK-SAME: invoker={{[0-9]+}} + +// CHECK: {{^}}[[MASTER_ID_2]]: ompt_event_thread_end: +// CHECK-SAME: thread_id=[[MASTER_ID_2]] + +// first worker thread +// CHECK: {{^}}[[THREAD_ID_1:[0-9]+]]: ompt_event_thread_begin: +// CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID_1]] + +// CHECK: {{^}}[[THREAD_ID_1]]: ompt_event_thread_end: +// CHECK-SAME: thread_id=[[THREAD_ID_1]] + +// second worker thread +// CHECK: {{^}}[[THREAD_ID_2:[0-9]+]]: ompt_event_thread_begin: +// CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID_2]] + +// CHECK: {{^}}[[THREAD_ID_2]]: ompt_event_thread_end: +// CHECK-SAME: thread_id=[[THREAD_ID_2]] diff --git a/final/runtime/test/ompt/misc/threads.c b/final/runtime/test/ompt/misc/threads.c new file mode 100644 index 0000000..4a0fc6f --- /dev/null +++ b/final/runtime/test/ompt/misc/threads.c @@ -0,0 +1,34 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() { + int x = 0; +#pragma omp parallel num_threads(4) + { +#pragma omp atomic + x++; + } + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[MASTER_ID]] + // CHECK: {{^}}[[WORKER_ID1:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[WORKER_ID1]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[WORKER_ID1]] + // CHECK: {{^}}[[WORKER_ID2:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[WORKER_ID2]] + // CHECK: {{^}}[[WORKER_ID2]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[WORKER_ID2]] + // CHECK: {{^}}[[WORKER_ID3:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[WORKER_ID3]] + // CHECK: {{^}}[[WORKER_ID3]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[WORKER_ID3]] + + return 0; +} diff --git a/final/runtime/test/ompt/misc/threads_nested.c b/final/runtime/test/ompt/misc/threads_nested.c new file mode 100644 index 0000000..0d38dcf --- /dev/null +++ b/final/runtime/test/ompt/misc/threads_nested.c @@ -0,0 +1,40 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() { + + int condition = 0; + int x = 0; + omp_set_nested(1); +#pragma omp parallel num_threads(2) + { +#pragma omp parallel num_threads(2) + { + OMPT_SIGNAL(condition); + OMPT_WAIT(condition, 4); + } + } + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[MASTER_ID]] + // CHECK: {{^}}[[WORKER_ID1:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[WORKER_ID1]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[WORKER_ID1]] + // CHECK: {{^}}[[WORKER_ID2:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[WORKER_ID2]] + // CHECK: {{^}}[[WORKER_ID2]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[WORKER_ID2]] + // CHECK: {{^}}[[WORKER_ID3:[0-9]+]]: ompt_event_thread_begin: + // CHECK-SAME: thread_type=ompt_thread_worker=2, thread_id=[[WORKER_ID3]] + // CHECK: {{^}}[[WORKER_ID3]]: ompt_event_thread_end: + // CHECK-SAME: thread_id=[[WORKER_ID3]] + + return 0; +} diff --git a/final/runtime/test/ompt/misc/unset_callback.c b/final/runtime/test/ompt/misc/unset_callback.c new file mode 100644 index 0000000..9074ad3 --- /dev/null +++ b/final/runtime/test/ompt/misc/unset_callback.c @@ -0,0 +1,29 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() +{ + #pragma omp parallel num_threads(1) + { + + } + ompt_set_callback(ompt_callback_parallel_begin, NULL); + #pragma omp parallel num_threads(1) + { + + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_idle' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_parallel_begin: + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: + // CHECK-NOT: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: + + return 0; +} diff --git a/final/runtime/test/ompt/ompt-signal.h b/final/runtime/test/ompt/ompt-signal.h new file mode 100644 index 0000000..b5c28cf --- /dev/null +++ b/final/runtime/test/ompt/ompt-signal.h @@ -0,0 +1,31 @@ +#if defined(WIN32) || defined(_WIN32) +#include <windows.h> +#define delay() Sleep(1); +#else +#include <unistd.h> +#define delay(t) usleep(t); +#endif + +// These functions are used to provide a signal-wait mechanism to enforce expected scheduling for the test cases. +// Conditional variable (s) needs to be shared! Initialize to 0 + +#define OMPT_SIGNAL(s) ompt_signal(&s) +//inline +void ompt_signal(int* s) +{ + #pragma omp atomic + (*s)++; +} + +#define OMPT_WAIT(s,v) ompt_wait(&s,v) +// wait for s >= v +//inline +void ompt_wait(int *s, int v) +{ + int wait=0; + do{ + delay(10); + #pragma omp atomic read + wait = (*s); + }while(wait<v); +} diff --git a/final/runtime/test/ompt/parallel/dynamic_enough_threads.c b/final/runtime/test/ompt/parallel/dynamic_enough_threads.c new file mode 100644 index 0000000..4c340ba --- /dev/null +++ b/final/runtime/test/ompt/parallel/dynamic_enough_threads.c @@ -0,0 +1,43 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" + +int main() +{ + omp_set_dynamic(1); + + #pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + } + print_fuzzy_address(1); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + + //team-size of 1-4 is expected + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]], team_size={{[1-4]}} + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/dynamic_not_enough_threads.c b/final/runtime/test/ompt/parallel/dynamic_not_enough_threads.c new file mode 100644 index 0000000..f3a6e17 --- /dev/null +++ b/final/runtime/test/ompt/parallel/dynamic_not_enough_threads.c @@ -0,0 +1,43 @@ +// RUN: %libomp-compile && env OMP_THREAD_LIMIT=2 %libomp-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" + +int main() +{ + omp_set_dynamic(1); + + #pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + } + print_fuzzy_address(1); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + + //team-size of 1-4 is expected + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]], team_size={{[1-4]}} + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/max_active_levels_serialized.c b/final/runtime/test/ompt/parallel/max_active_levels_serialized.c new file mode 100644 index 0000000..bbe73ef --- /dev/null +++ b/final/runtime/test/ompt/parallel/max_active_levels_serialized.c @@ -0,0 +1,73 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + omp_set_nested(1); + omp_set_max_active_levels(1); + + #pragma omp parallel num_threads(2) + { + print_ids(0); + print_ids(1); + #pragma omp parallel num_threads(2) + { + print_ids(0); + print_ids(1); + print_ids(2); + } + print_fuzzy_address(1); + } + print_fuzzy_address(2); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + // THREADS: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=2, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=2, codeptr_ra=[[NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=2, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/nested.c b/final/runtime/test/ompt/parallel/nested.c new file mode 100644 index 0000000..d91597b --- /dev/null +++ b/final/runtime/test/ompt/parallel/nested.c @@ -0,0 +1,298 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> +#include <unistd.h> + +int main() +{ + int condition=0; + omp_set_nested(1); + print_frame(0); + + #pragma omp parallel num_threads(4) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_frame(0); + + //get all implicit task events before starting nested: + #pragma omp barrier + + #pragma omp parallel num_threads(4) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_ids(2); + print_frame(0); + OMPT_SIGNAL(condition); + OMPT_WAIT(condition,16); + #pragma omp barrier + print_fuzzy_address(1); + print_ids(0); + } + print_fuzzy_address(2); + print_ids(0); + } + print_fuzzy_address(3); + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // Note that we cannot ensure that the worker threads have already called barrier_end and implicit_task_end before parallel_end! + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + + // THREADS: {{^}}0: NULL_POINTER=[[NULL:.*$]] + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: __builtin_frame_address(0)=[[MAIN_REENTER:0x[0-f]+]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=0x{{[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // nested parallel masters + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // THREADS: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[EXIT]], parent_task_frame.reenter=0x{{[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: __builtin_frame_address({{.}})=[[NESTED_EXIT:0x[0-f]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_EXIT]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // THREADS: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // THREADS: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[NESTED_REENTER:0x[0-f]+]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // explicit barrier + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], codeptr_ra=[[BARRIER_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_EXIT]], reenter_frame=0x{{[0-f]+}} + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[BARRIER_RETURN_ADDRESS]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_EXIT]], reenter_frame=[[NULL]] + // implicit barrier + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]], codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]], codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // implicit barrier + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // nested parallel worker threads + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/nested_lwt.c b/final/runtime/test/ompt/parallel/nested_lwt.c new file mode 100644 index 0000000..8348376 --- /dev/null +++ b/final/runtime/test/ompt/parallel/nested_lwt.c @@ -0,0 +1,334 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> +#include <unistd.h> + +int main() +{ + omp_set_nested(1); + int condition = 0; + + #pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + //get all implicit task events before starting nested: + #pragma omp barrier + #pragma omp parallel num_threads(1) + { + print_ids(0); + print_ids(1); + print_ids(2); + //get all implicit task events before starting nested: + #pragma omp barrier + #pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + print_ids(2); + print_ids(3); + OMPT_SIGNAL(condition); + OMPT_WAIT(condition,16); + } + print_fuzzy_address(1); + } + print_fuzzy_address(2); + } + print_fuzzy_address(3); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=0x{{[0-f]+}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // Note that we cannot ensure that the worker threads have already called barrier_end and implicit_task_end before parallel_end! + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + + + // THREADS: 0: NULL_POINTER=[[NULL:.*$]] + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=[[TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // nested parallel masters + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[NESTED_IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[MASTER_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[NESTED_IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[NESTED_IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[NESTED_IMPLICIT_TASK_ID]], parent_task_frame.exit=[[NESTED_NESTED_TASK_FRAME_EXIT]], parent_task_frame.reenter=[[NESTED_NESTED_TASK_FRAME_ENTER:0x[0-f]+]], parallel_id=[[NESTED_NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_NESTED_TASK_FRAME_EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame=[[NESTED_NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NESTED_TASK_FRAME_EXIT]], reenter_frame=[[NESTED_TASK_FRAME_ENTER]] + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // nested parallel worker threads + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // can't reliably tell which parallel region is the parent... + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id={{[0-9]+}}, task_id={{[0-9]+}} + // THREADS: {{^}}[[THREAD_ID]]: task level 3: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[TASK_FRAME_ENTER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/nested_serialized.c b/final/runtime/test/ompt/parallel/nested_serialized.c new file mode 100644 index 0000000..f87b8f4 --- /dev/null +++ b/final/runtime/test/ompt/parallel/nested_serialized.c @@ -0,0 +1,128 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + omp_set_nested(0); + + #pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + #pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + print_ids(2); + } + print_fuzzy_address(1); + } + print_fuzzy_address(2); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=0x{{[0-f]+}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // Note that we cannot ensure that the worker threads have already called barrier_end and implicit_task_end before parallel_end! + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + + + // THREADS: 0: NULL_POINTER=[[NULL:.*$]] + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/nested_thread_num.c b/final/runtime/test/ompt/parallel/nested_thread_num.c new file mode 100644 index 0000000..f14f87a --- /dev/null +++ b/final/runtime/test/ompt/parallel/nested_thread_num.c @@ -0,0 +1,357 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> +#include <unistd.h> + +int main() { + int condition = 0; + omp_set_nested(1); + print_frame(0); + +#pragma omp parallel num_threads(2) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_frame(0); + +// get all implicit task events before starting nested: +#pragma omp barrier + +#pragma omp parallel num_threads(2) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_ids(2); + print_frame(0); + OMPT_SIGNAL(condition); + OMPT_WAIT(condition, 4); +#pragma omp barrier + print_fuzzy_address(1); + print_ids(0); + } + print_fuzzy_address(2); + print_ids(0); + } + print_fuzzy_address(3); + + return 0; +} +// Check if libomp supports the callbacks for this test. +// CHECK-NOT: {{^}}0: Could not register callback + +// CHECK: 0: NULL_POINTER=[[NULL:.*$]] + +// make sure initial data pointers are null +// CHECK-NOT: 0: parallel_data initially not null +// CHECK-NOT: 0: task_data initially not null +// CHECK-NOT: 0: thread_data initially not null + +// CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: +// CHECK-SAME: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], +// CHECK-SAME: parent_task_frame.exit=[[NULL]], +// CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}}, +// CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], +// CHECK-SAME: requested_team_size=2, +// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, +// CHECK-SAME: invoker=[[PARALLEL_INVOKER:[0-9]+]] + +// CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: +// CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: + +// Note that we cannot ensure that the worker threads have already called +// barrier_end and implicit_task_end before parallel_end! + +// CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: +// CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: + + +// CHECK: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], +// CHECK-SAME: task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] +// CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + +// THREADS: {{^}}0: NULL_POINTER=[[NULL:.*$]] +// THREADS: __builtin_frame_address(0)=[[MAIN_REENTER:0x[0-f]+]] +// THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: +// THREADS-SAME: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], +// THREADS-SAME: parent_task_frame.exit=[[NULL]], +// THREADS-SAME: parent_task_frame.reenter=0x{{[0-f]+}}, +// THREADS-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=2, +// THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, +// THREADS-SAME: invoker=[[PARALLEL_INVOKER:[0-9]+]] + +// nested parallel masters +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: +// THREADS-SAME: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]], +// THREADS-SAME: team_size=2, thread_num=0 + +// THREADS: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], +// THREADS-SAME: reenter_frame=[[NULL]], +// THREADS-SAME: thread_num=0 + +// THREADS: {{^}}[[MASTER_ID]]: task level 1: +// THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], +// THREADS-SAME: task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], +// THREADS-SAME: reenter_frame=0x{{[0-f]+}} + +// THREADS: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: +// THREADS-SAME: parent_task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: parent_task_frame.exit=[[EXIT]], +// THREADS-SAME: parent_task_frame.reenter=0x{{[0-f]+}}, +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], +// THREADS-SAME: requested_team_size=2, +// THREADS-SAME: codeptr_ra=[[NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, +// THREADS-SAME: invoker=[[PARALLEL_INVOKER]] + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]], team_size=2, +// THREADS-SAME: thread_num=0 + +// THREADS: __builtin_frame_address({{.}})=[[NESTED_EXIT:0x[0-f]+]] + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: exit_frame=[[NESTED_EXIT]], reenter_frame=[[NULL]], +// THREADS-SAME: thread_num=0 + +// THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], +// THREADS-SAME: reenter_frame=0x{{[0-f]+}} + +// THREADS: {{^}}[[MASTER_ID]]: task level 2: +// THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]], +// THREADS-SAME: task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], +// THREADS-SAME: reenter_frame=0x{{[0-f]+}} + +// THREADS: __builtin_frame_address(0)=[[NESTED_REENTER:0x[0-f]+]] + +// THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end +// explicit barrier + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: codeptr_ra=[[BARRIER_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: exit_frame=[[NESTED_EXIT]], reenter_frame=0x{{[0-f]+}} + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[BARRIER_RETURN_ADDRESS]] + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: exit_frame=[[NESTED_EXIT]], reenter_frame=[[NULL]] + +// implicit barrier +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: exit_frame=[[NULL]], reenter_frame=[[NULL]] + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: invoker=[[PARALLEL_INVOKER]], +// THREADS-SAME: codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + +// THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], +// THREADS-SAME: reenter_frame=[[NULL]] + +// implicit barrier +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], +// THREADS-SAME: reenter_frame=[[NULL]] + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: +// THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], +// THREADS-SAME: invoker=[[PARALLEL_INVOKER]], +// THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + +// THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + +// Worker of first nesting level + +// THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: +// THREADS-SAME: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]], team_size=2, +// THREADS-SAME: thread_num=[[OUTER_THREADNUM:[0-9]+]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: thread_num=[[OUTER_THREADNUM]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 1: +// THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]], +// THREADS-SAME: task_id=[[PARENT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin: +// THREADS-SAME: parent_task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: parent_task_frame.exit={{0x[0-f]+}}, +// THREADS-SAME: parent_task_frame.reenter={{0x[0-f]+}}, +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=2, +// THREADS-SAME: codeptr_ra=[[NESTED_RETURN_ADDRESS]]{{[0-f][0-f]}}, +// THREADS-SAME: invoker=[[PARALLEL_INVOKER]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]], team_size=2, +// THREADS-SAME: thread_num=[[INNER_THREADNUM:[0-9]+]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]], +// THREADS-SAME: thread_num=[[INNER_THREADNUM]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], +// THREADS-SAME: thread_num=[[OUTER_THREADNUM]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 2: +// THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]], +// THREADS-SAME: task_id=[[PARENT_TASK_ID]] + +// THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[NESTED_IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[NESTED_IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_parallel_end: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + +// THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + +// nested parallel worker threads + +// THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] +// THREADS-SAME: thread_num=[[THREADNUM:[0-9]+]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]] +// THREADS-SAME: thread_num=[[THREADNUM]] + +// can't reliably tell which parallel region is the parent... + +// THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, +// THREADS-SAME: task_id={{[0-9]+}} +// THREADS-SAME: thread_num={{[01]}} + +// THREADS: {{^}}[[THREAD_ID]]: task level 2: +// THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]], +// THREADS-SAME: task_id=[[PARENT_TASK_ID]] +// THREADS-SAME: thread_num=0 + +// THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + +// other nested parallel worker threads + +// THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] +// THREADS-SAME: thread_num=[[THREADNUM:[0-9]+]] + +// THREADS: {{^}}[[THREAD_ID]]: task level 0: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]] +// THREADS-SAME: thread_num=[[THREADNUM]] + +// can't reliably tell which parallel region is the parent... + +// THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id={{[0-9]+}}, +// THREADS-SAME: task_id={{[0-9]+}} +// THREADS-SAME: thread_num={{[01]}} + +// THREADS: {{^}}[[THREAD_ID]]: task level 2: +// THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]], +// THREADS-SAME: task_id=[[PARENT_TASK_ID]] +// THREADS-SAME: thread_num=0 + +// THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: +// THREADS-SAME: parallel_id=[[NESTED_PARALLEL_ID]], +// THREADS-SAME: task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + +// THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: +// THREADS-SAME: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + diff --git a/final/runtime/test/ompt/parallel/nested_threadnum.c b/final/runtime/test/ompt/parallel/nested_threadnum.c new file mode 100644 index 0000000..a248530 --- /dev/null +++ b/final/runtime/test/ompt/parallel/nested_threadnum.c @@ -0,0 +1,62 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#include <omp.h> +#include "callback.h" + +int main() { + omp_set_nested(1); +#pragma omp parallel num_threads(2) + { +#pragma omp barrier +#pragma omp parallel num_threads(2) + { print_frame(0); } + } + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: + // CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: thread_num=[[OUTER_THREAD_NUM1:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: + // CHECK-SAME: parallel_id=[[INNER_PARALLEL_ID1:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: + // CHECK-SAME: parallel_id=[[INNER_PARALLEL_ID1]] + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM1:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM1]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: + // CHECK-SAME: parallel_id=[[INNER_PARALLEL_ID1]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // CHECK-SAME: thread_num=[[OUTER_THREAD_NUM1]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + + // CHECK: {{^}}[[WORKER_ID1:[0-9]+]]: ompt_event_implicit_task_begin: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: thread_num=[[OUTER_THREAD_NUM2:[0-9]+]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_parallel_begin: + // CHECK-SAME: parallel_id=[[INNER_PARALLEL_ID2:[0-9]+]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_implicit_task_begin: + // CHECK-SAME: parallel_id=[[INNER_PARALLEL_ID2]] + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM2:[0-9]+]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_implicit_task_end + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM2]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_parallel_end: + // CHECK-SAME: parallel_id=[[INNER_PARALLEL_ID2]] + // CHECK: {{^}}[[WORKER_ID1]]: ompt_event_implicit_task_end + // CHECK-SAME: thread_num=[[OUTER_THREAD_NUM2]] + + // CHECK: {{^}}[[WORKER_ID2:[0-9]+]]: ompt_event_implicit_task_begin: + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM3:[0-9]+]] + // CHECK: {{^}}[[WORKER_ID2]]: ompt_event_implicit_task_end + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM3]] + + // CHECK: {{^}}[[WORKER_ID3:[0-9]+]]: ompt_event_implicit_task_begin: + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM4:[0-9]+]] + // CHECK: {{^}}[[WORKER_ID3]]: ompt_event_implicit_task_end + // CHECK-SAME: thread_num=[[INNER_THREAD_NUM4]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/no_thread_num_clause.c b/final/runtime/test/ompt/parallel/no_thread_num_clause.c new file mode 100644 index 0000000..e23d89a --- /dev/null +++ b/final/runtime/test/ompt/parallel/no_thread_num_clause.c @@ -0,0 +1,95 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +#include "callback.h" + +int main() +{ + omp_set_num_threads(4); + #pragma omp parallel + { + print_ids(0); + print_ids(1); + } + print_fuzzy_address(1); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=0x{{[0-f]+}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // Note that we cannot ensure that the worker threads have already called barrier_end and implicit_task_end before parallel_end! + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + + + // THREADS: 0: NULL_POINTER=[[NULL:.*$]] + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_thread_begin: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=0, parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=[[NULL]], new_task_id=281474976710658, codeptr_ra=[[NULL]], task_type=ompt_task_initial=1, has_dependences=no + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker={{[0-9]+}} + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/normal.c b/final/runtime/test/ompt/parallel/normal.c new file mode 100644 index 0000000..2cc9ce1 --- /dev/null +++ b/final/runtime/test/ompt/parallel/normal.c @@ -0,0 +1,132 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | %sort-threads \ +// RUN: | FileCheck --check-prefix=THREADS %s +// REQUIRES: ompt +#include "callback.h" + +int main() { +#pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + } + print_fuzzy_address(1); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // Only check callback names, arguments are verified in THREADS below. + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin + + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + + // Note that we cannot ensure that the worker threads have already called + // barrier_end and implicit_task_end before parallel_end! + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end + + // THREADS: 0: NULL_POINTER=[[NULL:.*$]] + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_thread_begin + // THREADS-SAME: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin + // THREADS-SAME: parent_task_id=[[PARENT_TASK_ID:[0-9]+]] + // THREADS-SAME: parent_task_frame.exit=[[NULL]] + // THREADS-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // THREADS-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4 + // THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]] + // THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0 + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1 + // THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]] + // THREADS-SAME: task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end + // parallel_id is 0 because the region ended in the barrier! + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin + // THREADS-SAME: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]] + // THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0 + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1 + // THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]] + // THREADS-SAME: task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end + // parallel_id is 0 because the region ended in the barrier! + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin + // THREADS-SAME: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]] + // THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0 + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1 + // THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]] + // THREADS-SAME: task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end + // parallel_id is 0 because the region ended in the barrier! + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin + // THREADS-SAME: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]] + // THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0 + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1 + // THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]] + // THREADS-SAME: task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end + // parallel_id is 0 because the region ended in the barrier! + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/not_enough_threads.c b/final/runtime/test/ompt/parallel/not_enough_threads.c new file mode 100644 index 0000000..8a0469a --- /dev/null +++ b/final/runtime/test/ompt/parallel/not_enough_threads.c @@ -0,0 +1,90 @@ +// RUN: %libomp-compile && env OMP_THREAD_LIMIT=2 %libomp-run | FileCheck %s +// RUN: %libomp-compile && env OMP_THREAD_LIMIT=2 %libomp-run | %sort-threads \ +// RUN: | FileCheck --check-prefix=THREADS %s + +// REQUIRES: ompt + +#include "callback.h" + +int main() { +#pragma omp parallel num_threads(4) + { + print_ids(0); + print_ids(1); + } + print_fuzzy_address(1); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback + + // Make sure initial data pointers are null. + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // Only check callback names, arguments are verified in THREADS below. + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin + + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + + // Note that we cannot ensure that the worker threads have already called + // barrier_end and implicit_task_end before parallel_end! + + // CHECK-DAG: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin + // CHECK-DAG: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end + + // THREADS: 0: NULL_POINTER=[[NULL:.*$]] + // THREADS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_thread_begin + // THREADS-SAME: thread_type=ompt_thread_initial=1, thread_id=[[MASTER_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin + // THREADS-SAME: parent_task_id=[[PARENT_TASK_ID:[0-9]+]] + // THREADS-SAME: parent_task_frame.exit=[[NULL]] + // THREADS-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // THREADS-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4 + // THREADS-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]] + // THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[MASTER_ID]]: task level 0 + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: task level 1 + // THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]] + // THREADS-SAME: task_id=[[PARENT_TASK_ID]] + + // THREADS-NOT: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // parallel_id is 0 because the region ended in the barrier! + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_barrier_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: ompt_event_parallel_end + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]] + // THREADS: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // THREADS: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin + // THREADS-SAME: thread_type=ompt_thread_worker=2, thread_id=[[THREAD_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]] + // THREADS-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // THREADS: {{^}}[[THREAD_ID]]: task level 0 + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: task level 1 + // THREADS-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]] + // THREADS-SAME: task_id=[[PARENT_TASK_ID]] + // THREADS-NOT: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + // THREADS-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // parallel_id is 0 because the region ended in the barrier! + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_barrier_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // THREADS: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // THREADS-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/parallel_if0.c b/final/runtime/test/ompt/parallel/parallel_if0.c new file mode 100644 index 0000000..63d6701 --- /dev/null +++ b/final/runtime/test/ompt/parallel/parallel_if0.c @@ -0,0 +1,76 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" + +int main() +{ +// print_frame(0); + #pragma omp parallel if(0) + { +// print_frame(1); + print_ids(0); + print_ids(1); +// print_frame(0); + #pragma omp parallel if(0) + { +// print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); +// print_frame(0); + #pragma omp task + { +// print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); + print_ids(3); + } + } + print_fuzzy_address(1); + } + print_fuzzy_address(2); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_event_implicit_task_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_event_implicit_task_end' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[NESTED_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame={{0x[0-f]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[NESTED_IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id=[[EXPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[NESTED_IMPLICIT_TASK_ID]], second_task_id=[[EXPLICIT_TASK_ID]], prior_task_status=ompt_task_switch=7 + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[EXPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[EXPLICIT_TASK_ID]], second_task_id=[[NESTED_IMPLICIT_TASK_ID]], prior_task_status=ompt_task_complete=1 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_end: task_id=[[EXPLICIT_TASK_ID]] + + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id=0, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[NESTED_RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/parallel/serialized.c b/final/runtime/test/ompt/parallel/serialized.c new file mode 100644 index 0000000..2be17dc --- /dev/null +++ b/final/runtime/test/ompt/parallel/serialized.c @@ -0,0 +1,77 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" + +int main() +{ +// print_frame(0); + #pragma omp parallel num_threads(1) + { +// print_frame(1); + print_ids(0); + print_ids(1); +// print_frame(0); + #pragma omp parallel num_threads(1) + { +// print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); +// print_frame(0); + #pragma omp task + { +// print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); + print_ids(3); + } + } + print_fuzzy_address(1); + } + print_fuzzy_address(2); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_event_implicit_task_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_event_implicit_task_end' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: parallel_data initially not null + // CHECK-NOT: 0: task_data initially not null + // CHECK-NOT: 0: thread_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[OUTER_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[NESTED_PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=[[INNER_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker=[[PARALLEL_INVOKER]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame={{0x[0-f]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[NESTED_IMPLICIT_TASK_ID]], parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id=[[EXPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[NESTED_IMPLICIT_TASK_ID]], second_task_id=[[EXPLICIT_TASK_ID]], prior_task_status=ompt_task_switch=7 + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[EXPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[NESTED_IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: task level 2: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}}, reenter_frame={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[EXPLICIT_TASK_ID]], second_task_id=[[NESTED_IMPLICIT_TASK_ID]], prior_task_status=ompt_task_complete=1 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_end: task_id=[[EXPLICIT_TASK_ID]] + + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id=0, task_id=[[NESTED_IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[NESTED_PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], invoker=[[PARALLEL_INVOKER]], codeptr_ra=[[INNER_RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[INNER_RETURN_ADDRESS]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], invoker=[[PARALLEL_INVOKER]], codeptr_ra=[[OUTER_RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[OUTER_RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/explicit.c b/final/runtime/test/ompt/synchronization/barrier/explicit.c new file mode 100644 index 0000000..d60acd6 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/explicit.c @@ -0,0 +1,58 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + int x = 0; + + #pragma omp parallel num_threads(2) + { + #pragma omp atomic + x++; + + #pragma omp barrier + print_current_address(); + + #pragma omp atomic + x++; + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread explicit barrier + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + // master thread implicit barrier at parallel end + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + + + // worker thread explicit barrier + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[THREAD_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + // worker thread implicit barrier at parallel end + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/for_loop.c b/final/runtime/test/ompt/synchronization/barrier/for_loop.c new file mode 100644 index 0000000..5259447 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/for_loop.c @@ -0,0 +1,56 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + int y[] = {0,1,2,3}; + + #pragma omp parallel num_threads(2) + { + //implicit barrier at end of for loop + int i; + #pragma omp for + for (i = 0; i < 4; i++) + { + y[i]++; + } + print_current_address(); + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread implicit barrier at loop end + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + // master thread implicit barrier at parallel end + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + + // worker thread explicit barrier + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + // worker thread implicit barrier after parallel + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/for_simd.c b/final/runtime/test/ompt/synchronization/barrier/for_simd.c new file mode 100644 index 0000000..351b2c2 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/for_simd.c @@ -0,0 +1,33 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// XFAIL: gcc-4 + +#include "callback.h" +#include <omp.h> + +int main() +{ + int y[] = {0,1,2,3}; + + int i; + #pragma omp for simd + for (i = 0; i < 4; i++) + { + y[i]++; + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread implicit barrier at simd loop end + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/implicit_task_data.c b/final/runtime/test/ompt/synchronization/barrier/implicit_task_data.c new file mode 100644 index 0000000..c933e89 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/implicit_task_data.c @@ -0,0 +1,150 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt + +// This test checks that values stored in task_data in a barrier_begin event +// are still present in the corresponding barrier_end event. +// Therefore, callback implementations different from the ones in callback.h are neccessary. +// This is a test for an issue reported in +// https://github.com/OpenMPToolsInterface/LLVM-openmp/issues/39 + +#define _BSD_SOURCE +#include <stdio.h> +#include <unistd.h> +#include <inttypes.h> +#include <omp.h> +#include <omp-tools.h> + +static const char* ompt_thread_t_values[] = { + NULL, + "ompt_thread_initial", + "ompt_thread_worker", + "ompt_thread_other" +}; + +static ompt_get_unique_id_t ompt_get_unique_id; +static ompt_get_thread_data_t ompt_get_thread_data; + +int main() +{ + #pragma omp parallel num_threads(4) + { + #pragma omp master + { + sleep(1); + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread implicit barrier at parallel end + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id=0, task_id=[[TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra={{0x[0-f]*}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra={{0x[0-f]*}} + + + // worker thread implicit barrier at parallel end + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id=0, task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id=0, task_id=[[TASK_ID]], codeptr_ra=[[NULL]] + + return 0; +} + +static void +on_ompt_callback_thread_begin( + ompt_thread_t thread_type, + ompt_data_t *thread_data) +{ + if(thread_data->ptr) + printf("%s\n", "0: thread_data initially not null"); + thread_data->value = ompt_get_unique_id(); + printf("%" PRIu64 ": ompt_event_thread_begin: thread_type=%s=%d, thread_id=%" PRIu64 "\n", ompt_get_thread_data()->value, ompt_thread_t_values[thread_type], thread_type, thread_data->value); +} + +static void +on_ompt_callback_sync_region( + ompt_sync_region_t kind, + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + task_data->value = ompt_get_unique_id(); + if(kind == ompt_sync_region_barrier) + printf("%" PRIu64 ": ompt_event_barrier_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_scope_end: + if(kind == ompt_sync_region_barrier) + printf("%" PRIu64 ": ompt_event_barrier_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + } +} + +static void +on_ompt_callback_sync_region_wait( + ompt_sync_region_t kind, + ompt_scope_endpoint_t endpoint, + ompt_data_t *parallel_data, + ompt_data_t *task_data, + const void *codeptr_ra) +{ + switch(endpoint) + { + case ompt_scope_begin: + if(kind == ompt_sync_region_barrier) + printf("%" PRIu64 ": ompt_event_wait_barrier_begin: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, parallel_data->value, task_data->value, codeptr_ra); + break; + case ompt_scope_end: + if(kind == ompt_sync_region_barrier) + printf("%" PRIu64 ": ompt_event_wait_barrier_end: parallel_id=%" PRIu64 ", task_id=%" PRIu64 ", codeptr_ra=%p\n", ompt_get_thread_data()->value, (parallel_data)?parallel_data->value:0, task_data->value, codeptr_ra); + break; + } +} + +#define register_callback_t(name, type) \ +do{ \ + type f_##name = &on_##name; \ + if (ompt_set_callback(name, (ompt_callback_t)f_##name) == \ + ompt_set_never) \ + printf("0: Could not register callback '" #name "'\n"); \ +}while(0) + +#define register_callback(name) register_callback_t(name, name##_t) + +int ompt_initialize( + ompt_function_lookup_t lookup, + ompt_data_t *tool_data) +{ + ompt_set_callback_t ompt_set_callback; + ompt_set_callback = (ompt_set_callback_t) lookup("ompt_set_callback"); + ompt_get_unique_id = (ompt_get_unique_id_t) lookup("ompt_get_unique_id"); + ompt_get_thread_data = (ompt_get_thread_data_t) lookup("ompt_get_thread_data"); + register_callback(ompt_callback_sync_region); + register_callback_t(ompt_callback_sync_region_wait, ompt_callback_sync_region_t); + register_callback(ompt_callback_thread_begin); + printf("0: NULL_POINTER=%p\n", (void*)NULL); + return 1; //success +} + +void ompt_finalize(ompt_data_t *tool_data) +{ + printf("0: ompt_event_runtime_shutdown\n"); +} + +ompt_start_tool_result_t* ompt_start_tool( + unsigned int omp_version, + const char *runtime_version) +{ + static ompt_start_tool_result_t ompt_start_tool_result = {&ompt_initialize,&ompt_finalize, 0}; + return &ompt_start_tool_result; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/parallel_region.c b/final/runtime/test/ompt/synchronization/barrier/parallel_region.c new file mode 100644 index 0000000..ea0a23f --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/parallel_region.c @@ -0,0 +1,40 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() +{ + int x = 0; + + //implicit barrier at end of a parallel region + #pragma omp parallel num_threads(2) + { + #pragma omp atomic + x++; + } + print_fuzzy_address(); + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread implicit barrier at parallel end + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + + // worker thread implicit barrier at parallel end + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/sections.c b/final/runtime/test/ompt/synchronization/barrier/sections.c new file mode 100644 index 0000000..4e1dfdd --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/sections.c @@ -0,0 +1,63 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() +{ + int x = 0; + + #pragma omp parallel num_threads(2) + { + //implicit barrier after sections with nowait but with lastprivates + //implicit barrier at end of sections + #pragma omp sections + { + #pragma omp section + { + #pragma omp atomic + x++; + } + + #pragma omp section + { + #pragma omp atomic + x++; + } + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread implicit barrier at sections end + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + // master thread implicit barrier at parallel end + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + + // worker thread implicit barrier at sections end + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + // worker thread implicit barrier at parallel end + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/barrier/single.c b/final/runtime/test/ompt/synchronization/barrier/single.c new file mode 100644 index 0000000..8ba8b52 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/barrier/single.c @@ -0,0 +1,61 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + int x = 0; + + #pragma omp parallel num_threads(2) + { + //implicit barrier at end of single + #pragma omp single + { + x++; + } + print_fuzzy_address(); + //critical section to avoid merge of two barriers into one + #pragma omp critical + { + x++; + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // master thread implicit barrier at single end + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // master thread implicit barrier at parallel end + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + + + // worker thread implicit barrier at single end + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // worker thread implicit barrier at parallel end + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_wait_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/critical.c b/final/runtime/test/ompt/synchronization/critical.c new file mode 100644 index 0000000..ed982b7 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/critical.c @@ -0,0 +1,32 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + #pragma omp critical + { + print_current_address(1); + print_ids(0); + } + print_current_address(2); + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_wait_critical: wait_id=[[WAIT_ID:[0-9]+]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_critical: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_critical: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/flush.c b/final/runtime/test/ompt/synchronization/flush.c new file mode 100644 index 0000000..287d035 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/flush.c @@ -0,0 +1,30 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// GCC generates code that does not call the runtime for the flush construct +// XFAIL: gcc + +#include "callback.h" +#include <omp.h> + +int main() { +#pragma omp parallel num_threads(2) + { + int tid = omp_get_thread_num(); + +#pragma omp flush + print_current_address(1); + } + + return 0; +} +// Check if libomp supports the callbacks for this test. +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_flush' + +// CHECK: 0: NULL_POINTER=[[NULL:.*$]] +// CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_flush: +// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] +// CHECK: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] +// +// CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_flush: +// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] +// CHECK: {{^}}[[THREAD_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] diff --git a/final/runtime/test/ompt/synchronization/lock.c b/final/runtime/test/ompt/synchronization/lock.c new file mode 100644 index 0000000..2a934ee --- /dev/null +++ b/final/runtime/test/ompt/synchronization/lock.c @@ -0,0 +1,44 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() +{ + //need to use an OpenMP construct so that OMPT will be initalized + #pragma omp parallel num_threads(1) + print_ids(0); + + omp_lock_t lock; + printf("%" PRIu64 ": &lock: %" PRIu64 "\n", ompt_get_thread_data()->value, (ompt_wait_id_t)(uintptr_t) &lock); + omp_init_lock(&lock); + print_fuzzy_address(1); + omp_set_lock(&lock); + print_fuzzy_address(2); + omp_unset_lock(&lock); + print_fuzzy_address(3); + omp_destroy_lock(&lock); + print_fuzzy_address(4); + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: &lock: [[WAIT_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_init_lock: wait_id=[[WAIT_ID]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_lock: wait_id=[[WAIT_ID]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_destroy_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/master.c b/final/runtime/test/ompt/synchronization/master.c new file mode 100644 index 0000000..8cc2d46 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/master.c @@ -0,0 +1,38 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// GCC generates code that does not call the runtime for the master construct +// XFAIL: gcc + +#include "callback.h" +#include <omp.h> + +int main() { + int x = 0; +#pragma omp parallel num_threads(2) + { +#pragma omp master + { + print_fuzzy_address(1); + x++; + } + print_current_address(2); + } + + printf("%" PRIu64 ": x=%d\n", ompt_get_thread_data()->value, x); + + return 0; +} + +// Check if libomp supports the callbacks for this test. +// CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_master' + +// CHECK: 0: NULL_POINTER=[[NULL:.*$]] + +// CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_master_begin: +// CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[TASK_ID:[0-9]+]], +// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} +// CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] +// CHECK: {{^}}[[MASTER_ID]]: ompt_event_master_end: +// CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], +// CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS_END:0x[0-f]+]] +// CHECK: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS_END]] diff --git a/final/runtime/test/ompt/synchronization/nest_lock.c b/final/runtime/test/ompt/synchronization/nest_lock.c new file mode 100644 index 0000000..159048e --- /dev/null +++ b/final/runtime/test/ompt/synchronization/nest_lock.c @@ -0,0 +1,52 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> + +int main() +{ + //need to use an OpenMP construct so that OMPT will be initalized + #pragma omp parallel num_threads(1) + print_ids(0); + + omp_nest_lock_t nest_lock; + printf("%" PRIu64 ": &nest_lock: %lli\n", ompt_get_thread_data()->value, (ompt_wait_id_t)(uintptr_t) &nest_lock); + omp_init_nest_lock(&nest_lock); + print_fuzzy_address(1); + omp_set_nest_lock(&nest_lock); + print_fuzzy_address(2); + omp_set_nest_lock(&nest_lock); + print_fuzzy_address(3); + omp_unset_nest_lock(&nest_lock); + print_fuzzy_address(4); + omp_unset_nest_lock(&nest_lock); + print_fuzzy_address(5); + omp_destroy_nest_lock(&nest_lock); + print_fuzzy_address(6); + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_init_nest_lock: wait_id=[[WAIT_ID:[0-9]+]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_first: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_next: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_prev: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_last: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_destroy_nest_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/ordered.c b/final/runtime/test/ompt/synchronization/ordered.c new file mode 100644 index 0000000..14284a4 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/ordered.c @@ -0,0 +1,32 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + #pragma omp ordered + { + print_current_address(1); + print_ids(0); + } + print_current_address(2); + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_wait_ordered: wait_id=[[WAIT_ID:[0-9]+]], hint={{[0-9]+}}, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_ordered: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_ordered: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/taskgroup.c b/final/runtime/test/ompt/synchronization/taskgroup.c new file mode 100644 index 0000000..7309c0a --- /dev/null +++ b/final/runtime/test/ompt/synchronization/taskgroup.c @@ -0,0 +1,49 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 + +#include "callback.h" +#include <unistd.h> +#include <stdio.h> + +int main() +{ + int condition=0; + int x=0; + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + #pragma omp taskgroup + { + print_current_address(1); + #pragma omp task + { + #pragma omp atomic + x++; + } + } + print_current_address(2); + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_master' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_cancel' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_thread_begin' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_taskgroup_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_taskgroup_begin: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_taskgroup_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_taskgroup_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/taskwait.c b/final/runtime/test/ompt/synchronization/taskwait.c new file mode 100644 index 0000000..cb30f3b --- /dev/null +++ b/final/runtime/test/ompt/synchronization/taskwait.c @@ -0,0 +1,37 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +// XFAIL: powerpc64le, ppc64le +#include "callback.h" +#include <omp.h> + +int main() +{ + int x = 0; + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + #pragma omp task + { + x++; + } + #pragma omp taskwait + print_current_address(1); + } + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_sync_region_wait' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_taskwait_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_taskwait_begin: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_taskwait_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: ompt_event_taskwait_end: parallel_id={{[0-9]+}}, task_id={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-NEXT: {{^}}[[MASTER_ID]]: current_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/test_lock.c b/final/runtime/test/ompt/synchronization/test_lock.c new file mode 100644 index 0000000..d24e4d6 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/test_lock.c @@ -0,0 +1,54 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt + +#include "callback.h" +#include <omp.h> + +int main() +{ + omp_lock_t lock; + omp_init_lock(&lock); + print_fuzzy_address(1); + + omp_test_lock(&lock); + print_fuzzy_address(2); + omp_unset_lock(&lock); + print_fuzzy_address(3); + + omp_set_lock(&lock); + print_fuzzy_address(4); + omp_test_lock(&lock); + print_fuzzy_address(5); + omp_unset_lock(&lock); + print_fuzzy_address(6); + + omp_destroy_lock(&lock); + print_fuzzy_address(7); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_init_lock: wait_id=[[WAIT_ID:[0-9]+]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_destroy_lock: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/test_nest_lock.c b/final/runtime/test/ompt/synchronization/test_nest_lock.c new file mode 100644 index 0000000..ad02d32 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/test_nest_lock.c @@ -0,0 +1,42 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt + +#include "callback.h" +#include <omp.h> + +int main() +{ + omp_nest_lock_t nest_lock; + omp_init_nest_lock(&nest_lock); + + omp_test_nest_lock(&nest_lock); + omp_unset_nest_lock(&nest_lock); + + omp_set_nest_lock(&nest_lock); + omp_test_nest_lock(&nest_lock); + omp_unset_nest_lock(&nest_lock); + omp_unset_nest_lock(&nest_lock); + + omp_destroy_nest_lock(&nest_lock); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_init_nest_lock: wait_id=[[WAIT_ID:[0-9]+]], hint=0, impl={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_first: wait_id=[[WAIT_ID]], codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_last: wait_id=[[WAIT_ID]], codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_first: wait_id=[[WAIT_ID]], codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_next: wait_id=[[WAIT_ID]], codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_prev: wait_id=[[WAIT_ID]], codeptr_ra={{0x[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_last: wait_id=[[WAIT_ID]], codeptr_ra={{0x[0-f]+}} + + return 0; +} diff --git a/final/runtime/test/ompt/synchronization/test_nest_lock_parallel.c b/final/runtime/test/ompt/synchronization/test_nest_lock_parallel.c new file mode 100644 index 0000000..e9240f7 --- /dev/null +++ b/final/runtime/test/ompt/synchronization/test_nest_lock_parallel.c @@ -0,0 +1,60 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#include "callback.h" +#include <omp.h> + +int main() +{ + omp_nest_lock_t nest_lock; + omp_init_nest_lock(&nest_lock); + + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + omp_set_nest_lock(&nest_lock); + print_fuzzy_address(1); + } + #pragma omp barrier + omp_test_nest_lock(&nest_lock); //should fail for non-master + print_fuzzy_address(2); + #pragma omp barrier + #pragma omp master + { + omp_unset_nest_lock(&nest_lock); + print_fuzzy_address(3); + omp_unset_nest_lock(&nest_lock); + print_fuzzy_address(4); + } + } + + omp_destroy_nest_lock(&nest_lock); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_nest_lock' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID:[0-9]+]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_first: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_acquired_nest_lock_next: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_prev: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_release_nest_lock_last: wait_id=[[WAIT_ID]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NEXT: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_destroy_nest_lock: wait_id=[[WAIT_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_wait_nest_lock: wait_id=[[WAIT_ID]], hint=0, impl={{[0-9]+}}, codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-NOT: {{^}}[[THREAD_ID]]: ompt_event_acquired_nest_lock_next: wait_id=[[WAIT_ID]] + // CHECK-NEXT: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/dependences.c b/final/runtime/test/ompt/tasks/dependences.c new file mode 100644 index 0000000..57b61f9 --- /dev/null +++ b/final/runtime/test/ompt/tasks/dependences.c @@ -0,0 +1,61 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 + +#include "callback.h" +#include <omp.h> +#include <math.h> +#include <unistd.h> + +int main() +{ + int x = 0; + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + print_ids(0); + #pragma omp task depend(out:x) + { + x++; + delay(100); + } + print_fuzzy_address(1); + print_ids(0); + + #pragma omp task depend(in:x) + { + x = -1; + } + print_ids(0); + } + } + + x++; + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_dependences' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_dependence' + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: new_task_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT:0x[0-f]+]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit=[[EXIT]], parent_task_frame.reenter={{0x[0-f]+}}, new_task_id=[[FIRST_TASK:[0-f]+]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, task_type=ompt_task_explicit=4, has_dependences=yes + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_dependences: task_id=[[FIRST_TASK]], deps={{0x[0-f]+}}, ndeps=1 + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit=[[EXIT]], parent_task_frame.reenter={{0x[0-f]+}}, new_task_id=[[SECOND_TASK:[0-f]+]], codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit=4, has_dependences=yes + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_dependences: task_id=[[SECOND_TASK]], deps={{0x[0-f]+}}, ndeps=1 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_dependence_pair: first_task_id=[[FIRST_TASK]], second_task_id=[[SECOND_TASK]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/explicit_task.c b/final/runtime/test/ompt/tasks/explicit_task.c new file mode 100644 index 0000000..65bc1b2 --- /dev/null +++ b/final/runtime/test/ompt/tasks/explicit_task.c @@ -0,0 +1,102 @@ +// RUN: %libomp-compile-and-run | %sort-threads | tee %s.out | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> + +int main() +{ + int condition=0; + omp_set_nested(0); + print_frame(0); + #pragma omp parallel num_threads(2) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_frame(0); + #pragma omp master + { + print_ids(0); + #pragma omp task shared(condition) + { + OMPT_SIGNAL(condition); + print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); + } + print_fuzzy_address(1); + OMPT_WAIT(condition,1); + print_ids(0); + } + #pragma omp barrier + print_ids(0); + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: new_task_data initially not null + + // CHECK--doesnotwork: {{^}}[[MASTER_ID:[0-9]+]]: __builtin_frame_address(0)=[[MAIN_REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=0x{{[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=2, codeptr_ra=0x{{[0-f]+}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + // nested parallel masters + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // <- ompt_event_task_create would be expected here + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[EXIT]], parent_task_frame.reenter=0x{{[0-f]+}}, new_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // explicit barrier after master + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // implicit barrier parallel + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // this is expected to come earlier and at MASTER: + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[IMPLICIT_TASK_ID]], second_task_id=[[TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(1)=[[TASK_EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], exit_frame=[[TASK_EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[TASK_ID]], second_task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_end: task_id=[[TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/serialized.c b/final/runtime/test/ompt/tasks/serialized.c new file mode 100644 index 0000000..b1ef45d --- /dev/null +++ b/final/runtime/test/ompt/tasks/serialized.c @@ -0,0 +1,154 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> +#include <math.h> + +int main() { + omp_set_nested(0); + print_frame(0); +#pragma omp parallel num_threads(2) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_frame(0); +#pragma omp master + { + print_ids(0); + void *creator_frame = get_frame_address(0); + int t = (int)sin(0.1); +#pragma omp task if (t) + { + void *task_frame = get_frame_address(0); + if (creator_frame == task_frame) { + // Assume this code was inlined which the compiler is allowed to do. + print_frame(0); + } else { + // The exit frame must be our parent! + print_frame_from_outlined_fn(1); + } + print_ids(0); + print_ids(1); + print_ids(2); + } + print_fuzzy_address(1); + print_ids(0); + } + print_ids(0); + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: new_task_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_task_create + // CHECK-SAME: parent_task_id={{[0-9]+}}, parent_task_frame.exit=[[NULL]] + // CHECK-SAME: parent_task_frame.reenter=[[NULL]] + // CHECK-SAME: new_task_id={{[0-9]+}}, codeptr_ra=[[NULL]] + // CHECK-SAME: task_type=ompt_task_initial=1, has_dependences=no + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address(0) + // CHECK-SAME: =[[MAIN_REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin + // CHECK-SAME: parent_task_id=[[PARENT_TASK_ID:[0-9]+]] + // CHECK-SAME: parent_task_frame.exit=[[NULL]] + // CHECK-SAME: parent_task_frame.reenter=0x{{[0-f]+}} + // CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=2 + // CHECK-SAME: codeptr_ra=0x{{[0-f]+}}, invoker={{[0-9]+}} + + // nested parallel masters + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address + // CHECK-SAME: =[[EXIT:0x[0-f]+]] + + // CHECK: {{^}}[[MASTER_ID]]: task level 0 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: exit_frame=[[EXIT]], reenter_frame=[[NULL]] + + // CHECK: {{^}}[[MASTER_ID]]: task level 1 + // CHECK-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]] + // CHECK-SAME: task_id=[[PARENT_TASK_ID]], + // CHECK-SAME: exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create + // CHECK-SAME: parent_task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: parent_task_frame.exit=[[EXIT]] + // CHECK-SAME: parent_task_frame.reenter=0x{{[0-f]+}} + // CHECK-SAME: new_task_id=[[TASK_ID:[0-9]+]] + // CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: + // CHECK-SAME: first_task_id=[[IMPLICIT_TASK_ID]], second_task_id=[[TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address + // CHECK-SAME: =[[TASK_EXIT:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]] + // CHECK-SAME: exit_frame=[[TASK_EXIT]], reenter_frame=[[NULL]] + + // CHECK: {{^}}[[MASTER_ID]]: task level 1 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + + // CHECK: {{^}}[[MASTER_ID]]: task level 2 + // CHECK-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]] + // CHECK-SAME: task_id=[[PARENT_TASK_ID]] + // CHECK-SAME: exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule + // CHECK-SAME: first_task_id=[[TASK_ID]], second_task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_end: task_id=[[TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[RETURN_ADDRESS]] + + // CHECK: {{^}}[[MASTER_ID]]: task level 0 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: exit_frame=[[EXIT]], reenter_frame=[[NULL]] + + // implicit barrier parallel + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end + // parallel_id is 0 because the region ended in the barrier! + // CHECK-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end + // CHECK-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address + // CHECK-SAME: =[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1 + // CHECK-SAME: parallel_id=[[IMPLICIT_PARALLEL_ID]] + // CHECK-SAME: task_id=[[PARENT_TASK_ID]] + // CHECK-SAME: exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(0)={{0x[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0 + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK-SAME: exit_frame=[[NULL]], reenter_frame=[[NULL]] + // parallel_id is 0 because the region ended in the barrier! + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end + // CHECK-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end + // CHECK-SAME: parallel_id=0, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/task_in_joinbarrier.c b/final/runtime/test/ompt/tasks/task_in_joinbarrier.c new file mode 100644 index 0000000..8228add --- /dev/null +++ b/final/runtime/test/ompt/tasks/task_in_joinbarrier.c @@ -0,0 +1,91 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> + +int main() +{ + int condition=0; + omp_set_nested(0); + print_frame(0); + #pragma omp parallel num_threads(2) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_frame(0); + #pragma omp master + { + print_ids(0); + #pragma omp task shared(condition) + { + OMPT_SIGNAL(condition); + print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); + } + OMPT_WAIT(condition,1); + print_ids(0); + } + print_ids(0); + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: new_task_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: __builtin_frame_address(0)=[[MAIN_REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=0x{{[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=2, codeptr_ra=0x{{[0-f]+}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + // nested parallel masters + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // <- ompt_event_task_create would be expected here + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[EXIT]], parent_task_frame.reenter=0x{{[0-f]+}}, new_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[TASK_FUNCTION:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // implicit barrier parallel + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // implicit barrier parallel + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[IMPLICIT_TASK_ID]], second_task_id=[[TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(1)=[[TASK_EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], exit_frame=[[TASK_EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[TASK_ID]], second_task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_end: task_id=[[TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/task_types.c b/final/runtime/test/ompt/tasks/task_types.c new file mode 100644 index 0000000..40ceb2d --- /dev/null +++ b/final/runtime/test/ompt/tasks/task_types.c @@ -0,0 +1,222 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt +#include "callback.h" +#include <omp.h> +#include <math.h> + +int main() { + //initialize the OpenMP runtime + omp_get_num_threads(); + + // initial task + print_ids(0); + + int x; +// implicit task +#pragma omp parallel num_threads(1) + { + print_ids(0); + x++; + } + +#pragma omp parallel num_threads(2) + { +// explicit task +#pragma omp single +#pragma omp task + { + print_ids(0); + x++; + } +// explicit task with undeferred +#pragma omp single +#pragma omp task if (0) + { + print_ids(0); + x++; + } + +// explicit task with untied +#pragma omp single +#pragma omp task untied + { + // Output of thread_id is needed to know on which thread task is executed + printf("%" PRIu64 ": explicit_untied\n", ompt_get_thread_data()->value); + print_ids(0); + print_frame(1); + x++; +#pragma omp taskyield + printf("%" PRIu64 ": explicit_untied(2)\n", + ompt_get_thread_data()->value); + print_ids(0); + print_frame(1); + x++; +#pragma omp taskwait + printf("%" PRIu64 ": explicit_untied(3)\n", + ompt_get_thread_data()->value); + print_ids(0); + print_frame(1); + x++; + } +// explicit task with final +#pragma omp single +#pragma omp task final(1) + { + print_ids(0); + x++; +// nested explicit task with final and undeferred +#pragma omp task + { + print_ids(0); + x++; + } + } + + // Mergeable task test deactivated for now + // explicit task with mergeable + /* + #pragma omp task mergeable if((int)sin(0)) + { + print_ids(0); + x++; + } + */ + + // TODO: merged task + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_task_create: parent_task_id=0 + // CHECK-SAME: parent_task_frame.exit=[[NULL]] + // CHECK-SAME: parent_task_frame.reenter=[[NULL]] + // CHECK-SAME: new_task_id=[[INITIAL_TASK_ID:[0-9]+]], codeptr_ra=[[NULL]] + // CHECK-SAME: task_type=ompt_task_initial=1, has_dependences=no + + // CHECK-NOT: 0: parallel_data initially not null + + // initial task + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id={{[0-9]+}} + // CHECK-SAME: task_id=[[INITIAL_TASK_ID]], exit_frame=[[NULL]] + // CHECK-SAME: reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_initial=1, thread_num=0 + + // implicit task + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id={{[0-9]+}} + // CHECK-SAME: task_id={{[0-9]+}}, exit_frame={{0x[0-f]+}} + // CHECK-SAME: reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_implicit|ompt_task_undeferred=134217730 + // CHECK-SAME: thread_num=0 + + // explicit task + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}} + // CHECK-SAME: parent_task_frame.exit={{0x[0-f]+}} + // CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // CHECK-SAME: new_task_id=[[EXPLICIT_TASK_ID:[0-9]+]] + // CHECK-SAME: codeptr_ra={{0x[0-f]+}} + // CHECK-SAME: task_type=ompt_task_explicit=4 + // CHECK-SAME: has_dependences=no + + // CHECK: [[THREAD_ID_1:[0-9]+]]: ompt_event_task_schedule: + // CHECK-SAME: second_task_id=[[EXPLICIT_TASK_ID]] + + // CHECK: [[THREAD_ID_1]]: task level 0: parallel_id=[[PARALLEL_ID:[0-9]+]] + // CHECK-SAME: task_id=[[EXPLICIT_TASK_ID]], exit_frame={{0x[0-f]+}} + // CHECK-SAME: reenter_frame=[[NULL]], task_type=ompt_task_explicit=4 + // CHECK-SAME: thread_num={{[01]}} + + // explicit task with undeferred + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}} + // CHECK-SAME: parent_task_frame.exit={{0x[0-f]+}} + // CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // CHECK-SAME: new_task_id=[[EXPLICIT_UNDEFERRED_TASK_ID:[0-9]+]] + // CHECK-SAME: codeptr_ra={{0x[0-f]+}} + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_undeferred=134217732 + // CHECK-SAME: has_dependences=no + + // CHECK: [[THREAD_ID_2:[0-9]+]]: ompt_event_task_schedule: + // CHECK-SAME: second_task_id=[[EXPLICIT_UNDEFERRED_TASK_ID]] + + // CHECK: [[THREAD_ID_2]]: task level 0: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[EXPLICIT_UNDEFERRED_TASK_ID]] + // CHECK-SAME: exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_undeferred=134217732 + // CHECK-SAME: thread_num={{[01]}} + + // explicit task with untied + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}} + // CHECK-SAME: parent_task_frame.exit={{0x[0-f]+}} + // CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // CHECK-SAME: new_task_id=[[EXPLICIT_UNTIED_TASK_ID:[0-9]+]] + // CHECK-SAME: codeptr_ra={{0x[0-f]+}} + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_untied=268435460 + // CHECK-SAME: has_dependences=no + + // Here the thread_id cannot be taken from a schedule event as there + // may be multiple of those + // CHECK: [[THREAD_ID_3:[0-9]+]]: explicit_untied + // CHECK: [[THREAD_ID_3]]: task level 0: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[EXPLICIT_UNTIED_TASK_ID]] + // CHECK-SAME: exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_untied=268435460 + // CHECK-SAME: thread_num={{[01]}} + + // after taskyield + // CHECK: [[THREAD_ID_3_2:[0-9]+]]: explicit_untied(2) + // CHECK: [[THREAD_ID_3_2]]: task level 0: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[EXPLICIT_UNTIED_TASK_ID]] + // CHECK-SAME: exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_untied=268435460 + // CHECK-SAME: thread_num={{[01]}} + + // after taskwait + // CHECK: [[THREAD_ID_3_3:[0-9]+]]: explicit_untied(3) + // CHECK: [[THREAD_ID_3_3]]: task level 0: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[EXPLICIT_UNTIED_TASK_ID]] + // CHECK-SAME: exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_untied=268435460 + // CHECK-SAME: thread_num={{[01]}} + + // explicit task with final + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}} + // CHECK-SAME: parent_task_frame.exit={{0x[0-f]+}} + // CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // CHECK-SAME: new_task_id=[[EXPLICIT_FINAL_TASK_ID:[0-9]+]] + // CHECK-SAME: codeptr_ra={{0x[0-f]+}} + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_final=536870916 + // CHECK-SAME: has_dependences=no + + // CHECK: [[THREAD_ID_4:[0-9]+]]: ompt_event_task_schedule: + // CHECK-SAME: second_task_id=[[EXPLICIT_FINAL_TASK_ID]] + + // CHECK: [[THREAD_ID_4]]: task level 0: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[EXPLICIT_FINAL_TASK_ID]] + // CHECK-SAME: exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_final=536870916 + // CHECK-SAME: thread_num={{[01]}} + + // nested explicit task with final and undeferred + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}} + // CHECK-SAME: parent_task_frame.exit={{0x[0-f]+}} + // CHECK-SAME: parent_task_frame.reenter={{0x[0-f]+}} + // CHECK-SAME: new_task_id=[[NESTED_FINAL_UNDEFERRED_TASK_ID:[0-9]+]] + // CHECK-SAME: codeptr_ra={{0x[0-f]+}} + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_undeferred + // CHECK-SAME:|ompt_task_final=671088644 + // CHECK-SAME: has_dependences=no + + // CHECK: [[THREAD_ID_5:[0-9]+]]: ompt_event_task_schedule: + // CHECK-SAME: second_task_id=[[NESTED_FINAL_UNDEFERRED_TASK_ID]] + + // CHECK: [[THREAD_ID_5]]: task level 0: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[NESTED_FINAL_UNDEFERRED_TASK_ID]] + // CHECK-SAME: exit_frame={{0x[0-f]+}}, reenter_frame=[[NULL]] + // CHECK-SAME: task_type=ompt_task_explicit|ompt_task_undeferred + // CHECK-SAME:|ompt_task_final=671088644 + // CHECK-SAME: thread_num={{[01]}} + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/task_types_serialized.c b/final/runtime/test/ompt/tasks/task_types_serialized.c new file mode 100644 index 0000000..7726f5b --- /dev/null +++ b/final/runtime/test/ompt/tasks/task_types_serialized.c @@ -0,0 +1,113 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// REQUIRES: ompt + +#include "callback.h" +#include <omp.h> + +__attribute__ ((noinline)) // workaround for bug in icc +void print_task_type(int id) +{ + #pragma omp critical + { + int task_type; + char buffer[2048]; + ompt_get_task_info(0, &task_type, NULL, NULL, NULL, NULL); + format_task_type(task_type, buffer); + printf("%" PRIu64 ": id=%d task_type=%s=%d\n", ompt_get_thread_data()->value, id, buffer, task_type); + } +}; + +int main() +{ + //initial task + print_task_type(0); + + int x; + //implicit task + #pragma omp parallel num_threads(1) + { + print_task_type(1); + x++; + } + + #pragma omp parallel num_threads(1) + #pragma omp master + { + //explicit task + #pragma omp task + { + print_task_type(2); + x++; + } + + //explicit task with undeferred + #pragma omp task if(0) + { + print_task_type(3); + x++; + } + + //explicit task with untied + #pragma omp task untied + { + print_task_type(4); + x++; + } + + //explicit task with final + #pragma omp task final(1) + { + print_task_type(5); + x++; + //nested explicit task with final and undeferred + #pragma omp task + { + print_task_type(6); + x++; + } + } + +/* + //TODO:not working + //explicit task with mergeable + #pragma omp task mergeable + { + print_task_type(7); + x++; + } +*/ + + //TODO: merged task + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_task_create: parent_task_id=0, parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=[[NULL]], new_task_id={{[0-9]+}}, codeptr_ra=[[NULL]], task_type=ompt_task_initial=1, has_dependences=no + // CHECK: {{^}}[[MASTER_ID]]: id=0 task_type=ompt_task_initial=1 + // CHECK: {{^}}[[MASTER_ID]]: id=1 task_type=ompt_task_implicit|ompt_task_undeferred=134217730 + + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit|ompt_task_undeferred=134217732, has_dependences=no + // CHECK: {{^[0-9]+}}: id=2 task_type=ompt_task_explicit|ompt_task_undeferred=134217732 + + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit|ompt_task_undeferred=134217732, has_dependences=no + // CHECK: {{^[0-9]+}}: id=3 task_type=ompt_task_explicit|ompt_task_undeferred=134217732 + + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit|ompt_task_undeferred|ompt_task_untied=402653188, has_dependences=no + // CHECK: {{^[0-9]+}}: id=4 task_type=ompt_task_explicit|ompt_task_undeferred|ompt_task_untied=402653188 + + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit|ompt_task_undeferred|ompt_task_final=671088644, has_dependences=no + // CHECK: {{^[0-9]+}}: id=5 task_type=ompt_task_explicit|ompt_task_undeferred|ompt_task_final=671088644 + + // CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit|ompt_task_undeferred|ompt_task_final=671088644, has_dependences=no + // CHECK: {{^[0-9]+}}: id=6 task_type=ompt_task_explicit|ompt_task_undeferred|ompt_task_final=671088644 + + // ___CHECK: {{^[0-9]+}}: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id={{[0-9]+}}, codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit|ompt_task_undeferred=134217732, has_dependences=no + // ___CHECK: {{^[0-9]+}}: id=7 task_type=ompt_task_explicit|ompt_task_undeferred=134217732 + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/taskloop.c b/final/runtime/test/ompt/tasks/taskloop.c new file mode 100644 index 0000000..59a47bf --- /dev/null +++ b/final/runtime/test/ompt/tasks/taskloop.c @@ -0,0 +1,81 @@ +// RUN: %libomp-compile-and-run | FileCheck %s +// RUN: %libomp-compile-and-run | FileCheck --check-prefix=TASKS %s +// REQUIRES: ompt + +// These compilers don't support the taskloop construct +// UNSUPPORTED: gcc-4, gcc-5, icc-16 +// GCC 6 has support for taskloops, but at least 6.3.0 is crashing on this test +// UNSUPPORTED: gcc-6 + +#include "callback.h" +#include <omp.h> + +int main() { + unsigned int i, x; + +#pragma omp parallel num_threads(2) + { +#pragma omp barrier + +#pragma omp master +#pragma omp taskloop + for (i = 0; i < 5; i += 3) { + x++; + } + } + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: + // CHECK-SAME: parent_task_id={{[0-9]+}} + // CHECK-SAME: parallel_id=[[PARALLEL_ID:[0-9]+]] + // CHECK-SAME: requested_team_size=2 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: task_id=[[IMPLICIT_TASK_ID1:[0-9]+]] + // CHECK-SAME: team_size=2, thread_num=0 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_taskgroup_begin: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID1]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_taskloop_begin: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: parent_task_id=[[IMPLICIT_TASK_ID1]] + // CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS:0x[0-f]+]], count=2 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: + // CHECK-SAME: parent_task_id=[[IMPLICIT_TASK_ID1]] + // CHECK-SAME: new_task_id=[[TASK_ID1:[0-9]+]] + // CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-SAME: task_type=ompt_task_explicit=4 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: + // CHECK-SAME: parent_task_id=[[IMPLICIT_TASK_ID1]] + // CHECK-SAME: new_task_id=[[TASK_ID2:[0-9]+]] + // CHECK-SAME: codeptr_ra=[[RETURN_ADDRESS]] + // CHECK-SAME: task_type=ompt_task_explicit=4 + // CHECK-NOT: {{^}}[[MASTER_ID]]: ompt_event_task_create: + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_taskloop_end: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + // CHECK-SAME: parent_task_id=[[IMPLICIT_TASK_ID1]] + // CHECK-SAME: count=2 + // CHECK-DAG: {{^}}[[MASTER_ID]]: ompt_event_wait_taskgroup_begin: + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_wait_taskgroup_end: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID1]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_taskgroup_end: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID1]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id=0 + // CHECK-SAME: task_id=[[IMPLICIT_TASK_ID1]], team_size=2, thread_num=0 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: + // CHECK-SAME: parallel_id=[[PARALLEL_ID]] + + // TASKS: ompt_event_task_create:{{.*}} new_task_id={{[0-9]+}} + // TASKS-SAME: task_type=ompt_task_initial + // TASKS: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_taskloop_begin: + // TASKS: ompt_event_task_create:{{.*}} new_task_id=[[TASK_ID1:[0-9]+]] + // TASKS-SAME: task_type=ompt_task_explicit + // TASKS-DAG: ompt_event_task_create:{{.*}} new_task_id=[[TASK_ID2:[0-9]+]] + // Schedule events: + // TASKS-DAG: {{^.*}}first_task_id={{[0-9]+}}, second_task_id=[[TASK_ID1]] + // TASKS-DAG: {{^.*}}first_task_id=[[TASK_ID1]], second_task_id={{[0-9]+}} + // TASKS-DAG: {{^.*}}first_task_id={{[0-9]+}}, second_task_id=[[TASK_ID2]] + // TASKS-DAG: {{^.*}}first_task_id=[[TASK_ID2]], second_task_id={{[0-9]+}} + // TASKS-NOT: ompt_event_task_schedule + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/taskyield.c b/final/runtime/test/ompt/tasks/taskyield.c new file mode 100644 index 0000000..2dd0fa1 --- /dev/null +++ b/final/runtime/test/ompt/tasks/taskyield.c @@ -0,0 +1,62 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// Current GOMP interface implements taskyield as stub +// XFAIL: gcc + +#include "callback.h" +#include <omp.h> +#include <unistd.h> + +int main() +{ + int condition=0, x=0; + #pragma omp parallel num_threads(2) + { + #pragma omp master + { + #pragma omp task shared(condition) + { + OMPT_SIGNAL(condition); + OMPT_WAIT(condition,2); + } + OMPT_WAIT(condition,1); + #pragma omp task shared(x) + { + x++; + } + printf("%" PRIu64 ": before yield\n", ompt_get_thread_data()->value); + #pragma omp taskyield + printf("%" PRIu64 ": after yield\n", ompt_get_thread_data()->value); + OMPT_SIGNAL(condition); + } + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: new_task_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID:[0-9]+]], team_size={{[0-9]+}}, thread_num={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id=[[WORKER_TASK:[0-9]+]], codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit=4, has_dependences=no + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id={{[0-9]+}}, parent_task_frame.exit={{0x[0-f]+}}, parent_task_frame.reenter={{0x[0-f]+}}, new_task_id=[[MAIN_TASK:[0-9]+]], codeptr_ra={{0x[0-f]+}}, task_type=ompt_task_explicit=4, has_dependences=no + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[IMPLICIT_TASK_ID]], second_task_id=[[MAIN_TASK]], prior_task_status=ompt_task_yield=2 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_schedule: first_task_id=[[MAIN_TASK]], second_task_id=[[IMPLICIT_TASK_ID]], prior_task_status=ompt_task_complete=1 + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_task_schedule: first_task_id={{[0-9]+}}, second_task_id=[[WORKER_TASK]], prior_task_status=ompt_task_switch=7 + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[WORKER_TASK]], second_task_id={{[0-9]+}}, prior_task_status=ompt_task_complete=1 + + + + + + return 0; +} diff --git a/final/runtime/test/ompt/tasks/untied_task.c b/final/runtime/test/ompt/tasks/untied_task.c new file mode 100644 index 0000000..4ee3f11 --- /dev/null +++ b/final/runtime/test/ompt/tasks/untied_task.c @@ -0,0 +1,108 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +#define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN +#include "callback.h" +#include <omp.h> + +int main() +{ + int condition=0; + omp_set_nested(0); + print_frame(0); + #pragma omp parallel num_threads(2) + { + print_frame_from_outlined_fn(1); + print_ids(0); + print_ids(1); + print_frame(0); + #pragma omp master + { + print_ids(0); + #pragma omp task untied shared(condition) + { + OMPT_SIGNAL(condition); + print_frame(1); + print_ids(0); + print_ids(1); + print_ids(2); + #pragma omp task if(0) + { + print_ids(0); + print_ids(1); + print_ids(2); + } + print_ids(0); + print_ids(1); + print_ids(2); + } + OMPT_WAIT(condition,1); + print_ids(0); + } + #pragma omp barrier + print_ids(0); + } + + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_create' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_task_schedule' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquire' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_acquired' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_mutex_released' + + + // CHECK: {{^}}0: NULL_POINTER=[[NULL:.*$]] + + // make sure initial data pointers are null + // CHECK-NOT: 0: new_task_data initially not null + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: __builtin_frame_address(0)=[[MAIN_REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter=0x{{[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=2, codeptr_ra=0x{{[0-f]+}}, invoker=[[PARALLEL_INVOKER:[0-9]+]] + // nested parallel masters + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID:[0-9]+]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // <- ompt_event_task_create would be expected here + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_task_create: parent_task_id=[[IMPLICIT_TASK_ID]], parent_task_frame.exit=[[EXIT]], parent_task_frame.reenter=0x{{[0-f]+}}, new_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[TASK_FUNCTION:0x[0-f]+]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // explicit barrier after master + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // implicit barrier parallel + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address({{.}})=[[EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(0)=[[REENTER:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // this is expected to come earlier and at MASTER: + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[IMPLICIT_TASK_ID]], second_task_id=[[TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: __builtin_frame_address(1)=[[TASK_EXIT:0x[0-f]+]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], exit_frame=[[TASK_EXIT]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: task level 1: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[EXIT]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: task level 2: parallel_id=[[IMPLICIT_PARALLEL_ID]], task_id=[[PARENT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_schedule: first_task_id=[[TASK_ID]], second_task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_task_end: task_id=[[TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: task level 0: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]], exit_frame=[[NULL]], reenter_frame=[[NULL]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_barrier_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + + + return 0; +} diff --git a/final/runtime/test/ompt/worksharing/for/auto.c b/final/runtime/test/ompt/worksharing/for/auto.c new file mode 100644 index 0000000..17d26f5 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/auto.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base.h +// REQUIRES: ompt +// GCC doesn't call runtime for auto = static schedule +// XFAIL: gcc + +#define SCHEDULE auto +#include "base.h" diff --git a/final/runtime/test/ompt/worksharing/for/auto_serialized.c b/final/runtime/test/ompt/worksharing/for/auto_serialized.c new file mode 100644 index 0000000..f756166 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/auto_serialized.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_serialized.h +// REQUIRES: ompt +// GCC doesn't call runtime for auto = static schedule +// XFAIL: gcc + +#define SCHEDULE auto +#include "base_serialized.h" diff --git a/final/runtime/test/ompt/worksharing/for/auto_split.c b/final/runtime/test/ompt/worksharing/for/auto_split.c new file mode 100644 index 0000000..d82e3fd --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/auto_split.c @@ -0,0 +1,8 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h +// REQUIRES: ompt +// GCC doesn't call runtime for auto = static schedule +// XFAIL: gcc + +#define SCHEDULE auto +#include "base_split.h" diff --git a/final/runtime/test/ompt/worksharing/for/base.h b/final/runtime/test/ompt/worksharing/for/base.h new file mode 100644 index 0000000..8a496d9 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/base.h @@ -0,0 +1,43 @@ +#include "callback.h" +#include <omp.h> + +int main() +{ + unsigned int i; + + #pragma omp parallel for num_threads(4) schedule(SCHEDULE) + for (i = 0; i < 4; i++) { + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_work' + + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id={{[0-9]+}}, parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=0x{{[0-f]+}}, invoker={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id=[[IMPLICIT_TASK_ID]], codeptr_ra= + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id=[[IMPLICIT_TASK_ID]], codeptr_ra= + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id=[[IMPLICIT_TASK_ID]], codeptr_ra= + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id=[[IMPLICIT_TASK_ID]], codeptr_ra= + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_implicit_task_end: parallel_id={{[0-9]+}}, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/worksharing/for/base_serialized.h b/final/runtime/test/ompt/worksharing/for/base_serialized.h new file mode 100644 index 0000000..3376b37 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/base_serialized.h @@ -0,0 +1,28 @@ +#include "callback.h" +#include <omp.h> + +int main() +{ + unsigned int i; + + #pragma omp parallel for num_threads(1) schedule(SCHEDULE) + for (i = 0; i < 1; i++) { + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_work' + + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id=[[PARENT_TASK_ID:[0-9]+]], parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=1, codeptr_ra=0x{{[0-f]+}}, invoker={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[IMPLICIT_TASK_ID:[0-9]+]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id=[[IMPLICIT_TASK_ID]], codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id=[[IMPLICIT_TASK_ID]] + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_implicit_task_end: parallel_id={{[PARALLEL_ID,0]}}, task_id=[[IMPLICIT_TASK_ID]] + + return 0; +} diff --git a/final/runtime/test/ompt/worksharing/for/base_split.h b/final/runtime/test/ompt/worksharing/for/base_split.h new file mode 100644 index 0000000..0f1fed3 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/base_split.h @@ -0,0 +1,66 @@ +#include "callback.h" +#include <omp.h> + +/* With the combined parallel-for construct (base.h), the return-addresses are hard to compare. + With the separate parallel and for-nowait construct, the addresses become more predictable, + but the begin of the for-loop still generates additional code, so the offset of loop-begin + to the label is >4 Byte. +*/ + +int main() +{ + unsigned int i; + + #pragma omp parallel num_threads(4) + { + print_current_address(0); + #pragma omp for schedule(SCHEDULE) nowait + for (i = 0; i < 4; i++) { + print_fuzzy_address(1); + } + print_fuzzy_address(2); + } + print_fuzzy_address(3); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_begin' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_parallel_end' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_implicit_task' + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_work' + + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id={{[0-9]+}}, parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra=[[PARALLEL_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}}, invoker={{[0-9]+}} + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id={{[0-9]+}}, codeptr_ra=[[LOOP_BEGIN_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, codeptr_ra=[[LOOP_END_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[LOOP_END_RETURN_ADDRESS]] + + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_parallel_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, invoker={{[0-9]+}}, codeptr_ra=[[PARALLEL_RETURN_ADDRESS]] + // CHECK: {{^}}[[MASTER_ID]]: fuzzy_address={{.*}}[[PARALLEL_RETURN_ADDRESS]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, codeptr_ra=[[LOOP_END_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[LOOP_END_RETURN_ADDRESS]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, codeptr_ra=[[LOOP_END_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[LOOP_END_RETURN_ADDRESS]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id={{[0-9]+}}, codeptr_ra=0x{{[0-f]+}} + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_loop_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, codeptr_ra=[[LOOP_END_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK: {{^}}[[THREAD_ID]]: fuzzy_address={{.*}}[[LOOP_END_RETURN_ADDRESS]] + + + // CHECK-LOOP: 0: NULL_POINTER=[[NULL:.*$]] + // CHECK-LOOP: 0: ompt_event_runtime_shutdown + // CHECK-LOOP: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_parallel_begin: parent_task_id={{[0-9]+}}, parent_task_frame.exit=[[NULL]], parent_task_frame.reenter={{0x[0-f]+}}, parallel_id=[[PARALLEL_ID:[0-9]+]], requested_team_size=4, codeptr_ra={{0x[0-f]+}}, invoker={{[0-9]+}} + // CHECK-LOOP: {{^}}[[MASTER_ID]]: ompt_event_loop_begin: parallel_id=[[PARALLEL_ID]], parent_task_id={{[0-9]+}}, codeptr_ra=[[LOOP_BEGIN_RETURN_ADDRESS:0x[0-f]+]]{{[0-f][0-f]}} + // CHECK-LOOP: {{^}}{{[0-9]+}}: fuzzy_address={{.*}}[[LOOP_BEGIN_RETURN_ADDRESS]] + // CHECK-LOOP: {{^}}{{[0-9]+}}: fuzzy_address={{.*}}[[LOOP_BEGIN_RETURN_ADDRESS]] + // CHECK-LOOP: {{^}}{{[0-9]+}}: fuzzy_address={{.*}}[[LOOP_BEGIN_RETURN_ADDRESS]] + // CHECK-LOOP: {{^}}{{[0-9]+}}: fuzzy_address={{.*}}[[LOOP_BEGIN_RETURN_ADDRESS]] + + + return 0; +} diff --git a/final/runtime/test/ompt/worksharing/for/dynamic.c b/final/runtime/test/ompt/worksharing/for/dynamic.c new file mode 100644 index 0000000..ca5ae10 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/dynamic.c @@ -0,0 +1,5 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base.h +// REQUIRES: ompt + +#define SCHEDULE dynamic +#include "base.h" diff --git a/final/runtime/test/ompt/worksharing/for/dynamic_serialized.c b/final/runtime/test/ompt/worksharing/for/dynamic_serialized.c new file mode 100644 index 0000000..0f80929 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/dynamic_serialized.c @@ -0,0 +1,5 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_serialized.h +// REQUIRES: ompt + +#define SCHEDULE dynamic +#include "base_serialized.h" diff --git a/final/runtime/test/ompt/worksharing/for/dynamic_split.c b/final/runtime/test/ompt/worksharing/for/dynamic_split.c new file mode 100644 index 0000000..cf14971 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/dynamic_split.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 + +#define SCHEDULE dynamic +#include "base_split.h" diff --git a/final/runtime/test/ompt/worksharing/for/guided.c b/final/runtime/test/ompt/worksharing/for/guided.c new file mode 100644 index 0000000..01bff4e --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/guided.c @@ -0,0 +1,5 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base.h +// REQUIRES: ompt + +#define SCHEDULE guided +#include "base.h" diff --git a/final/runtime/test/ompt/worksharing/for/guided_serialized.c b/final/runtime/test/ompt/worksharing/for/guided_serialized.c new file mode 100644 index 0000000..4b5096d --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/guided_serialized.c @@ -0,0 +1,5 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_serialized.h +// REQUIRES: ompt + +#define SCHEDULE guided +#include "base_serialized.h" diff --git a/final/runtime/test/ompt/worksharing/for/guided_split.c b/final/runtime/test/ompt/worksharing/for/guided_split.c new file mode 100644 index 0000000..7d560c2 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/guided_split.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 + +#define SCHEDULE guided +#include "base_split.h" diff --git a/final/runtime/test/ompt/worksharing/for/runtime.c b/final/runtime/test/ompt/worksharing/for/runtime.c new file mode 100644 index 0000000..bcf160f --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/runtime.c @@ -0,0 +1,5 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base.h +// REQUIRES: ompt + +#define SCHEDULE runtime +#include "base.h" diff --git a/final/runtime/test/ompt/worksharing/for/runtime_serialized.c b/final/runtime/test/ompt/worksharing/for/runtime_serialized.c new file mode 100644 index 0000000..231d67d --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/runtime_serialized.c @@ -0,0 +1,5 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_serialized.h +// REQUIRES: ompt + +#define SCHEDULE runtime +#include "base_serialized.h" diff --git a/final/runtime/test/ompt/worksharing/for/runtime_split.c b/final/runtime/test/ompt/worksharing/for/runtime_split.c new file mode 100644 index 0000000..7a677ed --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/runtime_split.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h +// REQUIRES: ompt +// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7 + +#define SCHEDULE runtime +#include "base_split.h" diff --git a/final/runtime/test/ompt/worksharing/for/static.c b/final/runtime/test/ompt/worksharing/for/static.c new file mode 100644 index 0000000..4d99059 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/static.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base.h +// REQUIRES: ompt +// GCC doesn't call runtime for static schedule +// XFAIL: gcc + +#define SCHEDULE static +#include "base.h" diff --git a/final/runtime/test/ompt/worksharing/for/static_serialized.c b/final/runtime/test/ompt/worksharing/for/static_serialized.c new file mode 100644 index 0000000..4860d49 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/static_serialized.c @@ -0,0 +1,7 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_serialized.h +// REQUIRES: ompt +// GCC doesn't call runtime for static schedule +// XFAIL: gcc + +#define SCHEDULE static +#include "base_serialized.h" diff --git a/final/runtime/test/ompt/worksharing/for/static_split.c b/final/runtime/test/ompt/worksharing/for/static_split.c new file mode 100644 index 0000000..d8c88dd --- /dev/null +++ b/final/runtime/test/ompt/worksharing/for/static_split.c @@ -0,0 +1,8 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h +// REQUIRES: ompt +// GCC doesn't call runtime for static schedule +// XFAIL: gcc + +#define SCHEDULE static +#include "base_split.h" diff --git a/final/runtime/test/ompt/worksharing/sections.c b/final/runtime/test/ompt/worksharing/sections.c new file mode 100644 index 0000000..bafb743 --- /dev/null +++ b/final/runtime/test/ompt/worksharing/sections.c @@ -0,0 +1,36 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// Some compilers generate code that does not distinguish between sections and loops +// XFAIL: gcc, clang-3, clang-4, clang-5, icc-16, icc-17 +// UNSUPPORTED: icc-18 + +#include "callback.h" +#include <omp.h> + +int main() +{ + #pragma omp parallel sections num_threads(2) + { + #pragma omp section + { + printf("%lu: section 1\n", ompt_get_thread_data()->value); + } + #pragma omp section + { + printf("%lu: section 2\n", ompt_get_thread_data()->value); + } + } + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_work' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK: {{^}}[[MASTER_ID:[0-9]+]]: ompt_event_sections_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], parent_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[SECT_BEGIN:0x[0-f]+]], count=2 + // CHECK: {{^}}[[MASTER_ID]]: ompt_event_sections_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, codeptr_ra=[[SECT_END:0x[0-f]+]] + + // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_sections_begin: parallel_id=[[PARALLEL_ID]], parent_task_id=[[TASK_ID:[0-9]+]], codeptr_ra=[[SECT_BEGIN]], count=2 + // CHECK: {{^}}[[THREAD_ID]]: ompt_event_sections_end: parallel_id=[[PARALLEL_ID]], task_id={{[0-9]+}}, codeptr_ra=[[SECT_END]] + + return 0; +} diff --git a/final/runtime/test/ompt/worksharing/single.c b/final/runtime/test/ompt/worksharing/single.c new file mode 100644 index 0000000..6b24f2d --- /dev/null +++ b/final/runtime/test/ompt/worksharing/single.c @@ -0,0 +1,36 @@ +// RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s +// REQUIRES: ompt +// GCC generates code that does not call the runtime for the single construct +// XFAIL: gcc + +#include "callback.h" +#include <omp.h> + +int main() +{ + int x = 0; + #pragma omp parallel num_threads(2) + { + #pragma omp single + { + printf("%" PRIu64 ": in single\n", ompt_get_thread_data()->value); + x++; + } + } + + printf("x=%d\n", x); + + // Check if libomp supports the callbacks for this test. + // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_work' + + // CHECK: 0: NULL_POINTER=[[NULL:.*$]] + + // CHECK-DAG: {{^}}[[THREAD_ID_1:[0-9]+]]: ompt_event_single_in_block_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], parent_task_id=[[TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]+}}, count=1 + // CHECK-DAG: {{^}}[[THREAD_ID_1]]: in single + // CHECK-DAG: {{^}}[[THREAD_ID_1]]: ompt_event_single_in_block_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra={{0x[0-f]+}}, count=1 + + // CHECK-DAG: {{^}}[[THREAD_ID_2:[0-9]+]]: ompt_event_single_others_begin: parallel_id=[[PARALLEL_ID:[0-9]+]], task_id=[[TASK_ID:[0-9]+]], codeptr_ra={{0x[0-f]+}}, count=1 + // CHECK-DAG: {{^}}[[THREAD_ID_2]]: ompt_event_single_others_end: parallel_id=[[PARALLEL_ID]], task_id=[[TASK_ID]], codeptr_ra={{0x[0-f]+}}, count=1 + + return 0; +} |