[OpenMP] remove usage of std::abs in the new loop collapse support code

[vadikp-intel]

Summary

on some platforms, std::abs may inadvertently pull in a math library. This patch replaces its use in the new loop collapse code with a no thrills in-situ implementation.

[tianshilei1992]

Could you also check all the uses and replace them all at once? After that, can you remove the <cmath> header as well?

[tianshilei1992]

openmp/runtime/src/kmp_collapse.cpp

29

_X is not in any format that we try to follow here. Neither LLVM nor libomp standard.

29

Potentially it can be called something like __kmp_abs.

[vadikp-intel]

removed <cmath> reference and changed the names of the local replacement implementations to convention.

[vadikp-intel]

I have reworked the naming but am not seeing any other uses of std::abs in the runtime code. There are a couple of <cmath> references, but none of them appear to be reachable in the current build: one is apparently in a test case, the other - in the stats collection support which is off by default and where math use is heavier (e.g. sqrt) making its removal trickier.

[tianshilei1992]

openmp/runtime/src/kmp_stats.cpp contains a std::fabs. Can you update it as well? Thanks.

[vadikp-intel]

Changing kmp_stats to use the new definitions would require moving them up into a header somewhere while still requiring <cmath> in kmp_stats. Do you think this would be worth it?

[tianshilei1992]

Sure, then we can come back to it later. We might want to move those things into kmp.h or something like kmp_math.h eventually such that all source files can use them.

openmp/runtime/src/kmp_collapse.cpp

 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
 #include "kmp_collapse.h"
 
-#include <cmath>
-
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 // OMPTODO: different style of comments (see kmp_sched)
 // OMPTODO: OMPT/OMPD
 
+// avoid inadevertently using a library based abs
+template <typename T> T __kmp_abs(const T val) {
+  return (val < 0) ? -val: val;
+}
+kmp_uint32 __kmp_abs(const kmp_uint32 val) { return val; }
+kmp_uint64 __kmp_abs(const kmp_uint64 val) { return val; }
+
 //----------------------------------------------------------------------------
 // Common functions for working with rectangular and non-rectangular loops
 //----------------------------------------------------------------------------
 
-template <typename T> int sign(T val) { return (T(0) < val) - (val < T(0)); }
+template <typename T> int __kmp_sign(T val) { return (T(0) < val) - (val < T(0)); }
 
 //----------Loop canonicalization---------------------------------------------
 
 // For loop nest (any shape):
 // convert != to < or >;
 // switch from using < or > to <= or >=.
 // "bounds" array has to be allocated per thread.
 // All other internal functions will work only with canonicalized loops.
if (bounds->ub0 < bounds->lb0) {
       // Note: after this we don't need to calculate inner loops,
       // but that should be an edge case:
       bounds->trip_count = 0;
     } else {
       // ub - lb may exceed signed type range; we need to cast to
       // kmp_loop_nest_iv_t anyway
       bounds->trip_count =
           static_cast<kmp_loop_nest_iv_t>(bounds->ub0 - bounds->lb0) /
-              std::abs(bounds->step) +
+              __kmp_abs(bounds->step) +
           1;
     }
   } else if (bounds->comparison == comparison_t::comp_greater_or_eq) {
     if (bounds->lb0 < bounds->ub0) {
       // Note: after this we don't need to calculate inner loops,
       // but that should be an edge case:
       bounds->trip_count = 0;
     } else {
       // lb - ub may exceed signed type range; we need to cast to
       // kmp_loop_nest_iv_t anyway
       bounds->trip_count =
           static_cast<kmp_loop_nest_iv_t>(bounds->lb0 - bounds->ub0) /
-              std::abs(bounds->step) +
+              __kmp_abs(bounds->step) +
           1;
     }
   } else {
     KMP_ASSERT(false);
   }
   return bounds->trip_count;
 }
 
if (bbounds.lb1 == bbounds.ub1) {
     // Already parallel, no need to adjust:
     bounds->loop_bounds_adjusted = false;
   } else {
     bounds->loop_bounds_adjusted = true;
 
     T old_lb1 = bbounds.lb1;
     T old_ub1 = bbounds.ub1;
 
-    if (sign(old_lb1) != sign(old_ub1)) {
+    if (__kmp_sign(old_lb1) != __kmp_sign(old_ub1)) {
       // With this shape we can adjust to a rectangle:
       bbounds.lb1 = 0;
       bbounds.ub1 = 0;
     } else {
       // get upper and lower bounds to be parallel
       // with values in the old range.
-      // Note: std::abs didn't work here.
-      if (((sign(old_lb1) == -1) && (old_lb1 < old_ub1)) ||
-          ((sign(old_lb1) == 1) && (old_lb1 > old_ub1))) {
+      // Note: abs didn't work here.
+      if (((old_lb1 < 0) && (old_lb1 < old_ub1)) ||
+          ((old_lb1 > 0) && (old_lb1 > old_ub1))) {
         bbounds.lb1 = old_ub1;
       } else {
         bbounds.ub1 = old_lb1;
       }
     }
 
     // Now need to adjust lb0, ub0, otherwise in some cases space will shrink.
     // The idea here that for this IV we are now getting the same span
kmp_calc_number_of_iterations_XX(const bounds_infoXX_template<T> *bounds,
                                  kmp_index_t ind) {
 
   kmp_loop_nest_iv_t iterations = 0;
 
   if (bounds->comparison == comparison_t::comp_less_or_eq) {
     iterations =
         (static_cast<T>(original_ivs[ind]) - bounds->lb0 -
          bounds->lb1 * static_cast<T>(original_ivs[bounds->outer_iv])) /
-        std::abs(bounds->step);
+        __kmp_abs(bounds->step);
   } else {
     KMP_DEBUG_ASSERT(bounds->comparison == comparison_t::comp_greater_or_eq);
     iterations = (bounds->lb0 +
                   bounds->lb1 * static_cast<T>(original_ivs[bounds->outer_iv]) -
                   static_cast<T>(original_ivs[ind])) /
-                 std::abs(bounds->step);
+                 __kmp_abs(bounds->step);
   }
 
   return iterations;
 }
 
 // Calculate number of iterations in the original or updated space resulting in
 // original_ivs[ind] (only on this level, non-negative)
 kmp_loop_nest_iv_t kmp_calc_number_of_iterations(const bounds_info_t *bounds,