KokkosTypes.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------
Licence:
  This file is part of phasicFlow code. It is a free software for simulating
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions.
 
  phasicFlow is distributed to help others in their research in the field of
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
#ifndef __KokkosTypes_hpp__
#define __KokkosTypes_hpp__
 
#include <Kokkos_Core.hpp>
#include <Kokkos_DualView.hpp>
#include <Kokkos_UnorderedMap.hpp>
 
#include "builtinTypes.hpp"
 
namespace pFlow
{
 
using HostSpace = Kokkos::HostSpace;
 
using Serial = Kokkos::Serial;
 
#ifdef _OPENMP
using OpenMP = Kokkos::OpenMP;
#endif
 
#ifdef __CUDACC__
using Cuda = Kokkos::Cuda;
#endif
 
using DefaultHostExecutionSpace = Kokkos::DefaultHostExecutionSpace;
 
using DefaultExecutionSpace = Kokkos::DefaultExecutionSpace;
 
using deviceRPolicyStatic = Kokkos::RangePolicy<
  Kokkos::DefaultExecutionSpace,
  Kokkos::Schedule<Kokkos::Static>,
  Kokkos::IndexType<pFlow::uint32>>;
 
using hostRPolicyStatic = Kokkos::RangePolicy<
  Kokkos::DefaultExecutionSpace,
  Kokkos::Schedule<Kokkos::Static>,
  Kokkos::IndexType<pFlow::uint32>>;
 
using deviceRPolicyDynamic = Kokkos::RangePolicy<
  Kokkos::DefaultExecutionSpace,
  Kokkos::Schedule<Kokkos::Dynamic>,
  Kokkos::IndexType<pFlow::uint32>>;
 
using hostRPolicyDynamic = Kokkos::RangePolicy<
  Kokkos::DefaultExecutionSpace,
  Kokkos::Schedule<Kokkos::Dynamic>,
  Kokkos::IndexType<pFlow::uint32>>;
 
template<typename T1, typename T2>
using Pair = Kokkos::pair<T1, T2>;
 
template<typename T, typename... properties>
using ViewTypeScalar = Kokkos::View<T, properties...>;
 
template<typename T, typename... properties>
using ViewType1D = Kokkos::View<T*, properties...>;
 
template<typename T, typename... properties>
using ViewType2D = Kokkos::View<T**, properties...>;
 
template<typename T, typename... properties>
using ViewType3D = Kokkos::View<T***, properties...>;
 
template<typename T, typename... properties>
using DualViewType1D = Kokkos::DualView<T*, properties...>;
 
template<typename Key, typename Value, typename... properties>
using unorderedMap = Kokkos::UnorderedMap<Key, Value, properties...>;
 
template<typename Key, typename... properties>
using unorderedSet = Kokkos::UnorderedMap<Key, void, properties...>;
 
template<typename T>
using deviceViewTypeScalar = Kokkos::View<T>;
 
template<typename T>
using deviceViewType1D = Kokkos::View<T*>;
 
template<typename T, typename Layout = void>
using deviceViewType2D = Kokkos::View<T**, Layout, void>;
 
template<typename T, typename Layout = void>
using deviceViewType3D = Kokkos::View<T***, Layout, void>;
 
template<typename T>
using hostViewTypeScalar = Kokkos::View<T, Kokkos::HostSpace>;
 
template<typename T>
using hostViewType1D = Kokkos::View<T*, Kokkos::HostSpace>;
 
template<typename T, typename Layout = void>
using hostViewType2D = Kokkos::View<T**, Layout, Kokkos::HostSpace>;
 
template<typename T, typename Layout = void>
using hostViewType3D = Kokkos::View<T***, Layout, Kokkos::HostSpace>;
 
template<typename T>
using deviceAtomicViewType1D = Kokkos::View<
  T*,
  Kokkos::MemoryTraits<
    std::is_same_v<DefaultExecutionSpace, Serial> ? 0 : Kokkos::Atomic>>;
 
template<typename T>
using deviceAtomicViewType3D = Kokkos::View<
  T***,
  Kokkos::MemoryTraits<
    std::is_same_v<DefaultExecutionSpace, Serial> ? 0 : Kokkos::Atomic>>;
 
} // pFlow
 
#endif //__KokkosTypes_hpp__