Point Cloud Library (PCL)  1.12.1-dev
device_array.hpp
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Copyright (c) 2011, Willow Garage, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above
14  * copyright notice, this list of conditions and the following
15  * disclaimer in the documentation and/or other materials provided
16  * with the distribution.
17  * * Neither the name of Willow Garage, Inc. nor the names of its
18  * contributors may be used to endorse or promote products derived
19  * from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * Author: Anatoly Baskeheev, Itseez Ltd, (myname.mysurname@mycompany.com)
35  */
36 
37 #ifndef PCL_GPU_CONTAINER_DEVICE_ARRAY_IMPL_HPP_
38 #define PCL_GPU_CONTAINER_DEVICE_ARRAY_IMPL_HPP_
39 
40 namespace pcl {
41 
42 namespace gpu {
43 
44 //////////////////// Inline implementations of DeviceArray //////////////////
45 
46 template <class T>
48 {}
49 
50 template <class T>
51 inline DeviceArray<T>::DeviceArray(std::size_t size) : DeviceMemory(size * elem_size)
52 {}
53 
54 template <class T>
55 inline DeviceArray<T>::DeviceArray(T* ptr, std::size_t size)
56 : DeviceMemory(ptr, size * elem_size)
57 {}
58 
59 template <class T>
61 {}
62 
63 template <class T>
64 inline DeviceArray<T>&
66 {
67  DeviceMemory::operator=(other);
68  return *this;
69 }
70 
71 template <class T>
72 inline void
73 DeviceArray<T>::create(std::size_t size)
74 {
75  DeviceMemory::create(size * elem_size);
76 }
77 
78 template <class T>
79 inline void
81 {
82  DeviceMemory::release();
83 }
84 
85 template <class T>
86 inline void
88 {
89  DeviceMemory::copyTo(other);
90 }
91 
92 template <class T>
93 inline void
94 DeviceArray<T>::upload(const T* host_ptr, std::size_t size)
95 {
96  DeviceMemory::upload(host_ptr, size * elem_size);
97 }
98 
99 template <class T>
100 inline bool
101 DeviceArray<T>::upload(const T* host_ptr,
102  std::size_t device_begin_offset,
103  std::size_t num_elements)
104 {
105  std::size_t begin_byte_offset = device_begin_offset * sizeof(T);
106  std::size_t num_bytes = num_elements * sizeof(T);
107  return DeviceMemory::upload(host_ptr, begin_byte_offset, num_bytes);
108 }
109 
110 template <class T>
111 inline void
112 DeviceArray<T>::download(T* host_ptr) const
113 {
114  DeviceMemory::download(host_ptr);
115 }
116 
117 template <class T>
118 inline bool
120  std::size_t device_begin_offset,
121  std::size_t num_elements) const
122 {
123  std::size_t begin_byte_offset = device_begin_offset * sizeof(T);
124  std::size_t num_bytes = num_elements * sizeof(T);
125  return DeviceMemory::download(host_ptr, begin_byte_offset, num_bytes);
126 }
127 
128 template <class T>
129 void
131 {
132  DeviceMemory::swap(other_arg);
133 }
134 
135 template <class T>
137 {
138  return ptr();
139 }
140 
141 template <class T>
142 inline DeviceArray<T>::operator const T*() const
143 {
144  return ptr();
145 }
146 
147 template <class T>
148 inline std::size_t
150 {
151  return sizeBytes() / elem_size;
152 }
153 
154 template <class T>
155 inline T*
157 {
158  return DeviceMemory::ptr<T>();
159 }
160 
161 template <class T>
162 inline const T*
163 DeviceArray<T>::ptr() const
164 {
165  return DeviceMemory::ptr<T>();
166 }
167 
168 template <class T>
169 template <class A>
170 inline void
171 DeviceArray<T>::upload(const std::vector<T, A>& data)
172 {
173  upload(&data[0], data.size());
174 }
175 
176 template <class T>
177 template <class A>
178 inline void
179 DeviceArray<T>::download(std::vector<T, A>& data) const
180 {
181  data.resize(size());
182  if (!data.empty())
183  download(&data[0]);
184 }
185 
186 /////////////////// Inline implementations of DeviceArray2D //////////////////
187 
188 template <class T>
190 {}
191 
192 template <class T>
193 inline DeviceArray2D<T>::DeviceArray2D(int rows, int cols)
194 : DeviceMemory2D(rows, cols * elem_size)
195 {}
196 
197 template <class T>
199  int cols,
200  void* data,
201  std::size_t stepBytes)
202 : DeviceMemory2D(rows, cols * elem_size, data, stepBytes)
203 {}
204 
205 template <class T>
207 : DeviceMemory2D(other)
208 {}
209 
210 template <class T>
211 inline DeviceArray2D<T>&
213 {
214  DeviceMemory2D::operator=(other);
215  return *this;
216 }
217 
218 template <class T>
219 inline void
220 DeviceArray2D<T>::create(int rows, int cols)
221 {
222  DeviceMemory2D::create(rows, cols * elem_size);
223 }
224 
225 template <class T>
226 inline void
228 {
229  DeviceMemory2D::release();
230 }
231 
232 template <class T>
233 inline void
235 {
236  DeviceMemory2D::copyTo(other);
237 }
238 
239 template <class T>
240 inline void
241 DeviceArray2D<T>::upload(const void* host_ptr,
242  std::size_t host_step,
243  int rows,
244  int cols)
245 {
246  DeviceMemory2D::upload(host_ptr, host_step, rows, cols * elem_size);
247 }
248 
249 template <class T>
250 inline void
251 DeviceArray2D<T>::download(void* host_ptr, std::size_t host_step) const
252 {
253  DeviceMemory2D::download(host_ptr, host_step);
254 }
255 
256 template <class T>
257 template <class A>
258 inline void
259 DeviceArray2D<T>::upload(const std::vector<T, A>& data, int cols)
260 {
261  upload(&data[0], cols * elem_size, data.size() / cols, cols);
262 }
263 
264 template <class T>
265 template <class A>
266 inline void
267 DeviceArray2D<T>::download(std::vector<T, A>& data, int& elem_step) const
268 {
269  elem_step = cols();
270  data.resize(cols() * rows());
271  if (!data.empty())
272  download(&data[0], colsBytes());
273 }
274 
275 template <class T>
276 void
278 {
279  DeviceMemory2D::swap(other_arg);
280 }
281 
282 template <class T>
283 inline T*
285 {
286  return DeviceMemory2D::ptr<T>(y);
287 }
288 
289 template <class T>
290 inline const T*
292 {
293  return DeviceMemory2D::ptr<T>(y);
294 }
295 
296 template <class T>
298 {
299  return ptr();
300 }
301 
302 template <class T>
303 inline DeviceArray2D<T>::operator const T*() const
304 {
305  return ptr();
306 }
307 
308 template <class T>
309 inline int
311 {
312  return DeviceMemory2D::colsBytes() / elem_size;
313 }
314 
315 template <class T>
316 inline int
318 {
319  return DeviceMemory2D::rows();
320 }
321 
322 template <class T>
323 inline std::size_t
325 {
326  return DeviceMemory2D::step() / elem_size;
327 }
328 
329 } // namespace gpu
330 } // namespace pcl
331 
332 #endif /* PCL_GPU_CONTAINER_DEVICE_ARRAY_IMPL_HPP_ */
pcl
Definition: convolution.h:46
pcl::gpu::DeviceArray2D
DeviceArray2D class
Definition: device_array.h:188
pcl::gpu::DeviceArray::DeviceArray
DeviceArray()
Empty constructor.
Definition: device_array.hpp:47
pcl::gpu::DeviceArray
DeviceArray class
Definition: device_array.h:54
pcl::gpu::DeviceMemory
DeviceMemory class
Definition: device_memory.h:54
pcl::gpu::DeviceMemory2D
DeviceMemory2D class
Definition: device_memory.h:183