CUTLASS: array.h Source File

| CUTLASS CUDA Templates for Linear Algebra Subroutines and Solvers

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

array.h
Go to the documentation of this file.
1 /***************************************************************************************************
2 * Copyright (c) 2017-2019, NVIDIA CORPORATION. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification, are permitted
5 * provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright notice, this list of
7 * conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright notice, this list of
9 * conditions and the following disclaimer in the documentation and/or other materials
10 * provided with the distribution.
11 * * Neither the name of the NVIDIA CORPORATION nor the names of its contributors may be used
12 * to endorse or promote products derived from this software without specific prior written
13 * permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
17 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
19 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
20 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
21 * STRICT LIABILITY, OR TOR (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
22 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 *
24 **************************************************************************************************/
30 #pragma once
31 #include "cutlass/cutlass.h"
32 #include "cutlass/numeric_types.h"
33
34 namespace cutlass {
35
37
39 template <
40 typename T,
41 int N,
42 bool RegisterSized = sizeof_bits<T>::value >= 32
43 >
44 class Array;
45
47
49 template <typename T, int N, bool RegisterSized>
50 struct sizeof_bits<Array<T, N, RegisterSized> > {
51 static int const value =
52 sizeof(typename Array<T, N, RegisterSized>::Storage) * 8 * Array<T, N, RegisterSized>::kStorageElements;
53 };
54
56
58 CUTLASS_HOST_DEVICE
59 constexpr bool ispow2(unsigned x) {
60 return !(x & (x - 1));
61 }
62
64
66 CUTLASS_HOST_DEVICE
67 constexpr unsigned floor_pow_2(unsigned x) {
68 return ispow2(x) ? x : floor_pow_2(x >> 1);
69 }
70
72
74 template <
75 typename T,
76 int N
77 >
78 class Array<T, N, true> {
79 public:
80
82 using Storage = T;
83
85 using Element = T;
86
88 //static std::size_t const kStorageElements = N;
89 static size_t const kStorageElements = N;
90
92 static size_t const kElements = N;
93
94 //
95 // C++ standard members
96 //
97
98 typedef T value_type;
99 typedef size_t size_type;
100 typedef ptrdiff_t difference_type;
101 typedef value_type &reference;
102 typedef value_type const & const_reference;
103 typedef value_type *pointer;
104 typedef value_type const * const_pointer;
105
106 //
107 // Iterators
108 //
109
111 class iterator {
112
114 T *ptr_;
115
116 public:
117
118 CUTLASS_HOST_DEVICE
119 iterator(): ptr_(nullptr) { }
120
121 CUTLASS_HOST_DEVICE
122 iterator(T *_ptr): ptr_(_ptr) { }
123
124 CUTLASS_HOST_DEVICE
125 iterator &operator++() {
126 ++ptr_;
127 return *this;
128 }
129
130 CUTLASS_HOST_DEVICE
131 iterator &operator--() {
132 --ptr_;
133 return *this;
134 }
135
136 CUTLASS_HOST_DEVICE
137 iterator operator++(int) {
138 iterator ret(*this);
139 ++ptr_;
140 return ret;
141 }
142
143 CUTLASS_HOST_DEVICE
144 iterator operator--(int) {
145 iterator ret(*this);
146 --ptr_;
147 return ret;
148 }
149
150 CUTLASS_HOST_DEVICE
151 T &operator*() const {
152 return *ptr_;
153 }
154
155 CUTLASS_HOST_DEVICE
156 bool operator==(iterator const &other) const {
157 return ptr_ == other.ptr_;
158 }
159
160 CUTLASS_HOST_DEVICE
161 bool operator!=(iterator const &other) const {
162 return ptr_ != other.ptr_;
163 }
164 };
165
167 class const_iterator {
168
170 T *ptr_;
171
172 public:
173
174 CUTLASS_HOST_DEVICE
175 const_iterator(): ptr_(nullptr) { }
176
177 CUTLASS_HOST_DEVICE
178 const_iterator(T const *_ptr): ptr_(_ptr) { }
179
180 CUTLASS_HOST_DEVICE
181 const_iterator &operator++() {
182 ++ptr_;
183 return *this;
184 }
185
186 CUTLASS_HOST_DEVICE
187 const_iterator &operator--() {
188 --ptr_;
189 return *this;
190 }
191
192 CUTLASS_HOST_DEVICE
193 const_iterator operator++(int) {
194 const_iterator ret(*this);
195 ++ptr_;
196 return ret;
197 }
198
199 CUTLASS_HOST_DEVICE
200 const_iterator operator--(int) {
201 const_iterator ret(*this);
202 --ptr_;
203 return ret;
204 }
205
206 CUTLASS_HOST_DEVICE
207 T const &operator*() const {
208 return *ptr_;
209 }
210
211 CUTLASS_HOST_DEVICE
212 bool operator==(const_iterator const &other) const {
213 return ptr_ == other.ptr_;
214 }
215
216 CUTLASS_HOST_DEVICE
217 bool operator!=(const_iterator const &other) const {
218 return ptr_ != other.ptr_;
219 }
220 };
221
223 class reverse_iterator {
224
226 T *ptr_;
227
228 public:
229
230 CUTLASS_HOST_DEVICE
231 reverse_iterator(): ptr_(nullptr) { }
232
233 CUTLASS_HOST_DEVICE
234 reverse_iterator(T *_ptr): ptr_(_ptr) { }
235
236 CUTLASS_HOST_DEVICE
237 reverse_iterator &operator++() {
238 --ptr_;
239 return *this;
240 }
241
242 CUTLASS_HOST_DEVICE
243 reverse_iterator &operator--() {
244 ++ptr_;
245 return *this;
246 }
247
248 CUTLASS_HOST_DEVICE
249 reverse_iterator operator++(int) {
250 iterator ret(*this);
251 --ptr_;
252 return ret;
253 }
254
255 CUTLASS_HOST_DEVICE
256 reverse_iterator operator--(int) {
257 iterator ret(*this);
258 ++ptr_;
259 return ret;
260 }
261
262 CUTLASS_HOST_DEVICE
263 T &operator*() const {
264 return *(ptr_ - 1);
265 }
266
267 CUTLASS_HOST_DEVICE
268 bool operator==(reverse_iterator const &other) const {
269 return ptr_ == other.ptr_;
270 }
271
272 CUTLASS_HOST_DEVICE
273 bool operator!=(reverse_iterator const &other) const {
274 return ptr_ != other.ptr_;
275 }
276 };
277
279 class const_reverse_iterator {
280
282 T const *ptr_;
283
284 public:
285
286 CUTLASS_HOST_DEVICE
287 const_reverse_iterator(): ptr_(nullptr) { }
288
289 CUTLASS_HOST_DEVICE
290 const_reverse_iterator(T const *_ptr): ptr_(_ptr) { }
291
292 CUTLASS_HOST_DEVICE
293 const_reverse_iterator &operator++() {
294 --ptr_;
295 return *this;
296 }
297
298 CUTLASS_HOST_DEVICE
299 const_reverse_iterator &operator--() {
300 ++ptr_;
301 return *this;
302 }
303
304 CUTLASS_HOST_DEVICE
305 const_reverse_iterator operator++(int) {
306 const_reverse_iterator ret(*this);
307 --ptr_;
308 return ret;
309 }
310
311 CUTLASS_HOST_DEVICE
312 const_reverse_iterator operator--(int) {
313 const_reverse_iterator ret(*this);
314 ++ptr_;
315 return ret;
316 }
317
318 CUTLASS_HOST_DEVICE
319 T const &operator*() const {
320 return *(ptr_ - 1);
321 }
322
323 CUTLASS_HOST_DEVICE
324 bool operator==(const_iterator const &other) const {
325 return ptr_ == other.ptr_;
326 }
327
328 CUTLASS_HOST_DEVICE
329 bool operator!=(const_iterator const &other) const {
330 return ptr_ != other.ptr_;
331 }
332 };
333
334 private:
335
337 Storage storage[kElements];
338
339 public:
340
341 CUTLASS_HOST_DEVICE
342 Array() { }
343
344 CUTLASS_HOST_DEVICE
345 Array(Array const &x) {
346 CUTLASS_PRAGMA_UNROLL
347 for (int i = 0; i < kElements; ++i) {
348 storage[i] = x.storage[i];
349 }
350 }
351
353 CUTLASS_HOST_DEVICE
354 void clear() {
355 fill(T(0));
356 }
357
358 CUTLASS_HOST_DEVICE
359 reference at(size_type pos) {
360 return reinterpret_cast<reference>(storage[pos]);
361 }
362
363 CUTLASS_HOST_DEVICE
364 const_reference at(size_type pos) const {
365 return reinterpret_cast<const_reference>(storage[pos]);
366 }
367
368 CUTLASS_HOST_DEVICE
369 reference operator[](size_type pos) {
370 return reinterpret_cast<reference>(storage[pos]);
371 }
372
373 CUTLASS_HOST_DEVICE
374 const_reference operator[](size_type pos) const {
375 return reinterpret_cast<const_reference>(storage[pos]);
376 }
377
378 CUTLASS_HOST_DEVICE
379 reference front() {
380 return reinterpret_cast<reference>(storage[0]);
381 }
382
383 CUTLASS_HOST_DEVICE
384 const_reference front() const {
385 return reinterpret_cast<const_reference>(storage[0]);
386 }
387
388 CUTLASS_HOST_DEVICE
389 reference back() {
390 return reinterpret_cast<reference>(storage[kStorageElements - 1]);
391 }
392
393 CUTLASS_HOST_DEVICE
394 const_reference back() const {
395 return reinterpret_cast<const_reference>(storage[kStorageElements - 1]);
396 }
397
398 CUTLASS_HOST_DEVICE
399 pointer data() {
400 return reinterpret_cast<pointer>(storage);
401 }
402
403 CUTLASS_HOST_DEVICE
404 const_pointer data() const {
405 return reinterpret_cast<const_pointer>(storage);
406 }
407
408 CUTLASS_HOST_DEVICE
409 pointer raw_data() {
410 return reinterpret_cast<pointer>(storage);
411 }
412
413 CUTLASS_HOST_DEVICE
414 const_pointer raw_data() const {
415 return reinterpret_cast<const_pointer>(storage);
416 }
417
418
419 CUTLASS_HOST_DEVICE
420 constexpr bool empty() const {
421 return !kElements;
422 }
423
424 CUTLASS_HOST_DEVICE
425 constexpr size_type size() const {
426 return kElements;
427 }
428
429 CUTLASS_HOST_DEVICE
430 constexpr size_type max_size() const {
431 return kElements;
432 }
433
434 CUTLASS_HOST_DEVICE
435 void fill(T const &value) {
436 CUTLASS_PRAGMA_UNROLL
437 for (int i = 0; i < kElements; ++i) {
438 storage[i] = static_cast<Storage>(value);
439 }
440 }
441
442 CUTLASS_HOST_DEVICE
443 iterator begin() {
444 return iterator(storage);
445 }
446
447 CUTLASS_HOST_DEVICE
448 const_iterator cbegin() const {
449 return const_iterator(storage);
450 }
451
452 CUTLASS_HOST_DEVICE
453 iterator end() {
454 return iterator(reinterpret_cast<pointer>(storage + kStorageElements));
455 }
456
457 CUTLASS_HOST_DEVICE
458 const_iterator cend() const {
459 return const_iterator(reinterpret_cast<const_pointer>(storage + kStorageElements));
460 }
461
462 CUTLASS_HOST_DEVICE
463 reverse_iterator rbegin() {
464 return reverse_iterator(reinterpret_cast<pointer>(storage + kStorageElements));
465 }
466
467 CUTLASS_HOST_DEVICE
468 const_reverse_iterator crbegin() const {
469 return const_reverse_iterator(reinterpret_cast<const_pointer>(storage + kStorageElements));
470 }
471
472 CUTLASS_HOST_DEVICE
473 reverse_iterator rend() {
474 return reverse_iterator(reinterpret_cast<pointer>(storage));
475 }
476
477 CUTLASS_HOST_DEVICE
478 const_reverse_iterator crend() const {
479 return const_reverse_iterator(reinterpret_cast<const_pointer>(storage));
480 }
481
482 //
483 // Comparison operators
484 //
485
486 };
487
489
490 } // namespace cutlass
491
493
494 #include "cutlass/array_subbyte.h"
495
497
498 namespace cutlass {
499
501
503 template <
505 typename T,
507 int N,
509 int Alignment = sizeof_bits<T>::value * N / 8
510 >
511 class alignas(Alignment) AlignedArray: public Array<T, N> {
512 public:
513
514 };
515
517
518 } // namespace cutlass
519
521
cutlass::Array< T, N, true >::pointer
value_type * pointer
Definition: array.h:103
cutlass::Array< T, N, true >::iterator::operator!=
CUTLASS_HOST_DEVICE bool operator!=(iterator const &other) const
Definition: array.h:161
cutlass::Array< T, N, true >::const_reverse_iterator::const_reverse_iterator
CUTLASS_HOST_DEVICE const_reverse_iterator()
Definition: array.h:287
cutlass::Array< T, N, true >::const_iterator::const_iterator
CUTLASS_HOST_DEVICE const_iterator(T const *_ptr)
Definition: array.h:178
cutlass::Array< T, N, true >::const_iterator::const_iterator
CUTLASS_HOST_DEVICE const_iterator()
Definition: array.h:175
cutlass::Array< T, N, true >::empty
CUTLASS_HOST_DEVICE constexpr bool empty() const
Definition: array.h:420
cutlass::Array< T, N, true >::crbegin
CUTLASS_HOST_DEVICE const_reverse_iterator crbegin() const
Definition: array.h:468
cutlass::Array< T, N, true >::difference_type
ptrdiff_t difference_type
Definition: array.h:100
cutlass::Array< T, N, true >::reverse_iterator::operator--
CUTLASS_HOST_DEVICE reverse_iterator & operator--()
Definition: array.h:243
cutlass
Definition: aligned_buffer.h:35
constexpr
#define constexpr
Definition: platform.h:137
cutlass::sizeof_bits::value
static int const value
Definition: numeric_types.h:43
cutlass::Array< T, N, true >::const_iterator::operator++
CUTLASS_HOST_DEVICE const_iterator operator++(int)
Definition: array.h:193
cutlass::Array< T, N, true >::fill
CUTLASS_HOST_DEVICE void fill(T const &value)
Definition: array.h:435
array_subbyte.h
Statically sized array of elements that accommodates all CUTLASS-supported numeric types and is safe ...
cutlass::Array< T, N, true >::end
CUTLASS_HOST_DEVICE iterator end()
Definition: array.h:453
cutlass::Array< T, N, true >::data
CUTLASS_HOST_DEVICE pointer data()
Definition: array.h:399
cutlass::Array< T, N, true >::begin
CUTLASS_HOST_DEVICE iterator begin()
Definition: array.h:443
cutlass::Array< T, N, true >::rbegin
CUTLASS_HOST_DEVICE reverse_iterator rbegin()
Definition: array.h:463
cutlass::AlignedArray
Aligned array type.
Definition: array.h:511
cutlass::Array< T, N, true >::operator[]
CUTLASS_HOST_DEVICE const_reference operator[](size_type pos) const
Definition: array.h:374
cutlass::Array< T, N, true >::raw_data
CUTLASS_HOST_DEVICE pointer raw_data()
Definition: array.h:409
cutlass::Array< T, N, true >::rend
CUTLASS_HOST_DEVICE reverse_iterator rend()
Definition: array.h:473
cutlass::Array< T, N, true >::cend
CUTLASS_HOST_DEVICE const_iterator cend() const
Definition: array.h:458
cutlass::Array< T, N, true >::const_reverse_iterator::const_reverse_iterator
CUTLASS_HOST_DEVICE const_reverse_iterator(T const *_ptr)
Definition: array.h:290
cutlass::Array< T, N, true >::reverse_iterator::operator--
CUTLASS_HOST_DEVICE reverse_iterator operator--(int)
Definition: array.h:256
cutlass::Array< T, N, true >::size_type
size_t size_type
Definition: array.h:99
cutlass::Array< T, N, true >::const_reverse_iterator::operator++
CUTLASS_HOST_DEVICE const_reverse_iterator & operator++()
Definition: array.h:293
cutlass::Array< T, N, true >::size
CUTLASS_HOST_DEVICE constexpr size_type size() const
Definition: array.h:425
cutlass::Array< T, N, true >::back
CUTLASS_HOST_DEVICE reference back()
Definition: array.h:389
cutlass::Array< T, N, true >::reverse_iterator::operator!=
CUTLASS_HOST_DEVICE bool operator!=(reverse_iterator const &other) const
Definition: array.h:273
cutlass::Array< T, N, true >::reverse_iterator::operator++
CUTLASS_HOST_DEVICE reverse_iterator operator++(int)
Definition: array.h:249
cutlass::Array< T, N, true >::const_iterator::operator!=
CUTLASS_HOST_DEVICE bool operator!=(const_iterator const &other) const
Definition: array.h:217
cutlass::Array< T, N, true >::const_reverse_iterator::operator!=
CUTLASS_HOST_DEVICE bool operator!=(const_iterator const &other) const
Definition: array.h:329
CUTLASS_PRAGMA_UNROLL
#define CUTLASS_PRAGMA_UNROLL
Definition: cutlass.h:110
cutlass::Array< T, N, true >::const_reference
value_type const & const_reference
Definition: array.h:102
cutlass::Array< T, N, true >::reverse_iterator::operator++
CUTLASS_HOST_DEVICE reverse_iterator & operator++()
Definition: array.h:237
cutlass::Array< T, N, true >::const_iterator::operator*
CUTLASS_HOST_DEVICE T const & operator*() const
Definition: array.h:207
cutlass::Array< T, N, true >::reference
value_type & reference
Definition: array.h:101
cutlass::Array< T, N, true >::iterator::operator==
CUTLASS_HOST_DEVICE bool operator==(iterator const &other) const
Definition: array.h:156
cutlass::Array< T, N, true >::crend
CUTLASS_HOST_DEVICE const_reverse_iterator crend() const
Definition: array.h:478
cutlass::Array< T, N, true >::reverse_iterator::reverse_iterator
CUTLASS_HOST_DEVICE reverse_iterator()
Definition: array.h:231
cutlass::Array< T, N, true >::iterator::operator*
CUTLASS_HOST_DEVICE T & operator*() const
Definition: array.h:151
cutlass::sizeof_bits
Defines the size of an element in bits.
Definition: numeric_types.h:42
cutlass::Array< T, N, true >::iterator::operator++
CUTLASS_HOST_DEVICE iterator operator++(int)
Definition: array.h:137
cutlass::Array< T, N, true >::reverse_iterator::operator==
CUTLASS_HOST_DEVICE bool operator==(reverse_iterator const &other) const
Definition: array.h:268
nullptr
#define nullptr
nullptr
Definition: platform.h:144
cutlass::Array< T, N, true >::iterator::operator++
CUTLASS_HOST_DEVICE iterator & operator++()
Definition: array.h:125
cutlass::Array< T, N, true >::Storage
T Storage
Storage type.
Definition: array.h:82
cutlass::Array< T, N, true >::reverse_iterator::reverse_iterator
CUTLASS_HOST_DEVICE reverse_iterator(T *_ptr)
Definition: array.h:234
cutlass::Array< T, N, true >::iterator::iterator
CUTLASS_HOST_DEVICE iterator(T *_ptr)
Definition: array.h:122
cutlass::Array< T, N, true >::const_iterator::operator++
CUTLASS_HOST_DEVICE const_iterator & operator++()
Definition: array.h:181
cutlass::Array< T, N, true >::back
CUTLASS_HOST_DEVICE const_reference back() const
Definition: array.h:394
cutlass::Array< T, N, true >::iterator::operator--
CUTLASS_HOST_DEVICE iterator & operator--()
Definition: array.h:131
cutlass::Array< T, N, true >::at
CUTLASS_HOST_DEVICE const_reference at(size_type pos) const
Definition: array.h:364
CUTLASS_HOST_DEVICE
#define CUTLASS_HOST_DEVICE
Definition: cutlass.h:89
numeric_types.h
Top-level include for all CUTLASS numeric types.
cutlass::Array< T, N, true >::reverse_iterator::operator*
CUTLASS_HOST_DEVICE T & operator*() const
Definition: array.h:263
cutlass::Array< T, N, true >::const_iterator::operator==
CUTLASS_HOST_DEVICE bool operator==(const_iterator const &other) const
Definition: array.h:212
cutlass::Array< T, N, true >::front
CUTLASS_HOST_DEVICE reference front()
Definition: array.h:379
cutlass::Array< T, N, true >::Element
T Element
Element type.
Definition: array.h:85
cutlass::Array< T, N, true >::raw_data
CUTLASS_HOST_DEVICE const_pointer raw_data() const
Definition: array.h:414
cutlass::Array< T, N, true >::max_size
CUTLASS_HOST_DEVICE constexpr size_type max_size() const
Definition: array.h:430
cutlass::Array< T, N, true >::data
CUTLASS_HOST_DEVICE const_pointer data() const
Definition: array.h:404
cutlass::Array< T, N, true >::const_reverse_iterator::operator==
CUTLASS_HOST_DEVICE bool operator==(const_iterator const &other) const
Definition: array.h:324
cutlass::Array< T, N, true >::iterator::iterator
CUTLASS_HOST_DEVICE iterator()
Definition: array.h:119
cutlass::ispow2
CUTLASS_HOST_DEVICE constexpr bool ispow2(unsigned x)
Returns true if the argument is a power of 2.
Definition: array.h:59
cutlass::Array< T, N, true >::Array
CUTLASS_HOST_DEVICE Array(Array const &x)
Definition: array.h:345
cutlass::Array< T, N, true >::iterator::operator--
CUTLASS_HOST_DEVICE iterator operator--(int)
Definition: array.h:144
cutlass::floor_pow_2
CUTLASS_HOST_DEVICE constexpr unsigned floor_pow_2(unsigned x)
Returns the largest power of two not greater than the argument.
Definition: array.h:67
cutlass::Array< T, N, true >::const_reverse_iterator::operator--
CUTLASS_HOST_DEVICE const_reverse_iterator operator--(int)
Definition: array.h:312
cutlass::Array< T, N, true >::const_pointer
value_type const * const_pointer
Definition: array.h:104
cutlass::Array< T, N, true >::const_reverse_iterator::operator--
CUTLASS_HOST_DEVICE const_reverse_iterator & operator--()
Definition: array.h:299
cutlass::Array< T, N, true >::value_type
T value_type
Definition: array.h:98
cutlass::Array< T, N, true >::operator[]
CUTLASS_HOST_DEVICE reference operator[](size_type pos)
Definition: array.h:369
cutlass::Array< T, N, true >::cbegin
CUTLASS_HOST_DEVICE const_iterator cbegin() const
Definition: array.h:448
cutlass::Array< T, N, true >::Array
CUTLASS_HOST_DEVICE Array()
Definition: array.h:342
cutlass::Array< T, N, true >::const_iterator::operator--
CUTLASS_HOST_DEVICE const_iterator operator--(int)
Definition: array.h:200
cutlass::Array< T, N, true >::const_reverse_iterator::operator++
CUTLASS_HOST_DEVICE const_reverse_iterator operator++(int)
Definition: array.h:305
cutlass.h
Basic include for CUTLASS.
cutlass::Array< T, N, true >::const_reverse_iterator::operator*
CUTLASS_HOST_DEVICE T const & operator*() const
Definition: array.h:319
cutlass::Array< T, N, true >::front
CUTLASS_HOST_DEVICE const_reference front() const
Definition: array.h:384
cutlass::Array< T, N, true >::at
CUTLASS_HOST_DEVICE reference at(size_type pos)
Definition: array.h:359
cutlass::Array< T, N, true >::const_iterator::operator--
CUTLASS_HOST_DEVICE const_iterator & operator--()
Definition: array.h:187
cutlass::Array< T, N, true >::clear
CUTLASS_HOST_DEVICE void clear()
Efficient clear method.
Definition: array.h:354