Cleanup: put i_maxmin members and ___kmp_size_type into traits_t

[jlpeyton]

Summary

Put the duplicated i_maxmin into traits_t by adding new members max_value and
min_value. Put ___kmp_size_type into traits_t by adding member type_size.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp_dispatch.cpp

 #if OMPT_SUPPORT
 #include "ompt-internal.h"
 #include "ompt-specific.h"
 #endif
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
-// template for type limits
-template< typename T >
-struct i_maxmin {
-    static const T mx;
-    static const T mn;
-};
-template<>
-struct i_maxmin< int > {
-    static const int mx = 0x7fffffff;
-    static const int mn = 0x80000000;
-};
-template<>
-struct i_maxmin< unsigned int > {
-    static const unsigned int mx = 0xffffffff;
-    static const unsigned int mn = 0x00000000;
-};
-template<>
-struct i_maxmin< long long > {
-    static const long long mx = 0x7fffffffffffffffLL;
-    static const long long mn = 0x8000000000000000LL;
-};
-template<>
-struct i_maxmin< unsigned long long > {
-    static const unsigned long long mx = 0xffffffffffffffffLL;
-    static const unsigned long long mn = 0x0000000000000000LL;
-};
-//-------------------------------------------------------------------------
-
 #if KMP_STATIC_STEAL_ENABLED
 
     // replaces dispatch_private_info{32,64} structures and dispatch_private_info{32,64}_t types
     template< typename T >
     struct dispatch_private_infoXX_template {
         typedef typename traits_t< T >::unsigned_t  UT;
         typedef typename traits_t< T >::signed_t    ST;
         UT count;                // unsigned
__kmp_dispatch_init(
     T                                ub,
     typename traits_t< T >::signed_t st,
     typename traits_t< T >::signed_t chunk,
     int                              push_ws
 ) {
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
     typedef typename traits_t< T >::floating_t  DBL;
-    static const int ___kmp_size_type = sizeof( UT );
 
     int                                            active;
     T                                              tc;
     kmp_info_t *                                   th;
     kmp_team_t *                                   team;
     kmp_uint32                                     my_buffer_index;
     dispatch_private_info_template< T >          * pr;
     dispatch_shared_info_template< UT > volatile * sh;
#endif
 
     /* Pick up the nomerge/ordered bits from the scheduling type */
     if ( (schedule >= kmp_nm_lower) && (schedule < kmp_nm_upper) ) {
         pr->nomerge = TRUE;
         schedule = (enum sched_type)(((int)schedule) - (kmp_nm_lower - kmp_sch_lower));
     } else {
         pr->nomerge = FALSE;
     }
-    pr->type_size = ___kmp_size_type; // remember the size of variables
+    pr->type_size = traits_t<T>::type_size; // remember the size of variables
     if ( kmp_ord_lower & schedule ) {
         pr->ordered = TRUE;
         schedule = (enum sched_type)(((int)schedule) - (kmp_ord_lower - kmp_sch_lower));
     } else {
         pr->ordered = FALSE;
     }
 
     if ( schedule == kmp_sch_static ) {
case kmp_sch_static_steal:
                 init = id * small_chunk + ( id < extras ? id : extras );
                 pr->u.p.count = init;
                 pr->u.p.ub = init + small_chunk + ( id < extras ? 1 : 0 );
 
                 pr->u.p.parm2 = lb;
                 //pr->pfields.parm3 = 0; // it's not used in static_steal
                 pr->u.p.parm4 = (id + 1) % nproc; // remember neighbour tid
                 pr->u.p.st = st;
-                if ( ___kmp_size_type > 4 ) {
+                if ( traits_t<T>::type_size > 4 ) {
                     // AC: TODO: check if 16-byte CAS available and use it to
                     // improve performance (probably wait for explicit request
                     // before spending time on this).
                     // For now use dynamically allocated per-thread lock,
                     // free memory in __kmp_dispatch_next when status==0.
                     KMP_DEBUG_ASSERT(th->th.th_dispatch->th_steal_lock == NULL);
                     th->th.th_dispatch->th_steal_lock =
                         (kmp_lock_t*)__kmp_allocate(sizeof(kmp_lock_t));

 static int
 __kmp_dispatch_next(
     ident_t *loc, int gtid, kmp_int32 *p_last, T *p_lb, T *p_ub, typename traits_t< T >::signed_t *p_st
 ) {
 
     typedef typename traits_t< T >::unsigned_t  UT;
     typedef typename traits_t< T >::signed_t    ST;
     typedef typename traits_t< T >::floating_t  DBL;
-#if ( KMP_STATIC_STEAL_ENABLED )
-    static const int ___kmp_size_type = sizeof( UT );
-#endif
 
     // This is potentially slightly misleading, schedule(runtime) will appear here even if the actual runtme schedule
     // is static. (Which points out a disadavantage of schedule(runtime): even when static scheduling is used it costs
     // more than a compile time choice to use static scheduling would.)
     KMP_TIME_PARTITIONED_BLOCK(FOR_dynamic_scheduling);
 
     int                                   status;
     dispatch_private_info_template< T > * pr;
#endif
                 {
                     T chunk = pr->u.p.parm1;
                     int nproc = th->th.th_team_nproc;
 
                     KD_TRACE(100, ("__kmp_dispatch_next: T#%d kmp_sch_static_steal case\n", gtid) );
 
                     trip = pr->u.p.tc - 1;
 
-                    if ( ___kmp_size_type > 4 ) {
+                    if ( traits_t<T>::type_size > 4 ) {
                         // use lock for 8-byte and CAS for 4-byte induction
                         // variable. TODO (optional): check and use 16-byte CAS
                         kmp_lock_t * lck = th->th.th_dispatch->th_steal_lock;
                         KMP_DEBUG_ASSERT(lck != NULL);
                         if( pr->u.p.count < (UT)pr->u.p.ub ) {
                             __kmp_acquire_lock(lck, gtid);
                             // try to get own chunk of iterations
                             init   = ( pr->u.p.count )++;
#endif
                     traits_t< UT >::spec );
                 KD_TRACE(100, ( buff, gtid, sh->u.s.num_done ) );
                 __kmp_str_free( &buff );
             }
             #endif
 
             if ( (ST)num_done == th->th.th_team_nproc - 1 ) {
                 #if ( KMP_STATIC_STEAL_ENABLED )
-                if( pr->schedule == kmp_sch_static_steal && ___kmp_size_type > 4 ) {
+                if( pr->schedule == kmp_sch_static_steal && traits_t<T>::type_size > 4 ) {
                     int i;
                     kmp_info_t **other_threads = team->t.t_threads;
                     // loop complete, safe to destroy locks used for stealing
                     for( i = 0; i < th->th.th_team_nproc; ++i ) {
                         kmp_lock_t * lck = other_threads[i]->th.th_dispatch->th_steal_lock;
                         KMP_ASSERT(lck != NULL);
                         __kmp_destroy_lock( lck );
                         __kmp_free( lck );
if( trip_count <= nteams ) {
             register T upper = *pupper;
             KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
                 // Unknown static scheduling type.
             *plower += team_id * chunk_inc_count;
             *pupper = *plower + chunk_inc_count - incr;
             // Check/correct bounds if needed
             if( incr > 0 ) {
                 if( *pupper < *plower )
-                    *pupper = i_maxmin< T >::mx;
+                    *pupper = traits_t<T>::max_value;
                 if( plastiter != NULL )
                     *plastiter = *plower <= upper && *pupper > upper - incr;
                 if( *pupper > upper )
                     *pupper = upper; // tracker C73258
             } else {
                 if( *pupper > *plower )
-                    *pupper = i_maxmin< T >::mn;
+                    *pupper = traits_t<T>::min_value;
                 if( plastiter != NULL )
                     *plastiter = *plower >= upper && *pupper < upper - incr;
                 if( *pupper < upper )
                     *pupper = upper; // tracker C73258
             }
         }
     }
 }

openmp/trunk/runtime/src/kmp_os.h

 #define  KMP_INT_MAX     ((kmp_int32)0x7FFFFFFF)
 #define  KMP_INT_MIN     ((kmp_int32)0x80000000)
 
 #ifdef __cplusplus
     //-------------------------------------------------------------------------
     // template for debug prints specification ( d, u, lld, llu ), and to obtain
     // signed/unsigned flavors of a type
     template< typename T >
-    struct traits_t {
-        typedef T           signed_t;
-        typedef T           unsigned_t;
-        typedef T           floating_t;
-        static char const * spec;
-    };
+    struct traits_t { };
     // int
     template<>
     struct traits_t< signed int > {
         typedef signed int    signed_t;
         typedef unsigned int  unsigned_t;
         typedef double        floating_t;
         static char const *   spec;
+        static const signed_t max_value = 0x7fffffff;
+        static const signed_t min_value = 0x80000000;
+        static const int type_size = sizeof(signed_t);
     };
     // unsigned int
     template<>
     struct traits_t< unsigned int > {
         typedef signed int    signed_t;
         typedef unsigned int  unsigned_t;
         typedef double        floating_t;
         static char const *   spec;
+        static const unsigned_t max_value = 0xffffffff;
+        static const unsigned_t min_value = 0x00000000;
+        static const int type_size = sizeof(unsigned_t);
     };
     // long long
     template<>
     struct traits_t< signed long long > {
         typedef signed long long    signed_t;
         typedef unsigned long long  unsigned_t;
         typedef long double         floating_t;
         static char const *         spec;
+        static const signed_t max_value = 0x7fffffffffffffffLL;
+        static const signed_t min_value = 0x8000000000000000LL;
+        static const int type_size = sizeof(signed_t);
     };
     // unsigned long long
     template<>
     struct traits_t< unsigned long long > {
         typedef signed long long    signed_t;
         typedef unsigned long long  unsigned_t;
         typedef long double         floating_t;
         static char const *         spec;
+        static const unsigned_t max_value = 0xffffffffffffffffLL;
+        static const unsigned_t min_value = 0x0000000000000000LL;
+        static const int type_size = sizeof(unsigned_t);
     };
     //-------------------------------------------------------------------------
 #endif // __cplusplus
 
 #define KMP_EXPORT  extern  /* export declaration in guide libraries */
 
 #if __GNUC__ >= 4
     #define __forceinline __inline

openmp/trunk/runtime/src/kmp_sched.cpp

 #include "kmp_error.h"
 #include "kmp_stats.h"
 #include "kmp_itt.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
-// template for type limits
-template< typename T >
-struct i_maxmin {
-    static const T mx;
-    static const T mn;
-};
-template<>
-struct i_maxmin< int > {
-    static const int mx = 0x7fffffff;
-    static const int mn = 0x80000000;
-};
-template<>
-struct i_maxmin< unsigned int > {
-    static const unsigned int mx = 0xffffffff;
-    static const unsigned int mn = 0x00000000;
-};
-template<>
-struct i_maxmin< long long > {
-    static const long long mx = 0x7fffffffffffffffLL;
-    static const long long mn = 0x8000000000000000LL;
-};
-template<>
-struct i_maxmin< unsigned long long > {
-    static const unsigned long long mx = 0xffffffffffffffffLL;
-    static const unsigned long long mn = 0x0000000000000000LL;
-};
-//-------------------------------------------------------------------------
 #ifdef KMP_DEBUG
 //-------------------------------------------------------------------------
 // template for debug prints specification ( d, u, lld, llu )
     char const * traits_t< int >::spec = "d";
     char const * traits_t< unsigned int >::spec = "u";
     char const * traits_t< long long >::spec = "lld";
     char const * traits_t< unsigned long long >::spec = "llu";
 //-------------------------------------------------------------------------
case kmp_sch_static:
 
                     KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
                         // Unknown static scheduling type.
 
                     *plower += tid * big_chunk_inc_count;
                     *pupper = *plower + big_chunk_inc_count - incr;
                     if ( incr > 0 ) {
                         if( *pupper < *plower )
-                            *pupper = i_maxmin< T >::mx;
+                            *pupper = traits_t<T>::max_value;
                         if( plastiter != NULL )
                             *plastiter = *plower <= old_upper && *pupper > old_upper - incr;
                         if ( *pupper > old_upper ) *pupper = old_upper; // tracker C73258
                     } else {
                         if( *pupper > *plower )
-                            *pupper = i_maxmin< T >::mn;
+                            *pupper = traits_t<T>::min_value;
                         if( plastiter != NULL )
                             *plastiter = *plower >= old_upper && *pupper < old_upper - incr;
                         if ( *pupper < old_upper ) *pupper = old_upper; // tracker C73258
                     }
                 }
             }
             break;
         }
if( trip_count <= nteams ) {
             register T upper = *pupper;
             KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
                 // Unknown static scheduling type.
             *plower += team_id * chunk_inc_count;
             *pupperDist = *plower + chunk_inc_count - incr;
             // Check/correct bounds if needed
             if( incr > 0 ) {
                 if( *pupperDist < *plower )
-                    *pupperDist = i_maxmin< T >::mx;
+                    *pupperDist = traits_t<T>::max_value;
                 if( plastiter != NULL )
                     *plastiter = *plower <= upper && *pupperDist > upper - incr;
                 if( *pupperDist > upper )
                     *pupperDist = upper; // tracker C73258
                 if( *plower > *pupperDist ) {
                     *pupper = *pupperDist;  // no iterations available for the team
                     goto end;
                 }
             } else {
                 if( *pupperDist > *plower )
-                    *pupperDist = i_maxmin< T >::mn;
+                    *pupperDist = traits_t<T>::min_value;
                 if( plastiter != NULL )
                     *plastiter = *plower >= upper && *pupperDist < upper - incr;
                 if( *pupperDist < upper )
                     *pupperDist = upper; // tracker C73258
                 if( *plower < *pupperDist ) {
                     *pupper = *pupperDist;  // no iterations available for the team
                     goto end;
                 }
if( trip_count <= nteams ) {
                         ( trip_count / nth + ( ( trip_count % nth ) ? 1 : 0) ) * incr;
                     register T upper = *pupperDist;
                     KMP_DEBUG_ASSERT( __kmp_static == kmp_sch_static_greedy );
                         // Unknown static scheduling type.
                     *plower += tid * chunk_inc_count;
                     *pupper = *plower + chunk_inc_count - incr;
                     if( incr > 0 ) {
                         if( *pupper < *plower )
-                            *pupper = i_maxmin< T >::mx;
+                            *pupper = traits_t<T>::max_value;
                         if( plastiter != NULL )
                             if( *plastiter != 0 && !(*plower <= upper && *pupper > upper - incr) )
                                 *plastiter = 0;
                         if( *pupper > upper )
                             *pupper = upper;//tracker C73258
                     } else {
                         if( *pupper > *plower )
-                            *pupper = i_maxmin< T >::mn;
+                            *pupper = traits_t<T>::min_value;
                         if( plastiter != NULL )
                             if( *plastiter != 0 && !(*plower >= upper && *pupper < upper - incr) )
                                 *plastiter = 0;
                         if( *pupper < upper )
                             *pupper = upper;//tracker C73258
                     }
                 }
             }
) {
     *p_st = span * nteams;
     *p_lb = lower + (span * team_id);
     *p_ub = *p_lb + span - incr;
     if ( p_last != NULL )
         *p_last = (team_id == ((trip_count - 1)/(UT)chunk) % nteams);
     // Correct upper bound if needed
     if( incr > 0 ) {
         if( *p_ub < *p_lb ) // overflow?
-            *p_ub = i_maxmin< T >::mx;
+            *p_ub = traits_t<T>::max_value;
         if( *p_ub > upper )
             *p_ub = upper; // tracker C73258
     } else {   // incr < 0
         if( *p_ub > *p_lb )
-            *p_ub = i_maxmin< T >::mn;
+            *p_ub = traits_t<T>::min_value;
         if( *p_ub < upper )
             *p_ub = upper; // tracker C73258
     }
     #ifdef KMP_DEBUG
     {
         const char * buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format( "__kmp_team_static_init exit: T#%%d team%%u liter=%%d "\