| 1 |
/* Basic container usage. */ |
| 2 |
|
| 3 |
#include <vector> |
| 4 |
#include <deque> |
| 5 |
#include <list> |
| 6 |
#include <set> |
| 7 |
#include <map> |
| 8 |
#if __cplusplus >= 201103L |
| 9 |
#include <array> |
| 10 |
#include <forward_list> |
| 11 |
#include <unordered_set> |
| 12 |
#include <unordered_map> |
| 13 |
#endif |
| 14 |
|
| 15 |
bool vector_test() |
| 16 |
{ |
| 17 |
bool ok; |
| 18 |
#pragma omp target map(from: ok) |
| 19 |
{ |
| 20 |
std::vector<int> vector; |
| 21 |
ok = vector.empty(); |
| 22 |
} |
| 23 |
return ok; |
| 24 |
} |
| 25 |
|
| 26 |
bool deque_test() |
| 27 |
{ |
| 28 |
bool ok; |
| 29 |
#pragma omp target map(from: ok) |
| 30 |
{ |
| 31 |
std::deque<int> deque; |
| 32 |
ok = deque.empty(); |
| 33 |
} |
| 34 |
return ok; |
| 35 |
} |
| 36 |
|
| 37 |
bool list_test() |
| 38 |
{ |
| 39 |
bool ok; |
| 40 |
#pragma omp target map(from: ok) |
| 41 |
{ |
| 42 |
std::list<int> list; |
| 43 |
ok = list.empty(); |
| 44 |
} |
| 45 |
return ok; |
| 46 |
} |
| 47 |
|
| 48 |
bool map_test() |
| 49 |
{ |
| 50 |
bool ok; |
| 51 |
#pragma omp target map(from: ok) |
| 52 |
{ |
| 53 |
std::map<int, int> map; |
| 54 |
ok = map.empty(); |
| 55 |
} |
| 56 |
return ok; |
| 57 |
} |
| 58 |
|
| 59 |
bool set_test() |
| 60 |
{ |
| 61 |
bool ok; |
| 62 |
#pragma omp target map(from: ok) |
| 63 |
{ |
| 64 |
std::set<int> set; |
| 65 |
ok = set.empty(); |
| 66 |
} |
| 67 |
return ok; |
| 68 |
} |
| 69 |
|
| 70 |
bool multimap_test() |
| 71 |
{ |
| 72 |
bool ok; |
| 73 |
#pragma omp target map(from: ok) |
| 74 |
{ |
| 75 |
std::multimap<int, int> multimap; |
| 76 |
ok = multimap.empty(); |
| 77 |
} |
| 78 |
return ok; |
| 79 |
} |
| 80 |
|
| 81 |
bool multiset_test() |
| 82 |
{ |
| 83 |
bool ok; |
| 84 |
#pragma omp target map(from: ok) |
| 85 |
{ |
| 86 |
std::multiset<int, int> multiset; |
| 87 |
ok = multiset.empty(); |
| 88 |
} |
| 89 |
return ok; |
| 90 |
} |
| 91 |
|
| 92 |
#if __cplusplus >= 201103L |
| 93 |
|
| 94 |
bool array_test() |
| 95 |
{ |
| 96 |
static constexpr std::size_t array_size = 42; |
| 97 |
bool ok; |
| 98 |
#pragma omp target map(from: ok) |
| 99 |
{ |
| 100 |
std::array<int, array_size> array{}; |
| 101 |
ok = array[0] == 0 |
| 102 |
&& array[array_size - 1] == 0; |
| 103 |
} |
| 104 |
return ok; |
| 105 |
} |
| 106 |
|
| 107 |
bool forward_list_test() |
| 108 |
{ |
| 109 |
bool ok; |
| 110 |
#pragma omp target map(from: ok) |
| 111 |
{ |
| 112 |
std::forward_list<int> forward_list; |
| 113 |
ok = forward_list.empty(); |
| 114 |
} |
| 115 |
return ok; |
| 116 |
} |
| 117 |
|
| 118 |
bool unordered_map_test() |
| 119 |
{ |
| 120 |
bool ok; |
| 121 |
#pragma omp target map(from: ok) |
| 122 |
{ |
| 123 |
std::unordered_map<int, int> unordered_map; |
| 124 |
ok = unordered_map.empty(); |
| 125 |
} |
| 126 |
return ok; |
| 127 |
} |
| 128 |
|
| 129 |
bool unordered_set_test() |
| 130 |
{ |
| 131 |
bool ok; |
| 132 |
#pragma omp target map(from: ok) |
| 133 |
{ |
| 134 |
std::unordered_set<int> unordered_set; |
| 135 |
ok = unordered_set.empty(); |
| 136 |
} |
| 137 |
return ok; |
| 138 |
} |
| 139 |
|
| 140 |
bool unordered_multimap_test() |
| 141 |
{ |
| 142 |
|
| 143 |
bool ok; |
| 144 |
#pragma omp target map(from: ok) |
| 145 |
{ |
| 146 |
std::unordered_multimap<int, int> unordered_multimap; |
| 147 |
ok = unordered_multimap.empty(); |
| 148 |
} |
| 149 |
return ok; |
| 150 |
} |
| 151 |
|
| 152 |
bool unordered_multiset_test() |
| 153 |
{ |
| 154 |
|
| 155 |
bool ok; |
| 156 |
#pragma omp target map(from: ok) |
| 157 |
{ |
| 158 |
std::unordered_multiset<int> unordered_multiset; |
| 159 |
ok = unordered_multiset.empty(); |
| 160 |
} |
| 161 |
return ok; |
| 162 |
} |
| 163 |
|
| 164 |
#else |
| 165 |
bool array_test() { return true; } |
| 166 |
bool forward_list_test() { return true; } |
| 167 |
bool unordered_map_test() { return true; } |
| 168 |
bool unordered_set_test() { return true; } |
| 169 |
bool unordered_multimap_test() { return true; } |
| 170 |
bool unordered_multiset_test() { return true; } |
| 171 |
#endif |
| 172 |
|
| 173 |
int main() |
| 174 |
{ |
| 175 |
const bool vec_res = vector_test(); |
| 176 |
__builtin_printf("vector : %s\n", vec_res ? "PASS" : "FAIL"); |
| 177 |
const bool deque_res = deque_test(); |
| 178 |
__builtin_printf("deque : %s\n", deque_res ? "PASS" : "FAIL"); |
| 179 |
const bool list_res = list_test(); |
| 180 |
__builtin_printf("list : %s\n", list_res ? "PASS" : "FAIL"); |
| 181 |
const bool map_res = map_test(); |
| 182 |
__builtin_printf("map : %s\n", map_res ? "PASS" : "FAIL"); |
| 183 |
const bool set_res = set_test(); |
| 184 |
__builtin_printf("set : %s\n", set_res ? "PASS" : "FAIL"); |
| 185 |
const bool multimap_res = multimap_test(); |
| 186 |
__builtin_printf("multimap : %s\n", multimap_res ? "PASS" : "FAIL"); |
| 187 |
const bool multiset_res = multiset_test(); |
| 188 |
__builtin_printf("multiset : %s\n", multiset_res ? "PASS" : "FAIL"); |
| 189 |
const bool array_res = array_test(); |
| 190 |
__builtin_printf("array : %s\n", array_res ? "PASS" : "FAIL"); |
| 191 |
const bool forward_list_res = forward_list_test(); |
| 192 |
__builtin_printf("forward_list : %s\n", forward_list_res ? "PASS" : "FAIL"); |
| 193 |
const bool unordered_map_res = unordered_map_test(); |
| 194 |
__builtin_printf("unordered_map : %s\n", unordered_map_res ? "PASS" : "FAIL"); |
| 195 |
const bool unordered_set_res = unordered_set_test(); |
| 196 |
__builtin_printf("unordered_set : %s\n", unordered_set_res ? "PASS" : "FAIL"); |
| 197 |
const bool unordered_multimap_res = unordered_multimap_test(); |
| 198 |
__builtin_printf("unordered_multimap: %s\n", unordered_multimap_res ? "PASS" : "FAIL"); |
| 199 |
const bool unordered_multiset_res = unordered_multiset_test(); |
| 200 |
__builtin_printf("unordered_multiset: %s\n", unordered_multiset_res ? "PASS" : "FAIL"); |
| 201 |
const bool ok = vec_res |
| 202 |
&& deque_res |
| 203 |
&& list_res |
| 204 |
&& map_res |
| 205 |
&& set_res |
| 206 |
&& multimap_res |
| 207 |
&& multiset_res |
| 208 |
&& array_res |
| 209 |
&& forward_list_res |
| 210 |
&& unordered_map_res |
| 211 |
&& unordered_set_res |
| 212 |
&& unordered_multimap_res |
| 213 |
&& unordered_multiset_res; |
| 214 |
return ok ? 0 : 1; |
| 215 |
} |