Kokkos Core Kernels Package  Version of the Day
Kokkos_HBWSpace.hpp
1 /*
2 //@HEADER
3 // ************************************************************************
4 //
5 // Kokkos v. 2.0
6 // Copyright (2014) Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact H. Carter Edwards (hcedwar@sandia.gov)
39 //
40 // ************************************************************************
41 //@HEADER
42 */
43 
44 #ifndef KOKKOS_HBWSPACE_HPP
45 #define KOKKOS_HBWSPACE_HPP
46 
47 
48 #include <Kokkos_HostSpace.hpp>
49 #include <impl/Kokkos_HBWAllocators.hpp>
50 
51 /*--------------------------------------------------------------------------*/
52 #ifdef KOKKOS_HAVE_HBWSPACE
53 
54 namespace Kokkos {
55 namespace Experimental {
56 namespace Impl {
57 
64 void init_lock_array_hbw_space();
65 
71 bool lock_address_hbw_space(void* ptr);
72 
79 void unlock_address_hbw_space(void* ptr);
80 
81 } // namespace Impl
82 } // neamspace Experimental
83 } // namespace Kokkos
84 
85 namespace Kokkos {
86 namespace Experimental {
87 
93 class HBWSpace {
94 public:
95 
97  typedef HBWSpace memory_space ;
98  typedef size_t size_type ;
99 
106 #if defined( KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_OPENMP )
107  typedef Kokkos::OpenMP execution_space ;
108 #elif defined( KOKKOS_HAVE_DEFAULT_DEVICE_TYPE_THREADS )
109  typedef Kokkos::Threads execution_space ;
110 #elif defined( KOKKOS_HAVE_OPENMP )
111  typedef Kokkos::OpenMP execution_space ;
112 #elif defined( KOKKOS_HAVE_PTHREAD )
113  typedef Kokkos::Threads execution_space ;
114 #elif defined( KOKKOS_HAVE_SERIAL )
115  typedef Kokkos::Serial execution_space ;
116 #else
117 # error "At least one of the following host execution spaces must be defined: Kokkos::OpenMP, Kokkos::Serial, or Kokkos::Threads. You might be seeing this message if you disabled the Kokkos::Serial device explicitly using the Kokkos_ENABLE_Serial:BOOL=OFF CMake option, but did not enable any of the other host execution space devices."
118 #endif
119 
122 
123  /*--------------------------------*/
124 #if ! defined( KOKKOS_USING_EXPERIMENTAL_VIEW )
125 
126  typedef Impl::HBWMallocAllocator allocator ;
127 
134  static Kokkos::Impl::AllocationTracker allocate_and_track( const std::string & label, const size_t size );
135 
136 #endif /* #if ! defined( KOKKOS_USING_EXPERIMENTAL_VIEW ) */
137 
138  /*--------------------------------*/
139  /* Functions unique to the HBWSpace */
140  static int in_parallel();
141 
142  static void register_in_parallel( int (*)() );
143 
144  /*--------------------------------*/
145 
147  HBWSpace();
148  HBWSpace( const HBWSpace & rhs ) = default ;
149  HBWSpace & operator = ( const HBWSpace & ) = default ;
150  ~HBWSpace() = default ;
151 
154  enum AllocationMechanism { STD_MALLOC , POSIX_MEMALIGN , POSIX_MMAP , INTEL_MM_ALLOC };
155 
156  explicit
157  HBWSpace( const AllocationMechanism & );
158 
160  void * allocate( const size_t arg_alloc_size ) const ;
161 
163  void deallocate( void * const arg_alloc_ptr
164  , const size_t arg_alloc_size ) const ;
165 
166 private:
167 
168  AllocationMechanism m_alloc_mech ;
169 
170  friend class Kokkos::Experimental::Impl::SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void > ;
171 };
172 
173 } // namespace Experimental
174 } // namespace Kokkos
175 
176 //----------------------------------------------------------------------------
177 //----------------------------------------------------------------------------
178 
179 namespace Kokkos {
180 namespace Experimental {
181 namespace Impl {
182 
183 template<>
184 class SharedAllocationRecord< Kokkos::Experimental::HBWSpace , void >
185  : public SharedAllocationRecord< void , void >
186 {
187 private:
188 
189  friend Kokkos::Experimental::HBWSpace ;
190 
191  typedef SharedAllocationRecord< void , void > RecordBase ;
192 
193  SharedAllocationRecord( const SharedAllocationRecord & ) = delete ;
194  SharedAllocationRecord & operator = ( const SharedAllocationRecord & ) = delete ;
195 
196  static void deallocate( RecordBase * );
197 
199  static RecordBase s_root_record ;
200 
201  const Kokkos::Experimental::HBWSpace m_space ;
202 
203 protected:
204 
205  ~SharedAllocationRecord();
206  SharedAllocationRecord() = default ;
207 
208  SharedAllocationRecord( const Kokkos::Experimental::HBWSpace & arg_space
209  , const std::string & arg_label
210  , const size_t arg_alloc_size
211  , const RecordBase::function_type arg_dealloc = & deallocate
212  );
213 
214 public:
215 
216  inline
217  std::string get_label() const
218  {
219  return std::string( RecordBase::head()->m_label );
220  }
221 
222  KOKKOS_INLINE_FUNCTION static
223  SharedAllocationRecord * allocate( const Kokkos::Experimental::HBWSpace & arg_space
224  , const std::string & arg_label
225  , const size_t arg_alloc_size
226  )
227  {
228 #if defined( KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST )
229  return new SharedAllocationRecord( arg_space , arg_label , arg_alloc_size );
230 #else
231  return (SharedAllocationRecord *) 0 ;
232 #endif
233  }
234 
236  static
237  void * allocate_tracked( const Kokkos::Experimental::HBWSpace & arg_space
238  , const std::string & arg_label
239  , const size_t arg_alloc_size );
240 
242  static
243  void * reallocate_tracked( void * const arg_alloc_ptr
244  , const size_t arg_alloc_size );
245 
247  static
248  void deallocate_tracked( void * const arg_alloc_ptr );
249 
250 
251  static SharedAllocationRecord * get_record( void * arg_alloc_ptr );
252 
253  static void print_records( std::ostream & , const Kokkos::Experimental::HBWSpace & , bool detail = false );
254 };
255 
256 } // namespace Impl
257 } // namespace Experimental
258 } // namespace Kokkos
259 
260 //----------------------------------------------------------------------------
261 //----------------------------------------------------------------------------
262 
263 namespace Kokkos {
264 namespace Impl {
265 
266 
267 template<class ExecutionSpace>
268 struct DeepCopy<Experimental::HBWSpace,Experimental::HBWSpace,ExecutionSpace> {
269  DeepCopy( void * dst , const void * src , size_t n ) {
270  memcpy( dst , src , n );
271  }
272  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n ) {
273  exec.fence();
274  memcpy( dst , src , n );
275  }
276 };
277 
278 template<class ExecutionSpace>
279 struct DeepCopy<HostSpace,Experimental::HBWSpace,ExecutionSpace> {
280  DeepCopy( void * dst , const void * src , size_t n ) {
281  memcpy( dst , src , n );
282  }
283  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n ) {
284  exec.fence();
285  memcpy( dst , src , n );
286  }
287 };
288 
289 template<class ExecutionSpace>
290 struct DeepCopy<Experimental::HBWSpace,HostSpace,ExecutionSpace> {
291  DeepCopy( void * dst , const void * src , size_t n ) {
292  memcpy( dst , src , n );
293  }
294  DeepCopy( const ExecutionSpace& exec, void * dst , const void * src , size_t n ) {
295  exec.fence();
296  memcpy( dst , src , n );
297  }
298 };
299 
300 } // namespace Impl
301 } // namespace Kokkos
302 
303 namespace Kokkos {
304 namespace Impl {
305 
306 template<>
307 struct VerifyExecutionCanAccessMemorySpace< Kokkos::HostSpace , Kokkos::Experimental::HBWSpace >
308 {
309  enum { value = true };
310  inline static void verify( void ) { }
311  inline static void verify( const void * ) { }
312 };
313 
314 template<>
315 struct VerifyExecutionCanAccessMemorySpace< Kokkos::Experimental::HBWSpace , Kokkos::HostSpace >
316 {
317  enum { value = true };
318  inline static void verify( void ) { }
319  inline static void verify( const void * ) { }
320 };
321 
322 } // namespace Impl
323 } // namespace Kokkos
324 
325 #endif
326 #endif /* #define KOKKOS_HBWSPACE_HPP */
327 
Memory space for main process and CPU execution spaces.
Memory management for host memory.