/*
//@HEADER
// ************************************************************************
//
//                        Kokkos v. 2.0
//              Copyright (2014) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact  H. Carter Edwards (hcedwar@sandia.gov)
//
// ************************************************************************
//@HEADER
*/

#include <Kokkos_Core.hpp>

namespace TestAtomicOperations {

//-----------------------------------------------
//--------------zero_functor---------------------
//-----------------------------------------------

template<class T,class DEVICE_TYPE>
struct ZeroFunctor {
  typedef DEVICE_TYPE execution_space;
  typedef typename Kokkos::View<T,execution_space> type;
  typedef typename Kokkos::View<T,execution_space>::HostMirror h_type;
  type data;
  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    data() = 0;
  }
};

//-----------------------------------------------
//--------------init_functor---------------------
//-----------------------------------------------

template<class T,class DEVICE_TYPE>
struct InitFunctor {
  typedef DEVICE_TYPE execution_space;
  typedef typename Kokkos::View<T,execution_space> type;
  typedef typename Kokkos::View<T,execution_space>::HostMirror h_type;
  type data;
  T init_value ;
  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    data() = init_value;
  }

  InitFunctor(T _init_value) : init_value(_init_value) {}
};


//---------------------------------------------------
//--------------atomic_fetch_max---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct MaxFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    //Kokkos::atomic_fetch_max(&data(),(T)1);
    Kokkos::atomic_fetch_max(&data(),(T)i1);
  }
  MaxFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T MaxAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct MaxFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T MaxAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = (i0 > i1 ? i0 : i1) ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool MaxAtomicTest(T i0, T i1)
{
  T res       = MaxAtomic<T,DeviceType>(i0,i1);
  T resSerial = MaxAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = MaxAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_min---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct MinFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_min(&data(),(T)i1);
  }
  MinFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T MinAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct MinFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T MinAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = (i0 < i1 ? i0 : i1) ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool MinAtomicTest(T i0, T i1)
{
  T res       = MinAtomic<T,DeviceType>(i0,i1);
  T resSerial = MinAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = MinAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_increment---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct IncFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_increment(&data());
  }
  IncFunctor( T _i0 ) : i0(_i0) {}
};

template<class T, class execution_space >
T IncAtomic(T i0) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct IncFunctor<T,execution_space> f(i0);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T IncAtomicCheck(T i0) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0 + 1;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool IncAtomicTest(T i0)
{
  T res       = IncAtomic<T,DeviceType>(i0);
  T resSerial = IncAtomicCheck<T>(i0);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = IncAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_decrement---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct DecFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_decrement(&data());
  }
  DecFunctor( T _i0 ) : i0(_i0) {}
};

template<class T, class execution_space >
T DecAtomic(T i0) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct DecFunctor<T,execution_space> f(i0);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T DecAtomicCheck(T i0) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0 - 1;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool DecAtomicTest(T i0)
{
  T res       = DecAtomic<T,DeviceType>(i0);
  T resSerial = DecAtomicCheck<T>(i0);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = DecAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_mul---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct MulFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_mul(&data(),(T)i1);
  }
  MulFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T MulAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct MulFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T MulAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0*i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool MulAtomicTest(T i0, T i1)
{
  T res       = MulAtomic<T,DeviceType>(i0,i1);
  T resSerial = MulAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = MulAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_div---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct DivFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_div(&data(),(T)i1);
  }
  DivFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T DivAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct DivFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T DivAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0/i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool DivAtomicTest(T i0, T i1)
{
  T res       = DivAtomic<T,DeviceType>(i0,i1);
  T resSerial = DivAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = DivAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_mod---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct ModFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_mod(&data(),(T)i1);
  }
  ModFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T ModAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct ModFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T ModAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0%i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool ModAtomicTest(T i0, T i1)
{
  T res       = ModAtomic<T,DeviceType>(i0,i1);
  T resSerial = ModAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = ModAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_and---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct AndFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_and(&data(),(T)i1);
  }
  AndFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T AndAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct AndFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T AndAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0&i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool AndAtomicTest(T i0, T i1)
{
  T res       = AndAtomic<T,DeviceType>(i0,i1);
  T resSerial = AndAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = AndAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_or----------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct OrFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_or(&data(),(T)i1);
  }
  OrFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T OrAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct OrFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T OrAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0|i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool OrAtomicTest(T i0, T i1)
{
  T res       = OrAtomic<T,DeviceType>(i0,i1);
  T resSerial = OrAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = OrAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_xor---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct XorFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_xor(&data(),(T)i1);
  }
  XorFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T XorAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct XorFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T XorAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0^i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool XorAtomicTest(T i0, T i1)
{
  T res       = XorAtomic<T,DeviceType>(i0,i1);
  T resSerial = XorAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = XorAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_lshift---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct LShiftFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_lshift(&data(),(T)i1);
  }
  LShiftFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T LShiftAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct LShiftFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T LShiftAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0<<i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool LShiftAtomicTest(T i0, T i1)
{
  T res       = LShiftAtomic<T,DeviceType>(i0,i1);
  T resSerial = LShiftAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = LShiftAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}

//---------------------------------------------------
//--------------atomic_fetch_rshift---------------------
//---------------------------------------------------

template<class T,class DEVICE_TYPE>
struct RShiftFunctor{
  typedef DEVICE_TYPE execution_space;
  typedef Kokkos::View<T,execution_space> type;
  type data;
  T i0;
  T i1;

  KOKKOS_INLINE_FUNCTION
  void operator()(int) const {
    Kokkos::atomic_fetch_rshift(&data(),(T)i1);
  }
  RShiftFunctor( T _i0 , T _i1 ) : i0(_i0) , i1(_i1) {}
};

template<class T, class execution_space >
T RShiftAtomic(T i0 , T i1) {
  struct InitFunctor<T,execution_space> f_init(i0);
  typename InitFunctor<T,execution_space>::type data("Data");
  typename InitFunctor<T,execution_space>::h_type h_data("HData");
  f_init.data = data;
  Kokkos::parallel_for(1,f_init);
  execution_space::fence();

  struct RShiftFunctor<T,execution_space> f(i0,i1);
  f.data = data;
  Kokkos::parallel_for(1,f);
  execution_space::fence();

  Kokkos::deep_copy(h_data,data);
  T val = h_data();
  return val;
}

template<class T>
T RShiftAtomicCheck(T i0 , T i1) {
  T* data = new T[1];
  data[0] = 0;

  *data = i0>>i1 ;

  T val = *data;
  delete [] data;
  return val;
}

template<class T,class DeviceType>
bool RShiftAtomicTest(T i0, T i1)
{
  T res       = RShiftAtomic<T,DeviceType>(i0,i1);
  T resSerial = RShiftAtomicCheck<T>(i0,i1);

  bool passed = true;

  if ( resSerial != res ) {
    passed = false;

    std::cout << "Loop<"
              << typeid(T).name()
              << ">( test = RShiftAtomicTest"
              << " FAILED : "
              << resSerial << " != " << res
              << std::endl ;
  }

  return passed ;
}


//---------------------------------------------------
//--------------atomic_test_control------------------
//---------------------------------------------------

template<class T,class DeviceType>
bool AtomicOperationsTestIntegralType( int i0 , int i1 , int test )
{
  switch (test) {
    case 1: return MaxAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 2: return MinAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 3: return MulAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 4: return DivAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 5: return ModAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 6: return AndAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 7: return OrAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 8: return XorAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 9: return LShiftAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 10: return RShiftAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 11: return IncAtomicTest<T,DeviceType>( (T)i0 );
    case 12: return DecAtomicTest<T,DeviceType>( (T)i0 );
  }
  return 0;
}

template<class T,class DeviceType>
bool AtomicOperationsTestNonIntegralType( int i0 , int i1 , int test )
{
  switch (test) {
    case 1: return MaxAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 2: return MinAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 3: return MulAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
    case 4: return DivAtomicTest<T,DeviceType>( (T)i0 , (T)i1 );
  }
  return 0;
}

} // namespace