Fine tuning of TC* macros

[pawosm01]

Summary

This patch introduces following:

• TCI_* and TCD_* macros for incrementation and decrementation
• Fix for invalid use of TCR_8 in one expression

[AndreyChurbanov]

LGTM

[pawosm01]

As a side note, there is one more place that could be rearranged too: as I replaced no-op TCR_4 with actual code, compiler complained when building debug build. Following change was required:

diff --git a/runtime/src/kmp_tasking.c b/runtime/src/kmp_tasking.c
index 1d4ec35..e4d7bdc 100644
--- a/runtime/src/kmp_tasking.c
+++ b/runtime/src/kmp_tasking.c
@@ -1832,7 +1832,7 @@ static inline int __kmp_execute_tasks_template(kmp_info_t *thread, kmp_int32 gti
 #else
     KMP_DEBUG_ASSERT( nthreads > 1 );
 #endif
-    KMP_DEBUG_ASSERT( TCR_4((int)*unfinished_threads) >= 0 );
+    KMP_DEBUG_ASSERT( (int)(TCR_4(*unfinished_threads)) >= 0 );
.
     // Choose tasks from our own work queue.
     start:

Change commited.

runtime/src/kmp_lock.cpp

#endif /* USE_LOCK_PROFILE */
     //
     // The current implementation of KMP_WAIT_YIELD doesn't allow for mask
     // and poll to be re-read every spin iteration.
     //
     kmp_uint32 spins;
 
     KMP_FSYNC_PREPARE(lck);
     KMP_INIT_YIELD(spins);
-    while (TCR_8(polls[ticket & mask]).poll < ticket) { // volatile load
+    while (TCR_8(polls[ticket & mask].poll) < ticket) { // volatile load
         // If we are oversubscribed,
         // or have waited a bit (and KMP_LIBRARY=turnaround), then yield.
         // CPU Pause is in the macros for yield.
         //
         KMP_YIELD(TCR_4(__kmp_nth)
           > (__kmp_avail_proc ? __kmp_avail_proc : __kmp_xproc));
         KMP_YIELD_SPIN(spins);
 

runtime/src/kmp_os.h

 // #define TCW_8(a,b)  (a) = (*(volatile kmp_int64 *)(&b))
 //
 // I'm fairly certain this is the correct thing to do, but I'm afraid
 // of performance regressions.
 //
 
 #define TCR_4(a)            (a)
 #define TCW_4(a,b)          (a) = (b)
+#define TCI_4(a)            (++(a))
+#define TCD_4(a)            (--(a))
 #define TCR_8(a)            (a)
 #define TCW_8(a,b)          (a) = (b)
+#define TCI_8(a)            (++(a))
+#define TCD_8(a)            (--(a))
 #define TCR_SYNC_4(a)       (a)
 #define TCW_SYNC_4(a,b)     (a) = (b)
 #define TCX_SYNC_4(a,b,c)   KMP_COMPARE_AND_STORE_REL32((volatile kmp_int32 *)(volatile void *)&(a), (kmp_int32)(b), (kmp_int32)(c))
 #define TCR_SYNC_8(a)       (a)
 #define TCW_SYNC_8(a,b)     (a) = (b)
 #define TCX_SYNC_8(a,b,c)   KMP_COMPARE_AND_STORE_REL64((volatile kmp_int64 *)(volatile void *)&(a), (kmp_int64)(b), (kmp_int64)(c))
 
 #if KMP_ARCH_X86

runtime/src/kmp_tasking.c

static void __kmp_first_top_half_finish_proxy( kmp_taskdata_t * taskdata )
     KMP_DEBUG_ASSERT( taskdata -> td_flags.freed == 0 );
 
     taskdata -> td_flags.complete = 1;   // mark the task as completed
 
     if ( taskdata->td_taskgroup )
        KMP_TEST_THEN_DEC32( (kmp_int32 *)(& taskdata->td_taskgroup->count) );
 
     // Create an imaginary children for this task so the bottom half cannot release the task before we have completed the second top half
-    TCR_4(taskdata->td_incomplete_child_tasks++);
+    TCI_4(taskdata->td_incomplete_child_tasks);
 }
 
 static void __kmp_second_top_half_finish_proxy( kmp_taskdata_t * taskdata )
 {
     kmp_int32 children = 0;
 
     // Predecrement simulated by "- 1" calculation
     children = KMP_TEST_THEN_DEC32( (kmp_int32 *)(& taskdata -> td_parent -> td_incomplete_child_tasks) ) - 1;
     KMP_DEBUG_ASSERT( children >= 0 );
 
     // Remove the imaginary children
-    TCR_4(taskdata->td_incomplete_child_tasks--);
+    TCD_4(taskdata->td_incomplete_child_tasks);
 }
 
 static void __kmp_bottom_half_finish_proxy( kmp_int32 gtid, kmp_task_t * ptask )
 {
     kmp_taskdata_t * taskdata = KMP_TASK_TO_TASKDATA(ptask);
     kmp_info_t * thread = __kmp_threads[ gtid ];
 
     KMP_DEBUG_ASSERT( taskdata -> td_flags.proxy == TASK_PROXY );