Kokkos Core Kernels Package  Version of the Day
Kokkos_HBWSpace.hpp
1 /*
2 //@HEADER
3 // ************************************************************************
4 //
5 // Kokkos v. 3.0
6 // Copyright (2020) National Technology & Engineering
7 // Solutions of Sandia, LLC (NTESS).
8 //
9 // Under the terms of Contract DE-NA0003525 with NTESS,
10 // the U.S. Government retains certain rights in this software.
11 //
12 // Redistribution and use in source and binary forms, with or without
13 // modification, are permitted provided that the following conditions are
14 // met:
15 //
16 // 1. Redistributions of source code must retain the above copyright
17 // notice, this list of conditions and the following disclaimer.
18 //
19 // 2. Redistributions in binary form must reproduce the above copyright
20 // notice, this list of conditions and the following disclaimer in the
21 // documentation and/or other materials provided with the distribution.
22 //
23 // 3. Neither the name of the Corporation nor the names of the
24 // contributors may be used to endorse or promote products derived from
25 // this software without specific prior written permission.
26 //
27 // THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
28 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
31 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 //
39 // Questions? Contact Christian R. Trott (crtrott@sandia.gov)
40 //
41 // ************************************************************************
42 //@HEADER
43 */
44 
45 #ifndef KOKKOS_HBWSPACE_HPP
46 #define KOKKOS_HBWSPACE_HPP
47 
48 #include <Kokkos_Macros.hpp>
49 #ifdef KOKKOS_ENABLE_HBWSPACE
50 
51 #include <Kokkos_HostSpace.hpp>
52 
53 namespace Kokkos {
54 
55 namespace Experimental {
56 
57 namespace Impl {
58 
65 void init_lock_array_hbw_space();
66 
72 bool lock_address_hbw_space(void* ptr);
73 
80 void unlock_address_hbw_space(void* ptr);
81 
82 } // namespace Impl
83 
84 } // namespace Experimental
85 
86 } // namespace Kokkos
87 
88 namespace Kokkos {
89 
90 namespace Experimental {
91 
97 class HBWSpace {
98  public:
100  using memory_space = HBWSpace;
101  using size_type = size_t;
102 
109  using execution_space = Kokkos::DefaultHostExecutionSpace;
110 
112  using device_type = Kokkos::Device<execution_space, memory_space>;
113 
115  HBWSpace();
116  HBWSpace(const HBWSpace& rhs) = default;
117  HBWSpace& operator=(const HBWSpace&) = default;
118  ~HBWSpace() = default;
119 
123  enum AllocationMechanism {
124  STD_MALLOC,
125  POSIX_MEMALIGN,
126  POSIX_MMAP,
127  INTEL_MM_ALLOC
128  };
129 
130  explicit HBWSpace(const AllocationMechanism&);
131 
133  void* allocate(const size_t arg_alloc_size) const;
134  void* allocate(const char* arg_label, const size_t arg_alloc_size,
135  const size_t arg_logical_size = 0) const;
136 
138  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
139  void deallocate(const char* arg_label, void* const arg_alloc_ptr,
140  const size_t arg_alloc_size,
141  const size_t arg_logical_size = 0) const;
142 
143  private:
144  template <class, class, class, class>
145  friend class LogicalMemorySpace;
146 
147  void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
148  const size_t arg_logical_size = 0,
149  const Kokkos::Tools::SpaceHandle =
150  Kokkos::Tools::make_space_handle(name())) const;
151  void impl_deallocate(const char* arg_label, void* const arg_alloc_ptr,
152  const size_t arg_alloc_size,
153  const size_t arg_logical_size = 0,
154  const Kokkos::Tools::SpaceHandle =
155  Kokkos::Tools::make_space_handle(name())) const;
156 
157  public:
159  static constexpr const char* name() { return "HBW"; }
160 
161  private:
162  AllocationMechanism m_alloc_mech;
163  friend class Kokkos::Impl::SharedAllocationRecord<
164  Kokkos::Experimental::HBWSpace, void>;
165 };
166 
167 } // namespace Experimental
168 
169 } // namespace Kokkos
170 
171 //----------------------------------------------------------------------------
172 
173 namespace Kokkos {
174 
175 namespace Impl {
176 
177 template <>
178 class SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>
179  : public SharedAllocationRecord<void, void> {
180  private:
181  friend Kokkos::Experimental::HBWSpace;
182 
183  using RecordBase = SharedAllocationRecord<void, void>;
184 
185  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
186  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
187 
188  static void deallocate(RecordBase*);
189 
190 #ifdef KOKKOS_ENABLE_DEBUG
191 
192  static RecordBase s_root_record;
193 #endif
194 
195  const Kokkos::Experimental::HBWSpace m_space;
196 
197  protected:
198  ~SharedAllocationRecord()
199 #if defined( \
200  KOKKOS_IMPL_INTEL_WORKAROUND_NOEXCEPT_SPECIFICATION_VIRTUAL_FUNCTION)
201  noexcept
202 #endif
203  ;
204  SharedAllocationRecord() = default;
205 
206  SharedAllocationRecord(
207  const Kokkos::Experimental::HBWSpace& arg_space,
208  const std::string& arg_label, const size_t arg_alloc_size,
209  const RecordBase::function_type arg_dealloc = &deallocate);
210 
211  public:
212  inline std::string get_label() const {
213  return std::string(RecordBase::head()->m_label);
214  }
215 
216  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
217  const Kokkos::Experimental::HBWSpace& arg_space,
218  const std::string& arg_label, const size_t arg_alloc_size) {
219 #if defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
220  return new SharedAllocationRecord(arg_space, arg_label, arg_alloc_size);
221 #else
222  return (SharedAllocationRecord*)0;
223 #endif
224  }
225 
227  static void* allocate_tracked(const Kokkos::Experimental::HBWSpace& arg_space,
228  const std::string& arg_label,
229  const size_t arg_alloc_size);
230 
232  static void* reallocate_tracked(void* const arg_alloc_ptr,
233  const size_t arg_alloc_size);
234 
236  static void deallocate_tracked(void* const arg_alloc_ptr);
237 
238  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
239 
240  static void print_records(std::ostream&,
241  const Kokkos::Experimental::HBWSpace&,
242  bool detail = false);
243 };
244 
245 } // namespace Impl
246 
247 } // namespace Kokkos
248 
249 //----------------------------------------------------------------------------
250 
251 namespace Kokkos {
252 
253 namespace Impl {
254 
255 static_assert(
256  Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::HBWSpace,
257  Kokkos::Experimental::HBWSpace>::assignable,
258  "");
259 
260 template <>
261 struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::Experimental::HBWSpace> {
262  enum : bool { assignable = true };
263  enum : bool { accessible = true };
264  enum : bool { deepcopy = true };
265 };
266 
267 template <>
268 struct MemorySpaceAccess<Kokkos::Experimental::HBWSpace, Kokkos::HostSpace> {
269  enum : bool { assignable = false };
270  enum : bool { accessible = true };
271  enum : bool { deepcopy = true };
272 };
273 
274 } // namespace Impl
275 
276 } // namespace Kokkos
277 
278 //----------------------------------------------------------------------------
279 
280 namespace Kokkos {
281 
282 namespace Impl {
283 
284 template <class ExecutionSpace>
285 struct DeepCopy<Kokkos::Experimental::HBWSpace, Kokkos::Experimental::HBWSpace,
286  ExecutionSpace> {
287  DeepCopy(void* dst, const void* src, size_t n) { memcpy(dst, src, n); }
288 
289  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
290  exec.fence();
291  memcpy(dst, src, n);
292  }
293 };
294 
295 template <class ExecutionSpace>
296 struct DeepCopy<HostSpace, Kokkos::Experimental::HBWSpace, ExecutionSpace> {
297  DeepCopy(void* dst, const void* src, size_t n) { memcpy(dst, src, n); }
298 
299  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
300  exec.fence();
301  memcpy(dst, src, n);
302  }
303 };
304 
305 template <class ExecutionSpace>
306 struct DeepCopy<Kokkos::Experimental::HBWSpace, HostSpace, ExecutionSpace> {
307  DeepCopy(void* dst, const void* src, size_t n) { memcpy(dst, src, n); }
308 
309  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
310  exec.fence();
311  memcpy(dst, src, n);
312  }
313 };
314 
315 } // namespace Impl
316 
317 } // namespace Kokkos
318 
319 #endif
320 #endif // #define KOKKOS_HBWSPACE_HPP
Memory management for host memory.
Definition: dummy.cpp:3
Access relationship between DstMemorySpace and SrcMemorySpace.