1. Containers, Iterators, Algorithms, Thrust
Richard Kelley

2. we want faster programs!
problem
we want to use the GPU
we don’t want to use CUDA or OpenCL
solution
use a library that “acts like” something we already know.
Thrust to the rescue!

3. Thrust what is it? exactly what we want.
from the Thrust webpage:
“Thrust is a CUDA library of parallel algorithms with an interface resembling the C++ Standard Template Library (STL). Thrust provides a high-level interface for GPU programming that greatly enhances developer productivity.”
exactly what we want.
but we need to be comfortable with the STL to use thrust.

4. what is the STL? precursor to the standard library
the major parts are still around
containers
iterators
algorithms
functors
thrust is based on these abstractions
not object-oriented, but functional and generic
we don’t combine data and operations, we explicitly separate them.

5. containers STL containers are what they sound like
objects that hold other objects
the primary goal (in this part of the standard library) is efficiency
error-checking takes a secondary role almost everywhere
there are containers for most of the data structures you’re likely to use
dynamic arrays, deques, linked lists
balanced binary trees
hash tables (new in C++11)

6. container types (1/2) three main types (as of c++11)
sequence containers
std::vector – a dynamically resizable array
std::deque – a dynamically resizable double-ended queue
std::list – a doubly linked list
associative containers (elements must implement <)
std::map – efficient key-value stores. keys must be unique
std::set – a set of things. elements must be unique
std::multimap – key-value stores, keys needn’t be unique
std::multiset – a multiset of things. elements needn’t be unique

7. container types (2/2) unordered associative containers (hash tables)
std::unordered_set
std::unordered_multiset
std::unordered_map
std::unordered_multimap
they say “unordered” to avoid name conflicts with libraries that made their own “hash_*”
this is new in C++11 – your mileage may vary.

8. common operations on containers
constructor, destructor
constructor(beg, end)
size()
empty()
max_size()
begin(), end()
rbegin(), rend()
insert(pos, elem)
erase(beg, end)
clear()

9. iterators object that can iterate over a collection
duh
an iterator’s value represents a position in a container
an iterator is anything that acts like an iterator:
operator*
operator++ (sometimes operator--)
operators == and !=
operator=
Containers have functions that return special iterators
begin
end

10. iterators categories C++ offers a few categories of iterator.
input iterators
output iterators
forward iterators
bidirectional iterators
random access iterators

11. algorithms
STL contains several algorithms to do stuff with containers.
global functions
accept ranges defined by iterators

12. algorithm types (1/6) nonmodifying algorithms count() count_if()
min_element()
max_element()
find(), find_if() …

13. algorithm types (2/6) modifying algorithms for_each
copy, copy_backward
transform
merge …

14. algorithm types (3/6) removing algorithms remove, remove_if unique
removes adjacent duplicates

15. algorithm types (4/6)
mutating algorithms (change element orders, not values)
reverse
rotate
next_permutation, prev_permutation
random_shuffle
partition, stable_partition

16. algorithm types (5/6) sorting algorithms sort stable_sort partial_sort
probably quicksort. maybe introsort (quicksort+heapsort).
stable_sort
probably mergesort.
partial_sort
just do the first n elements. probably heapsort.
make_heap
push_heap
pop_heap
sort_heap

17. algorithm types (6/6) algorithms for sorted ranges binary_search merge
set_union
set_intersection
set_difference
set_symmetric_difference

18. functors (function objects)
any object that has overloaded operator()
yes, you can do that
also called “function objects”
can have internal state
(probably) faster than a function pointer
I haven’t checked this

19. code!
let’s look at some

20. what does Thrust give us?
thrust aims to “look like” STL, but runs on the GPU
you get speedup doing little beyond what you would do in STL.
sequence containers
host_vector
device_vector
iterators
algorithms
functors are just like standard C++
thrust has some special functors

21. thrust containers we get vectors we have to specify location
thrust::host_vector
resides on the CPU side
thrust::device_vector
resides on the GPU
“host” and “device” are common terms to distinguish between the CPU and the GPU.
we can build thrust containers from std containers

22. thrust iterators & algorithms
basic iterator usage is the same as STL
thrust also has “fancy iterators” that perform additional functionality
(their name, not mine)
thrust algorithms are similar to STL
there are some built-ins that perform simple tasks.
let’s look at some code
add two vectors