[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

 #endif
 }
 
 static void ompt_tsan_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 type) {
-  switch (endpoint) {
-  case ompt_scope_begin:
+  if (endpoint == 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:
+  } else if (endpoint == 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;
   }
 }
 
 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:
+  if (endpoint == ompt_scope_begin || endpoint == 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;
+
     }
-    break;
-  case ompt_scope_end:
+  }
+  if (endpoint == ompt_scope_end || endpoint == ompt_scope_beginend) {
     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;
       // Barrier will end after it has been entered by all threads.
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 never be reached
       break;
+
     }
-    break;
   }
 }
 
 static void ompt_tsan_reduction(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 (endpoint == ompt_scope_begin) {
     switch (kind) {
     case ompt_sync_region_reduction:
       TsanIgnoreWritesBegin();
       break;
     default:
       break;
     }
-    break;
-  case ompt_scope_end:
+  } else if (endpoint == ompt_scope_end) {
     switch (kind) {
     case ompt_sync_region_reduction:
       TsanIgnoreWritesEnd();
       break;
     default:
       break;
     }
-    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           */