[OpenMP] Minor improvement in task allocation

[hbae]

Summary

This patch includes a few changes to improve task allocation
performance slightly. These changes are enough to restore performance
drop observed after introducing hidden helper.

[tianshilei1992]

I can understand the point of setting flag by direct copy, but does inline really help a lot here, or say really inline the function?

[hbae]

Undo the change that introduce __kmp_task_alloc_impl since the outcome may vary depending on the build compiler.

[tianshilei1992]

LGTM. Thanks!

openmp/runtime/src/kmp_tasking.cpp

 // flags: include tiedness & task type (explicit vs. implicit) of the ''new''
 // task encountered. Converted from kmp_int32 to kmp_tasking_flags_t in routine.
 // sizeof_kmp_task_t:  Size in bytes of kmp_task_t data structure including
 // private vars accessed in task.
 // sizeof_shareds:  Size in bytes of array of pointers to shared vars accessed
 // in task.
 // task_entry: Pointer to task code entry point generated by compiler.
 // returns: a pointer to the allocated kmp_task_t structure (task).
-kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
-                             kmp_tasking_flags_t *flags,
-                             size_t sizeof_kmp_task_t, size_t sizeof_shareds,
-                             kmp_routine_entry_t task_entry) {
+static inline kmp_task_t *
+__kmp_task_alloc_impl(ident_t *loc_ref, kmp_int32 gtid,
+                      kmp_tasking_flags_t *flags, size_t sizeof_kmp_task_t,
+                      size_t sizeof_shareds, kmp_routine_entry_t task_entry) {
   kmp_task_t *task;
   kmp_taskdata_t *taskdata;
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_info_t *encountering_thread = thread;
   kmp_team_t *team = thread->th.th_team;
   kmp_taskdata_t *parent_task = thread->th.th_current_task;
   size_t shareds_offset;
 
#endif
   taskdata->td_taskwait_ident = NULL;
   taskdata->td_taskwait_counter = 0;
   taskdata->td_taskwait_thread = 0;
   KMP_DEBUG_ASSERT(taskdata->td_parent != NULL);
   // avoid copying icvs for proxy tasks
   if (flags->proxy == TASK_FULL)
     copy_icvs(&taskdata->td_icvs, &taskdata->td_parent->td_icvs);
 
-  taskdata->td_flags.tiedness = flags->tiedness;
-  taskdata->td_flags.final = flags->final;
-  taskdata->td_flags.merged_if0 = flags->merged_if0;
-  taskdata->td_flags.destructors_thunk = flags->destructors_thunk;
-  taskdata->td_flags.proxy = flags->proxy;
-  taskdata->td_flags.detachable = flags->detachable;
-  taskdata->td_flags.hidden_helper = flags->hidden_helper;
+  taskdata->td_flags = *flags;
   taskdata->encountering_gtid = gtid;
   taskdata->td_task_team = thread->th.th_task_team;
   taskdata->td_size_alloc = shareds_offset + sizeof_shareds;
   taskdata->td_flags.tasktype = TASK_EXPLICIT;
 
   // GEH - TODO: fix this to copy parent task's value of tasking_ser flag
   taskdata->td_flags.tasking_ser = (__kmp_tasking_mode == tskm_immediate_exec);
 
   // GEH - TODO: fix this to copy parent task's value of team_serial flag
   taskdata->td_flags.team_serial = (team->t.t_serialized) ? 1 : 0;
 
   // GEH - Note we serialize the task if the team is serialized to make sure
   // implicit parallel region tasks are not left until program termination to
   // execute. Also, it helps locality to execute immediately.
 
   taskdata->td_flags.task_serial =
       (parent_task->td_flags.final || taskdata->td_flags.team_serial ||
        taskdata->td_flags.tasking_ser || flags->merged_if0);
 
   taskdata->td_flags.started = 0;
   taskdata->td_flags.executing = 0;
   taskdata->td_flags.complete = 0;
   taskdata->td_flags.freed = 0;
 
-  taskdata->td_flags.native = flags->native;
-
   KMP_ATOMIC_ST_RLX(&taskdata->td_incomplete_child_tasks, 0);
   // start at one because counts current task and children
   KMP_ATOMIC_ST_RLX(&taskdata->td_allocated_child_tasks, 1);
   taskdata->td_taskgroup =
       parent_task->td_taskgroup; // task inherits taskgroup from the parent task
   taskdata->td_dephash = NULL;
   taskdata->td_depnode = NULL;
   if (flags->tiedness == TASK_UNTIED)
if (flags->proxy == TASK_PROXY || flags->detachable == TASK_DETACHABLE ||
     KMP_ATOMIC_INC(&parent_task->td_incomplete_child_tasks);
     if (parent_task->td_taskgroup)
       KMP_ATOMIC_INC(&parent_task->td_taskgroup->count);
     // Only need to keep track of allocated child tasks for explicit tasks since
     // implicit not deallocated
     if (taskdata->td_parent->td_flags.tasktype == TASK_EXPLICIT) {
       KMP_ATOMIC_INC(&taskdata->td_parent->td_allocated_child_tasks);
     }
-  }
-
     if (flags->hidden_helper) {
       taskdata->td_flags.task_serial = FALSE;
       // Increment the number of hidden helper tasks to be executed
       KMP_ATOMIC_INC(&__kmp_unexecuted_hidden_helper_tasks);
     }
+  }
 
   KA_TRACE(20, ("__kmp_task_alloc(exit): T#%d created task %p parent=%p\n",
                 gtid, taskdata, taskdata->td_parent));
   ANNOTATE_HAPPENS_BEFORE(task);
 
   return task;
 }
 
+kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
+                             kmp_tasking_flags_t *flags,
+                             size_t sizeof_kmp_task_t, size_t sizeof_shareds,
+                             kmp_routine_entry_t task_entry) {
+  return __kmp_task_alloc_impl(loc_ref, gtid, flags, sizeof_kmp_task_t,
+                               sizeof_shareds, task_entry);
+}
+
 kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                   kmp_int32 flags, size_t sizeof_kmp_task_t,
                                   size_t sizeof_shareds,
                                   kmp_routine_entry_t task_entry) {
   kmp_task_t *retval;
   kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
   __kmp_assert_valid_gtid(gtid);
   input_flags->native = FALSE;
   // __kmp_task_alloc() sets up all other runtime flags
   KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s %s %s) "
                 "sizeof_task=%ld sizeof_shared=%ld entry=%p\n",
                 gtid, loc_ref, input_flags->tiedness ? "tied  " : "untied",
                 input_flags->proxy ? "proxy" : "",
                 input_flags->detachable ? "detachable" : "", sizeof_kmp_task_t,
                 sizeof_shareds, task_entry));
 
-  retval = __kmp_task_alloc(loc_ref, gtid, input_flags, sizeof_kmp_task_t,
+  retval = __kmp_task_alloc_impl(loc_ref, gtid, input_flags, sizeof_kmp_task_t,
                                  sizeof_shareds, task_entry);
 
   KA_TRACE(20, ("__kmpc_omp_task_alloc(exit): T#%d retval %p\n", gtid, retval));
 
   return retval;
 }
 
 kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                          kmp_int32 flags,