HLT/TPCLib/tracking-ca/AliHLTTPCCAMath.h

   1 //-*- Mode: C++ -*-
   2 // ************************************************************************
   3 // This file is property of and copyright by the ALICE HLT Project        *
   4 // ALICE Experiment at CERN, All rights reserved.                         *
   5 // See cxx source for full Copyright notice                               *
   6 //                                                                        *
   7 //*************************************************************************
   8
   9 #ifndef ALIHLTTPCCAMATH_H
  10 #define ALIHLTTPCCAMATH_H
  11
  12 #include "AliHLTTPCCADef.h"
  13
  14 #if defined(HLTCA_STANDALONE) || defined(HLTCA_GPUCODE)
  15 #if !defined(__OPENCL__) || defined(HLTCA_HOSTCODE)
  16 #include <math.h>
  17 #endif
  18 #else
  19 #include "TMath.h"
  20 #endif //HLTCA_STANDALONE | HLTCA_GPUCODE
  21
  22 /**
  23  * @class ALIHLTTPCCAMath
  24  *
  25  *
  26  */
  27 class AliHLTTPCCAMath
  28 {
  29   public:
  30     GPUd() static float2 MakeFloat2( float x, float y );
  31
  32     GPUhd() static float Min( float x, float y );
  33     GPUhd() static float Max( float x, float y );
  34     GPUhd() static int Min( int x, int y );
  35     GPUhd() static int Max( int x, int y );
  36     GPUhd() static float Sqrt( float x );
  37     GPUhd() static float Abs( float x );
  38     GPUhd() static double Abs( double x );
  39     GPUhd() static int Abs( int x );
  40     GPUhd() static float ASin( float x );
  41     GPUd() static float ATan2( float y, float x );
  42     GPUhd() static float Sin( float x );
  43     GPUhd() static float Cos( float x );
  44     GPUhd() static float Tan( float x );
  45     GPUd() static float Copysign( float x, float y );
  46     GPUd() static float TwoPi() { return 6.28319; }
  47     GPUd() static float Pi() { return 3.1415926535897; }
  48     GPUd() static int Nint( float x );
  49     GPUd() static bool Finite( float x );
  50
  51         GPUhd() static float Log(float x);
  52   GPUd()  static int AtomicExch( register GPUglobalref() int *addr, int val );
  53     GPUd()  static int AtomicAdd (register GPUglobalref() int *addr, int val );
  54     GPUd()  static int AtomicMax (register GPUglobalref() int *addr, int val );
  55     GPUd()  static int AtomicMin (register GPUglobalref() int *addr, int val );
  56     GPUd()  static int AtomicExchShared(register GPUsharedref() int *addr, int val );
  57     GPUd()  static int AtomicAddShared (register GPUsharedref() int *addr, int val );
  58     GPUd()  static int AtomicMaxShared (register GPUsharedref() int *addr, int val );
  59     GPUd()  static int AtomicMinShared (register GPUsharedref() int *addr, int val );
  60     GPUd()  static int Mul24( int a, int b );
  61     GPUd()  static float FMulRZ( float a, float b );
  62 };
  63
  64 typedef AliHLTTPCCAMath CAMath;
  65
  66
  67 #if defined( HLTCA_GPUCODE )
  68 #define choice(c1,c2,c3) c1
  69
  70 #if defined( __OPENCL__ )
  71 #if defined( HLTCA_HOSTCODE)
  72 #if defined( HLTCA_STANDALONE )
  73 #define choiceA(c1,c2,c3) c2
  74 #else //HLTCA_STANDALONE
  75 #define choiceA(c1,c2,c3) c2
  76 #endif //HLTCA_STANDALONE
  77 #else //HLTCA_HOSTCODE
  78 #define choiceA(c1, c2, c3) c2
  79 #endif //HLTCA_HOSTCODE
  80 #else //__OPENCL
  81
  82 #define choiceA choice
  83 #endif //__OPENCL__
  84 #elif defined( HLTCA_STANDALONE )
  85 #define choice(c1,c2,c3) c2
  86 #define choiceA choice
  87 #else
  88 #define choice(c1,c2,c3) c3
  89 #define choiceA choice
  90 #endif //HLTCA_GPUCODE
  91
  92 GPUd() inline float2 AliHLTTPCCAMath::MakeFloat2( float x, float y )
  93 {
  94 #if !defined( HLTCA_GPUCODE ) || defined(__OPENCL__)
  95   float2 ret = {x, y};
  96   return ret;
  97 #else
  98   return make_float2( x, y );
  99 #endif //HLTCA_GPUCODE
 100 }
 101
 102
 103 GPUd() inline int AliHLTTPCCAMath::Nint( float x )
 104 {
 105 #if defined(HLTCA_STANDALONE) || defined( HLTCA_GPUCODE )
 106   int i;
 107   if ( x >= 0 ) {
 108     i = int( x + 0.5 );
 109     if ( x + 0.5 == float( i ) && i & 1 ) i--;
 110   } else {
 111     i = int( x - 0.5 );
 112     if ( x - 0.5 == float( i ) && i & 1 ) i++;
 113   }
 114   return i;
 115 #else
 116   return TMath::Nint( x );
 117 #endif //HLTCA_STANDALONE | HLTCA_GPUCODE
 118 }
 119
 120 GPUd() inline bool AliHLTTPCCAMath::Finite( float x )
 121 {
 122   return choice( 1 /*isfinite( x )*/, finite( x ), finite( x ) );
 123 }
 124
 125 GPUd() inline float AliHLTTPCCAMath::ATan2( float y, float x )
 126 {
 127   return choiceA( atan2f( y, x ), atan2( y, x ), TMath::ATan2( y, x ) );
 128 }
 129
 130
 131 GPUd() inline float AliHLTTPCCAMath::Copysign( float x, float y )
 132 {
 133 #if defined( HLTCA_GPUCODE ) && !defined(__OPENCL__)
 134   return copysignf( x, y );
 135 #else
 136   x = CAMath::Abs( x );
 137   return ( y >= 0 ) ? x : -x;
 138 #endif //HLTCA_GPUCODE
 139 }
 140
 141
 142 GPUhd() inline float AliHLTTPCCAMath::Sin( float x )
 143 {
 144   return choiceA( sinf( x ), sin( x ), TMath::Sin( x ) );
 145 }
 146
 147 GPUhd() inline float AliHLTTPCCAMath::Cos( float x )
 148 {
 149   return choiceA( cosf( x ), cos( x ), TMath::Cos( x ) );
 150 }
 151
 152 GPUhd() inline float AliHLTTPCCAMath::Tan( float x )
 153 {
 154   return choiceA( tanf( x ), tan( x ), TMath::Tan( x ) );
 155 }
 156
 157 GPUhd() inline float AliHLTTPCCAMath::Min( float x, float y )
 158 {
 159   return choiceA( fminf( x, y ),  ( x < y ? x : y ), TMath::Min( x, y ) );
 160 }
 161
 162 GPUhd() inline float AliHLTTPCCAMath::Max( float x, float y )
 163 {
 164   return choiceA( fmaxf( x, y ),  ( x > y ? x : y ), TMath::Max( x, y ) );
 165 }
 166
 167 GPUhd() inline int AliHLTTPCCAMath::Min( int x, int y )
 168 {
 169   return choiceA( min( x, y ),  ( x < y ? x : y ), TMath::Min( x, y ) );
 170 }
 171
 172 GPUhd() inline int AliHLTTPCCAMath::Max( int x, int y )
 173 {
 174   return choiceA( max( x, y ),  ( x > y ? x : y ), TMath::Max( x, y ) );
 175 }
 176
 177 GPUhd() inline float AliHLTTPCCAMath::Sqrt( float x )
 178 {
 179   return choiceA( sqrtf( x ), sqrt( x ), TMath::Sqrt( x ) );
 180 }
 181
 182 GPUhd() inline float AliHLTTPCCAMath::Abs( float x )
 183 {
 184   return choiceA( fabsf( x ), fabs( x ), TMath::Abs( x ) );
 185 }
 186
 187 GPUhd() inline double AliHLTTPCCAMath::Abs( double x )
 188 {
 189   return choice( fabs( x ), fabs( x ), TMath::Abs( x ) );
 190 }
 191
 192 GPUhd() inline int AliHLTTPCCAMath::Abs( int x )
 193 {
 194   return choice( abs( x ), ( x >= 0 ? x : -x ), TMath::Abs( x ) );
 195 }
 196
 197 GPUhd() inline float AliHLTTPCCAMath::ASin( float x )
 198 {
 199   return choiceA( asinf( x ), asin( x ), TMath::ASin( x ) );
 200 }
 201
 202
 203 GPUd() inline int AliHLTTPCCAMath::Mul24( int a, int b )
 204 {
 205 #if defined(FERMI) || defined(__OPENCL__) || defined(KEPLER)
 206   return(a * b);
 207 #else
 208   return choice( __mul24( a, b ), a*b, a*b );
 209 #endif
 210 }
 211
 212 GPUd() inline float AliHLTTPCCAMath::FMulRZ( float a, float b )
 213 {
 214   return choiceA( __fmul_rz( a, b ), a*b, a*b );
 215 }
 216
 217 GPUhd() inline float AliHLTTPCCAMath::Log(float x)
 218 {
 219         return choice( Log(x), Log(x), TMath::Log(x));
 220 }
 221
 222 #if defined(__OPENCL__) && !defined(HLTCA_HOSTCODE)
 223 GPUd()  inline int AliHLTTPCCAMath::AtomicExchShared(register GPUsharedref() int *addr, int val ) {return ::atomic_xchg( (volatile __local int*) addr, val );}
 224 GPUd()  inline int AliHLTTPCCAMath::AtomicAddShared (register GPUsharedref() int *addr, int val ) {return ::atomic_add( (volatile __local int*) addr, val );}
 225 GPUd()  inline int AliHLTTPCCAMath::AtomicMaxShared (register GPUsharedref() int *addr, int val ) {return ::atomic_max( (volatile __local int*) addr, val );}
 226 GPUd()  inline int AliHLTTPCCAMath::AtomicMinShared (register GPUsharedref() int *addr, int val ) {return ::atomic_min( (volatile __local int*) addr, val );}
 227
 228 #else
 229 GPUd()  inline int AliHLTTPCCAMath::AtomicExchShared( int *addr, int val ) {return(AliHLTTPCCAMath::AtomicExch(addr, val));}
 230 GPUd()  inline int AliHLTTPCCAMath::AtomicAddShared ( int *addr, int val ) {return(AliHLTTPCCAMath::AtomicAdd(addr, val));}
 231 GPUd()  inline int AliHLTTPCCAMath::AtomicMaxShared ( int *addr, int val ) {return(AliHLTTPCCAMath::AtomicMax(addr, val));}
 232 GPUd()  inline int AliHLTTPCCAMath::AtomicMinShared ( int *addr, int val ) {return(AliHLTTPCCAMath::AtomicMin(addr, val));}
 233 #endif
 234
 235
 236 GPUd()  inline int AliHLTTPCCAMath::AtomicExch(register GPUglobalref() int *addr, int val )
 237 {
 238 #if defined( HLTCA_GPUCODE ) & !defined(HLTCA_HOSTCODE)
 239 #ifdef __OPENCL__
 240         return ::atomic_xchg( (volatile __global int*) addr, val );
 241 #else
 242   return ::atomicExch( addr, val );
 243 #endif
 244 #else
 245   int old = *addr;
 246   *addr = val;
 247   return old;
 248 #endif //HLTCA_GPUCODE
 249 }
 250
 251 GPUd()  inline int AliHLTTPCCAMath::AtomicAdd (register GPUglobalref() int *addr, int val )
 252 {
 253 #if defined( HLTCA_GPUCODE ) & !defined(HLTCA_HOSTCODE)
 254 #ifdef __OPENCL__
 255   return ::atomic_add( (volatile __global int*) addr, val );
 256 #else
 257   return ::atomicAdd( addr, val );
 258 #endif
 259 #else
 260   int old = *addr;
 261   *addr += val;
 262   return old;
 263 #endif //HLTCA_GPUCODE
 264 }
 265
 266 GPUd()  inline int AliHLTTPCCAMath::AtomicMax (register GPUglobalref() int *addr, int val )
 267 {
 268 #if defined( HLTCA_GPUCODE ) & !defined(HLTCA_HOSTCODE)
 269 #ifdef __OPENCL__
 270   return ::atomic_max( (volatile __global int*) addr, val );
 271 #else
 272   return ::atomicMax( addr, val );
 273 #endif
 274 #else
 275   int old = *addr;
 276   if ( *addr < val ) *addr = val;
 277   return old;
 278 #endif //HLTCA_GPUCODE
 279 }
 280
 281 GPUd()  inline int AliHLTTPCCAMath::AtomicMin (register GPUglobalref() int *addr, int val )
 282 {
 283 #if defined( HLTCA_GPUCODE ) & !defined(HLTCA_HOSTCODE)
 284 #ifdef __OPENCL__
 285   return ::atomic_min( (volatile __global int*) addr, val );
 286 #else
 287   return ::atomicMin( addr, val );
 288 #endif
 289 #else
 290   int old = *addr;
 291   if ( *addr > val ) *addr = val;
 292   return old;
 293 #endif //HLTCA_GPUCODE
 294 }
 295
 296 #undef CHOICE
 297
 298 #endif //ALIHLTTPCCAMATH_H