Parallelism in C++ J. Daniel Garcia. Universidad Carlos III de Madrid. November 23, 2018

Transcription

1 J. Daniel Garcia Universidad Carlos III de Madrid November 23, 2018 cbea J. Daniel Garcia 1/58

2 Introduction to generic programming 1 Introduction to generic programming 2 STL: Standard Template Library 3 Execution policies 4 5 More? cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 2/58

3 Introduction to generic programming What is generic programming? Approach allowing to generalize program entities. Also known as parametric polymorphism. Provides compile-time polymorphism as opposed to dynamic polymorphism from object orientation. Very good combination of flexibility and performance. Which are the entities that can be generalized? Classes (types) and functions. What can be a parameter for the generic? A type. An integral value. Example template <class T, int N> class buffer { /... / }; buffer<int,100> b1; buffer<char,20> b2; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 3/58

4 Introduction to generic programming Templates: Defining generic types A template allows to define a data type that is parametrized by another data type. vector<double> v; vector<int> w; map<string,int> d; vector<vector<string>> x; A template requires that all definitions are visible at compile time (instead of link time). Practical effect: All definitions in headers. template <typename T> class vector { //... }; template <typename K, typename V> class map { //... }; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 4/58

5 Introduction to generic programming A generic vector class vector.h (I) template <typename T> class vector { public: vector() ; explicit vector( int n); vector(std :: initializer_list <T> il ) ; vector(const vector &); vector & operator=(const vector &); vector(vector &&) = default; vector & operator=(vector &&) = default; T operator[](int i ) const { return vec[i ]; } T & operator[](int i ) { return vec[i ]; } //... cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 5/58

6 Introduction to generic programming A generic vector class vector.h (II) unsigned long num_elems() const { return tam; } unsigned long capacity() const { return total; } void reserve(int n); void redim(int n); void add_end(const T & x); private: unsigned long tam; unsigned long total; std :: unique_ptr<t[]> vec; }; //... cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 6/58

7 Introduction to generic programming Implementing member functions vector.h (III) template <typename T> vector<t>::vector() : tam{0}, total {0}, vec{nullptr} {} template <typename T> vector<t>::vector(int n) : tam{(n>0)?static_cast<unsigned long>(n):0}, total {tam}, vec{make_unique<t[]>(total)} {} cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 7/58

8 Introduction to generic programming Non-type template parameters A template can be defined with a parameter that is not a type but a value. template <typename T, int N> struct array { //... }; Values used in instantiation must be known at compile time. array<double,1024> v1; // OK constexpr int max = 512; array<double, max> v2; // OK int tam = 256; array<double, tam> v3; // Error cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 8/58

9 Introduction to generic programming A template for arrays array.h template <typename T, int N> struct array { T vec[n]; T & operator[](int i ) { return vec[i ]; } const T & operator[](int i ) const { return vec[i ]; } int tam() const { return N; } }; void f () { array<int,12> v; for ( int i=0;i<12;++i) { v[ i ] = 2 i ; } for ( int i=0;i<12;++i) { cout << v[ i ] << endl; } } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 9/58

10 Introduction to generic programming Function templates A template can be used to define a family of functions in a generic way. template <typename O, typename C> void print (O & os, const C & c, string sep) { for (auto & x : c) { os << x << sep; } } Template parameters are deduced at call site. void f () { vector<string> v1 {"C++", "is ", " faster ", "than", "C"}; array<double,4> v2 {1.0, 2.0, 3.0, 4.0}; print (cout, v1, " \n") ; // O >ostream, C >vector<string> print (cout, v2, ", ") ; // O >ostream, C >vector<double> } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 10/58

11 STL: Standard Template Library 1 Introduction to generic programming 2 STL: Standard Template Library 3 Execution policies 4 5 More? cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 11/58

12 STL: Standard Template Library STL: Standard Template Library Originally designed by Alexander Stepanov. Original goal: the most general, efficient and flexible representation of concepts. Represent separate concepts separately in code. Freely combine concepts as long as they make sense. Basic model: Containers: Structures storing data. Iterators: Allows traversing containers. Algorithms: Perform data manipulation independently from containers. cbea J. Daniel Garcia 12/58

13 STL: Standard Template Library Containers A container stores a sequence of objects. Sequences: Allow accessing a sequence (semi-open) of objects. vector<t,a>, deque<t,a>, list<t,a>, forward_list<t,a>, array<t,n>. Associative containers: Allow finding pairs key-value. Ordered: map<k,v,c,a>, multimap<k,v,c,a>, set<k,v,c,a>, multiset<k,v,c,a>. Unordered: unordered_map<k,v,c,a>, unordered_multimap<k,v,c,a>, unordered_set<k,v,c,a>, unordered_multiset<k,v,c,a>. Others: Adaptors and views. Adaptors: stack<t,c>, queue<t,c>, priority_queue<t,c,cmp>. Views: span<t,e>. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 13/58

14 STL: Standard Template Library Iterators An iterator generalizes the abstraction of pointer to perform indirect accesses. Many iterators satisfy the concept of InputIterator. They can advance: ++i. They can access the pointed object: x = *i. They allow for equality comparison: i == j, i!=j. Some iterators support more operations: i, i+n, i+=n, i[n], i<j,... cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 14/58

15 STL: Standard Template Library Iterators and containers All containers have an associated iterator type defined. Type iterator. vector<int>::iterator, list<double>::iterator, deque<string>::iterator,... All containers have two member functions defining their sequence. c.begin(): Iterator to the beginning of the sequence. c.end(): Iterator to one-past-the-end of the sequence. Sequences as semi-open interval [start, end). Print a list of values from container c for (auto i=c.begin(); i!=c.end(); ++i) { cout << i << endl; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 15/58

16 STL: Standard Template Library Algorithms Using iterators allows to define algorithms independently from specific containers. Find a value template <typename I, typename T> I find ( I first, I last, const T & x) { while ( first!= last && first!=x) first ++ return first ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/58

17 STL: Standard Template Library Algorithms Using iterators allows to define algorithms independently from specific containers. Find a value template <typename I, typename T> I find ( I first, I last, const T & x) { while ( first!= last && first!=x) first ++ return first ; } Using find bool has(vector<int> & v, int x) { auto p = find (v.begin(), v.end(), x); return p!=v.end(); } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 16/58

18 STL: Standard Template Library Algorithms and predicates Finding with predicates template <typename I, typename P> I find_if ( I first, I last, P pred) { while ( first!= last &&!pred( first )) prim++; return first ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 17/58

19 STL: Standard Template Library Algorithms and predicates Finding with predicates template <typename I, typename P> I find_if ( I first, I last, P pred) { while ( first!= last &&!pred( first )) prim++; return first ; } Using find vector<int> v {1,2,3,4,5,6,7,8}; auto p = find_if (v.begin(), v.end(), []( int x) { return (x%2==0) && (x%3==0); }); cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 17/58

20 STL: Standard Template Library Algorithms in STL Great variety 90 algorithms. Classification: Sequence algorithms: Modifying and non-modifying. Partitioning, sorting, binary search. Set and heap operations. Minimum and maximum operations. Numeric operations. cbea J. Daniel Garcia 18/58

21 STL: Standard Template Library Applying and operation to a sequence Applies a function object to each element in a sequence. template <typename I, typename F> F for_each(i first, I last, F f ) ; Example vector<int> v {1,2,3,4,5,6,7,8}; for_each(begin(v), end(v), []( int x) { cout << x; }) ; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 19/58

22 STL: Standard Template Library Copying a sequence Copies a sequence into another sequence. template <typename I, typename O> O copy(i first, I last, O first2 ) ; Example vector<int> v {1,2,3,4,5,6,7,8}; vector<int> w; w.resize(8); copy(begin(v), end(v), begin(w)); // w must have enough space. vector<int> z; copy(begin(v), end(v), back_inserter(w)); // Copies by inserting. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 20/58

23 STL: Standard Template Library Transformation Transforms a sequence into another by applying an operation. template <typename I, typename O, typename F> O transform(i first, I last, O first2, F unop); template <typename I, typename O, typename F> O transform(i first1, I last1, I first2, I last2, O first3, F binop); Example vector<int> v {1,2,3,4,5,6,7,8}; vector<int> w; transform(begin(v), end(v), back_inserter(w), []( int x) {return x x}); vector<int> z; transform(begin(v), end(v), begin(w), end(w), back_inserter(z), []( int x, int y) { return x+y; }) ; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 21/58

24 Execution policies 1 Introduction to generic programming 2 STL: Standard Template Library 3 Execution policies 4 5 More? cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 22/58

25 Execution policies Introduction An execution policy specifies the type of parallelism that is allowed in the execution of the algorithm. Sequential: No parallelism. Type: sequenced_policy. Global object: seq. Parallel: Parallel execution. Typo: parallel_policy. Global object: par. Parallel + Vector: Parallelized and vectorized. Type: parallel_unseq_policy. Global object: par_unseq. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 23/58

26 Execution policies Algorithm versions All parallel algorithms take as a first argument an execution policy. Example: sorting a vector using namespace std; vector<double> v = read_values(); sort(v.begin(), v.end()); using namespace std::experimental::parallel; sort(seq, v.begin(), v.end()); // Sequential sort(par, v.begin(), v.end()); // Parallel sort(par_unseq, v.begin(), v.end()); // Parallel + Vector cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 24/58

27 1 Introduction to generic programming 2 STL: Standard Template Library 3 Execution policies 4 5 More? cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 25/58

28 What algorithms are included? Parallel algorithms library includes most algorithms in the STL. In all cases an additional argument is added to signal the execution policy. Policy argument is always the first one. Some algorithms from the STL have been excluded. Example: accumulate. Some algorithms do not come from the STL. Example: exclusive_scan cbea J. Daniel Garcia 26/58

29 Categories of algorithms Invariant: Find out something about a sequence. Modifying: Perform modifications on a sequence. Partitioning: Support the idea of partitioning a sequence. Sorting: Sorting and support algorithms on sequences. Set operations: Apply set operations on sequences. Heap: Maximal heap support. Comparison: Comparisons on sequences. Numeric: Numeric-like algorithms. Memory: Memory operations. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 27/58

30 Invariant: Finding and searching Finding: adjacent_find: Finds two first elements that are equal or satisfy a predicate. find: Finds the first element with a value. find_if: Finds the first element satisfying a predicate. find_if_not: Finds the first element not satisfying a predicate. Searching search: Searches for a subsequence within a sequence. search_n: Searches n occurrences of a subsequence within a sequence. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 28/58

31 Finding in a sequence Examples vector<int> v = get_values_vector(); count_if(par, begin(v), end(v), []( int x) { return x>0; }) ; auto p = find (par, begin(v), end(v), 0); auto q = find_if (par, begin(v), end(v), []( int x) { return (x>0) && (x<10); } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 29/58

32 Invariant: Iterating Iterating for_each: Applies a function to all elements in a sequence. for_each_n: Applies a function to the first n elements in a sequence. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 30/58

33 Iterating Counting primes long count_primes(const std::vector<int> & v) { long count; std :: for_each(std::par, v.begin(), v.end(), [&]( int n) { if (is_prime(n)) count++; }) ; return count; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 31/58

34 Iterating Counting primes long count_primes(const std::vector<int> & v) { long count; std :: for_each(std::par, v.begin(), v.end(), [&]( int n) { if (is_prime(n)) count++; }) ; return count; } Can you spot the problem? cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 31/58

35 Iterating Counting primes long count_primes(const std::vector<int> & v) { long count; std :: for_each(std::par, v.begin(), v.end(), [&]( int n) { if (is_prime(n)) count++; }) ; return count; } Can you spot the problem? Hint: A data race condition. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 31/58

36 Iterating Counting primes long count_primes(const std::vector<int> & v) { std :: atomic<long> count; std :: for_each(std::par, v.begin(), v.end(), [&]( int n) { if (is_prime(n)) count++; }) ; return count.load() ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/58

37 Iterating Counting primes long count_primes(const std::vector<int> & v) { std :: atomic<long> count; std :: for_each(std::par, v.begin(), v.end(), [&]( int n) { if (is_prime(n)) count++; }) ; return count.load() ; } Lesson 1: Avoid iterating and modifying. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/58

38 Iterating Counting primes long count_primes(const std::vector<int> & v) { std :: atomic<long> count; std :: for_each(std::par, v.begin(), v.end(), [&]( int n) { if (is_prime(n)) count++; }) ; return count.load() ; } Lesson 1: Avoid iterating and modifying. Lesson 2: If needed, add concurrency control. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 32/58

39 Invariant: Comparing, checking and counting Comparing equal: Compares two sequences element by element. mismatch: Determines the first position in which two sequences differ. Checking: all_of: Checks if a predicate is true for all elements. none_of: Checks if a predicate is false for all the elements. any_of: Checks if a predicate is true for any of the elements. Counting count: Counts the number of elements equal to a value. count_if: Counts the number of elements that satisfy a predicate. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 33/58

40 Counting Counting primes long count_primes(const std::vector<int> & v) { return std :: count_if(std :: par, v.begin(), v.end(), [&]( int n) { return is_prime(n); }) ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 34/58

41 Counting Counting primes long count_primes(const std::vector<int> & v) { return std :: count_if(std :: par, v.begin(), v.end(), [&]( int n) { return is_prime(n); }) ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 34/58

42 Modifying Copying/Moving copy: Copies a sequence of elements. copy_if: Copies elements from a sequences satisfying a predicate. copy_n: Copies the n first elements from a sequence. move: Moves a sequence of elements. swap_ranges: Swaps two sequences element by element. Replacement replace: Replaces all values from a sequence equal to a value with another one. replace_if: Replaces all values from a sequence satisfying a predicate with another value. replace_copy: Copies values from a sequence replacing elements equal to a value with another one. replace_copy_if: Copies values from a sequence replacing elements satisfying a predicate with another value. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 35/58

43 Modifying Filling fill: Fills a sequence with a value. fill_n: Fills the n first elements with a value. Value generation generate: Fills a sequence with the result of invoking a function. generate_n: Fills the n first elements with the result of invoking a function. Rearranging reverse: Inverts order of elements in a sequence. reverse_copy: Copies inverting orders of elements in a sequence. rotate: Rotates order of elements in a sequence. rotate_copy: Copies values from a sequence rotating order. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 36/58

44 Modifying Removal remove: Removes elements equal to a value. remove_if: Removes elements satisfying a predicate. remove_copy: Copies elements from a sequence except those equal to a value. remove_copy_if: Copies elements from a sequence except those satisfying a predicate. unique: Removes consecutive duplicates in a sequence. unique_copy: Copies elements from a sequence without repeating duplicates. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 37/58

45 Modifying Mapping pattern transform: Applies a function to one or two sequences to generate another sequence. using myvector = std::double<vector>; myvector addvec(const myvector & v, const myvector & w) { myvector r(v.size () ) ; std :: transform(par, v.begin(), v.end(), w.begin(), r.begin(), []( double x, double y) { return x+y; } }) ; return r ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 38/58

46 Partitioning operations is_partitioned: Determines if a sequence is partitioned with respect a predicate. partition: Divides a sequence in two using a predicate as criteria. partition_copy: Copies a sequence divided in two using a predicate as criteria. stable_partition: Divides a sequence in two using a predicate as criteria and preserving relative order. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 39/58

47 Sorting operations is_sorted: Determines if a sequence is sorted. is_sorted_until: Determines the longest sorted subsequence. nth_element: Partially sorts ensuring position of an element as pivot. partial_sort: Sorts the first n elements in a sequence. partial_sort_copy: Copies and partially sorts the first n elements from a sequence. sort: Sorts a sequence in ascending order. stable_sort: Sorts a sequence preserving order among equal elements. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 40/58

48 Set operations includes: Determines if a sequence is a subset from another. inplace_merge: Merges two consecutive subsequences that are already sorted. merge: Merges two sequences already sorted. set_difference: Computes the set difference between two sequences. set_intersection: Computes set intersection between tow sequences. set_symmetric_difference: Computes set symmetric difference between two sequences. set_union: Computes set union between two sequences. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 41/58

49 Heap operations is_heap: Determines if a sequences is a maximal heap. is_heap_until: Finds the longest subsequence that is a maximal heap. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 42/58

50 Minimum and maximum operations lexicographical_compare: Determines if a sequence is lexicographically less than another one. max_element: Determines the greater element in a sequence. min_element: Determines the lowest element in a sequence. minmax_element: Determines the greater and the lowest element in a sequence. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 43/58

51 Memory operations uninitialized_copy: Copies a sequence into an uninitialized memory area. uninitialized_copy_n: Copies a sequence of n values into an uninitialized memory area. uninitialized_fill: Copies a value repeatedly into an uninitialized memory area. uninitialized_fill_n: Copies a value repeatedly (n times) into an uninitialized memory area. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 44/58

52 Numeric-like operations Reductions reduce: Performs a reduction operation on a sequence. Map/Reduce transform_reduce: Performs a reduction operation on the transformation of a sequence. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 45/58

53 Reducing sequences Adding elements double addvalues(const std::vector<double> & v) { return std :: reduce(std::par, v.begin(), v.end(), 0.0, []( double x, double y) { return x+y; } ) ; } Notes: The operation cannot invalidate iterators. The operation cannot modify values in the sequence. Might be non-deterministic is the operation is: Non-associative. Non-commutative. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 46/58

54 Other versions of reduce If no operation is provided, std::plus<>() is used. If no initial value is provided, a default constructed value from iterator s value type is used. Adding elements double addvalues(const std::vector<double> & v) { return std :: reduce(std::par, v.begin(), v.end()); } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 47/58

55 Map-reduce Named in C++ transform_reduce to avoid conflicts. Takes two operations: An unary operation to transform each element. A binary operation to reduce results of transformations. Sum of squares double sum_squares(const std::vector<double> & v) { return std :: transform_reduce(std::par, v.begin(), v.end(), 0.0, []( double x) { return std :: pow(x,2); }, []( double x, double y) { return x+y; } ) ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 48/58

56 Binary map/reduce Takes to input sequences. The transform stage pairs elements from both sequences. Scalar product double scalar_product(const std::vector<double> & v) { return std :: transform_reduce(std::par, v.begin(), v.end(), w.begin(), 0.0, []( double x, double y) { return x y; }, []( double x, double y) { return x+y; } ) ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 49/58

57 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

58 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

59 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; freq_table count_words(const text & words) { return std :: transform_reduce(std::par, words.begin(), words.end(), cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

60 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; freq_table count_words(const text & words) { return std :: transform_reduce(std::par, words.begin(), words.end(), freq_table {}, cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

61 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; freq_table count_words(const text & words) { return std :: transform_reduce(std::par, words.begin(), words.end(), freq_table {}, []( std :: string word) > freq_table { return{word,1}; }, cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

62 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; freq_table count_words(const text & words) { return std :: transform_reduce(std::par, words.begin(), words.end(), freq_table {}, []( std :: string word) > freq_table { return{word,1}; }, []( freq_table & lhs, const freq_table & rhs) { cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

63 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; freq_table count_words(const text & words) { return std :: transform_reduce(std::par, words.begin(), words.end(), freq_table {}, []( std :: string word) > freq_table { return{word,1}; }, []( freq_table & lhs, const freq_table & rhs) { for (auto & [w,n] : rhs) { lhs[w] += n; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

64 Cannonical map/reduce example Word count using text = std :: vector<std:: string >; using freq_table = std :: map<std::string, long>; freq_table count_words(const text & words) { return std :: transform_reduce(std::par, words.begin(), words.end(), freq_table {}, []( std :: string word) > freq_table { return{word,1}; }, []( freq_table & lhs, const freq_table & rhs) { for (auto & [w,n] : rhs) { lhs[w] += n; } return lhs; } ) ; } cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 50/58

65 Numeric-like operations Scan operations Generate a sequence of cummulative reductions Scan exclusive_scan: Performs an exclusive scan operation on a sequence. inclusive_scan: Performs an inclusive scan operation on a sequence. transform_exclusive_scan: Performs an exclusive scan operation on the transformation of a sequence. transform_inclusive_scan: Performs an inclusive scan operation on the transformation of a sequence. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 51/58

66 Using scans to compute CDF CDF computation vector<int> histogram = compute\_histogram(); vector<int> cdf(histogram.size()) ; std :: inclusive_scan(std :: par, histogram.begin(), histogram.end(), cdf.begin(), 0, []( int x, int y) { return x+y; } ) ; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 52/58

67 Using scans to compute CDF CDF computation vector<int> histogram = compute\_histogram(); vector<int> cdf(histogram.size()) ; std :: inclusive_scan(std :: par, histogram.begin(), histogram.end(), cdf.begin(), 0, []( int x, int y) { return x+y; } ) ; What if I want to saturate the histogram? Negative values become 0. Values over 255 become 255. cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 52/58

68 Using scans to compute CDF Saturated CDF computation vector<int> histogram = compute\_histogram(); vector<int> cdf(histogram.size()) ; std :: inclusive_scan(std :: par, histogram.begin(), histogram.end(), cdf.begin(), 0, []( int x) { if (x<0) return 0; if (x>255) return 255; return x; }, []( int x, int y) { return x+y; } ) ; cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 53/58

69 More? 1 Introduction to generic programming 2 STL: Standard Template Library 3 Execution policies 4 5 More? cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 54/58

70 More? using std::cpp 2019 cbea J. Daniel Garcia 55/58

71 More? CFP abierto cbea J. Daniel Garcia 56/58

72 More? Curso de C++ (25,26,27 marzo) cbea J. Daniel Garcia 57/58

73 More? J. Daniel Garcia Universidad Carlos III de Madrid November 23, 2018 cbea J. Daniel Garcia 58/58