[OpenMP][Tool] Update archer to accept new OpenMP 5.1 enum values

[protze.joachim]

Summary

D90752 adds an extra enum entry for ompt_scope_endpoint_t, which makes the related switch statement incomplete.
Also adding cases for newly added barrier variants.

[jdoerfert]

openmp/tools/archer/ompt-tsan.cpp

670

I don't get these changes. Don't we just silently ignore other endpoint values now? Does it make sense to make it explicit?

[protze.joachim]

openmp/tools/archer/ompt-tsan.cpp

558

Keeping the switch here would look like:

switch (endpoint) {
case ompt_scope_begin:
case ompt_scope_beginend:
...
if (endpoint == ompt_scope_begin) break;
[[fallthrough]]
case ompt_scope_end:
...

670

I can go back to the switch statement and list ompt_scope_beginend explicitly. For this callback, ompt_scope_beginend cannot be used according to the OpenMP spec.

[jdoerfert]

What do you think about adding assertions or warnings for the cases that "should not happen"?

openmp/tools/archer/ompt-tsan.cpp

670

can we at least use an assert or warning or something?

[protze.joachim]

I acknowledge the advantage of switch statements, in that they will warn on missing cases in the future. So, I went back to the switch statements.

Regarding the assertions for the cases, which should not happen: I think, this should be covered by the OMPT tests. The OMPT tests fail, if such unexpected callback arguments are passed. Archer can just happily ignore these cases and I added comments for this.

[jdoerfert]

LGTM, thanks!

openmp/tools/archer/ompt-tsan.cpp

 
 #if (defined __APPLE__ && defined __MACH__)
 #include <dlfcn.h>
 #endif
 
 #include "omp-tools.h"
 #include <sys/resource.h>
 
+// Define attribute that indicates that the fall through from the previous
+// case label is intentional and should not be diagnosed by a compiler
+//   Code from libcxx/include/__config
+// Use a function like macro to imply that it must be followed by a semicolon
+#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
+#define KMP_FALLTHROUGH() [[fallthrough]]
+#elif __has_cpp_attribute(clang::fallthrough)
+#define KMP_FALLTHROUGH() [[clang::fallthrough]]
+#elif __has_attribute(fallthrough) || __GNUC__ >= 7
+#define KMP_FALLTHROUGH() __attribute__((__fallthrough__))
+#else
+#define KMP_FALLTHROUGH() ((void)0)
+#endif
+
 static int runOnTsan;
 static int hasReductionCallback;
 
 class ArcherFlags {
 public:
 #if (LLVM_VERSION) >= 40
   int flush_shadow;
 #endif
static void ompt_tsan_implicit_task(ompt_scope_endpoint_t endpoint,
   case ompt_scope_begin:
     if (type & ompt_task_initial) {
       parallel_data->ptr = new ParallelData(nullptr);
     }
     task_data->ptr = new TaskData(ToParallelData(parallel_data));
     TsanHappensAfter(ToParallelData(parallel_data)->GetParallelPtr());
     TsanFuncEntry(ToParallelData(parallel_data)->codePtr);
     break;
-  case ompt_scope_end:
+  case ompt_scope_end: {
     TaskData *Data = ToTaskData(task_data);
     assert(Data->freed == 0 && "Implicit task end should only be called once!");
     Data->freed = 1;
     assert(Data->RefCount == 1 &&
            "All tasks should have finished at the implicit barrier!");
     delete Data;
     TsanFuncExit();
     break;
   }
+  case ompt_scope_beginend:
+    // Should not occur according to OpenMP 5.1
+    // Tested in OMPT tests
+    break;
+  }
 }
 
 static void ompt_tsan_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) {
   TaskData *Data = ToTaskData(task_data);
   switch (endpoint) {
   case ompt_scope_begin:
+  case ompt_scope_beginend:
     TsanFuncEntry(codeptr_ra);
     switch (kind) {
     case ompt_sync_region_barrier_implementation:
     case ompt_sync_region_barrier_implicit:
     case ompt_sync_region_barrier_explicit:
+    case ompt_sync_region_barrier_implicit_parallel:
+    case ompt_sync_region_barrier_implicit_workshare:
+    case ompt_sync_region_barrier_teams:
     case ompt_sync_region_barrier: {
       char BarrierIndex = Data->BarrierIndex;
       TsanHappensBefore(Data->Team->GetBarrierPtr(BarrierIndex));
 
       if (hasReductionCallback < ompt_set_always) {
         // We ignore writes inside the barrier. These would either occur during
         // 1. reductions performed by the runtime which are guaranteed to be
         // race-free.
         // 2. execution of another task.
         // For the latter case we will re-enable tracking in task_switch.
         Data->InBarrier = true;
         TsanIgnoreWritesBegin();
       }
 
       break;
     }
 
     case ompt_sync_region_taskwait:
       break;
 
     case ompt_sync_region_taskgroup:
       Data->TaskGroup = new Taskgroup(Data->TaskGroup);
       break;
 
-    default:
+    case ompt_sync_region_reduction:
+      // should never be reached
       break;
+
     }
+    if (endpoint == ompt_scope_begin)
       break;
+    KMP_FALLTHROUGH();
   case ompt_scope_end:
     TsanFuncExit();
     switch (kind) {
     case ompt_sync_region_barrier_implementation:
     case ompt_sync_region_barrier_implicit:
     case ompt_sync_region_barrier_explicit:
+    case ompt_sync_region_barrier_implicit_parallel:
+    case ompt_sync_region_barrier_implicit_workshare:
+    case ompt_sync_region_barrier_teams:
     case ompt_sync_region_barrier: {
       if (hasReductionCallback < ompt_set_always) {
         // We want to track writes after the barrier again.
         Data->InBarrier = false;
         TsanIgnoreWritesEnd();
       }
 
       char BarrierIndex = Data->BarrierIndex;
case ompt_sync_region_taskgroup: {
       // Delete this allocated taskgroup, all descendent task are finished by
       // now.
       Taskgroup *Parent = Data->TaskGroup->Parent;
       delete Data->TaskGroup;
       Data->TaskGroup = Parent;
       break;
     }
 
-    default:
+    case ompt_sync_region_reduction:
+      // Should not occur according to OpenMP 5.1
+      // Tested in OMPT tests
       break;
+
     }
     break;
   }
 }
 
 static void ompt_tsan_reduction(ompt_sync_region_t kind,
                                 ompt_scope_endpoint_t endpoint,
                                 ompt_data_t *parallel_data,
case ompt_scope_end:
     switch (kind) {
     case ompt_sync_region_reduction:
       TsanIgnoreWritesEnd();
       break;
     default:
       break;
     }
     break;
+  case ompt_scope_beginend:
+    // Should not occur according to OpenMP 5.1
+    // Tested in OMPT tests
+    // Would have no implications for DR detection
+    break;
   }
 }
 
 /// OMPT event callbacks for handling tasks.
 
 static void ompt_tsan_task_create(
     ompt_data_t *parent_task_data,    /* id of parent task            */
     const ompt_frame_t *parent_frame, /* frame data for parent task   */
     ompt_data_t *new_task_data,       /* id of created task           */