// @HEADER // ***************************************************************************** // Stokhos Package // // Copyright 2009 NTESS and the Stokhos contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER #if defined( __CUDA_ARCH__ ) namespace Stokhos { template class DynamicThreadedStorage { public: static const bool is_static = false; static const int static_size = 0; static const bool supports_reset = true; typedef ordinal_t ordinal_type; typedef value_t value_type; typedef Kokkos::Cuda execution_space; typedef value_type& reference; typedef volatile value_type& volatile_reference; typedef const value_type& const_reference; typedef const volatile value_type& const_volatile_reference; typedef value_type* pointer; typedef volatile value_type* volatile_pointer; typedef const value_type* const_pointer; typedef const volatile value_type* const_volatile_pointer; typedef Stokhos::DynArrayTraits ds; //! Turn DynamicThreadedStorage into a meta-function class usable with mpl::apply template struct apply { typedef DynamicThreadedStorage type; }; //! Constructor __device__ DynamicThreadedStorage(const ordinal_type& sz = 1, const value_type& x = value_type(0.0)) : sz_(sz), stride_(num_threads()), total_sz_(sz_*stride_) { allocate_coeff_array(coeff_, is_owned_, total_sz_, x); } //! Constructor from array __device__ DynamicThreadedStorage(const ordinal_type& sz, const value_type* x) : sz_(sz), stride_(num_threads()), total_sz_(sz_*stride_) { allocate_coeff_array(coeff_, is_owned_, total_sz_, x); } //! Constructor for creating a view __device__ DynamicThreadedStorage(const ordinal_type& sz, pointer v, bool owned) : coeff_(v), sz_(sz), stride_(num_threads()), total_sz_(sz_*stride_), is_owned_(owned) {} //! Constructor __device__ DynamicThreadedStorage(const DynamicThreadedStorage& s) : sz_(s.sz_), stride_(s.stride_), total_sz_(s.total_sz_) { allocate_coeff_array(coeff_, is_owned_, total_sz_); for (ordinal_type i=0; i total_sz_new) my_tsz = total_sz_new; for (ordinal_type i=0; i total_sz_new) my_tsz = total_sz_new; for (ordinal_type i=0; i KOKKOS_INLINE_FUNCTION reference getCoeff() { return coeff_[i*stride_]; } template KOKKOS_INLINE_FUNCTION volatile_reference getCoeff() volatile { return coeff_[i*stride_]; } template KOKKOS_INLINE_FUNCTION const_reference getCoeff() const { return coeff_[i*stride_]; } template KOKKOS_INLINE_FUNCTION const_volatile_reference getCoeff() const volatile { return coeff_[i*stride_]; } //! Get coefficients KOKKOS_INLINE_FUNCTION const_volatile_pointer coeff() const volatile { return coeff_; } //! Get coefficients KOKKOS_INLINE_FUNCTION const_pointer coeff() const { return coeff_; } //! Get coefficients KOKKOS_INLINE_FUNCTION volatile_pointer coeff() volatile { return coeff_; } //! Get coefficients KOKKOS_INLINE_FUNCTION pointer coeff() { return coeff_; } protected: //! Compute number of threads in each block __device__ ordinal_type num_threads() const { return blockDim.x*blockDim.y*blockDim.z; } //! Compute number of threads in each block __device__ ordinal_type num_threads() const volatile { return blockDim.x*blockDim.y*blockDim.z; } //! Compute thread index within a block __device__ ordinal_type thread_index() const { return threadIdx.x + (threadIdx.y + threadIdx.z*blockDim.y)*blockDim.x; } //! Compute thread index within a block __device__ ordinal_type thread_index() const volatile { return threadIdx.x + (threadIdx.y + threadIdx.z*blockDim.y)*blockDim.x; } //! Allocate coefficient array __device__ void allocate_coeff_array(pointer& c, bool& owned, ordinal_type total_size, const value_type& x = value_type(0.0)) { // Allocate coefficient array on thread 0 __shared__ pointer ptr; ordinal_type tidx = thread_index(); if (tidx == 0) { ptr = ds::get_and_fill(total_size,x); owned = true; } else owned = false; __syncthreads(); // Give each thread its portion of the array c = ptr + tidx; } //! Allocate coefficient array __device__ void allocate_coeff_array(pointer& c, bool& owned, ordinal_type total_size, const value_type& x = value_type(0.0)) volatile { // Allocate coefficient array on thread 0 __shared__ pointer ptr; ordinal_type tidx = thread_index(); if (tidx == 0) { ptr = ds::get_and_fill(total_size,x); owned = true; } else owned = false; __syncthreads(); // Give each thread its portion of the array c = ptr + tidx; } //! Allocate coefficient array __device__ void allocate_coeff_array(pointer& c, bool& owned, ordinal_type total_size, const value_type* x) { // Allocate coefficient array on thread 0 __shared__ pointer ptr; ordinal_type tidx = thread_index(); if (tidx == 0) { ptr = ds::get_and_fill(x, total_size); owned = true; } else owned = false; __syncthreads(); // Give each thread its portion of the array c = ptr + tidx; } //! Destroy coefficient array __device__ void destroy_coeff_array(pointer c, bool owned, ordinal_type total_size) { __syncthreads(); if (owned) ds::destroy_and_release(c, total_size); } //! Destroy coefficient array __device__ void destroy_coeff_array(pointer c, bool owned, ordinal_type total_size) volatile { __syncthreads(); if (owned) ds::destroy_and_release(c, total_size); } private: //! Coefficient values pointer coeff_; //! Size of array used ordinal_type sz_; //! Stride of array ordinal_type stride_; //! Total size of array ordinal_type total_sz_; //! Do we own the array bool is_owned_; }; } #endif