|
2 | 2 |
|
3 | 3 | <html> |
4 | 4 | <head> |
5 | | - <meta charset="utf-8" /> |
6 | | - <link rel="stylesheet" href="../../Static/css/reveal.css" /> |
7 | | - <link |
8 | | - rel="stylesheet" |
9 | | - href="../../Static/css/theme/white.css" |
10 | | - /> |
11 | | - <link rel="stylesheet" href="../../Static/css/custom.css" /> |
12 | | - <link |
13 | | - rel="stylesheet" |
14 | | - href="../../Static/css/atom-one-light.css" |
15 | | - /> |
| 5 | + <meta charset="utf-8"/> |
| 6 | + <link rel="stylesheet" href="../../Static/css/reveal.css"/> |
| 7 | + <link rel="stylesheet" href="../../Static/css/theme/white.css"/> |
| 8 | + <link rel="stylesheet" href="../../Static/css/custom.css"/> |
| 9 | + <link rel="stylesheet" href="../../Static/css/atom-one-light.css"/> |
16 | 10 | <script src="../../node_modules/reveal.js/dist/reveal.js" defer></script> |
17 | 11 | <script src="../../node_modules/reveal.js/dist/plugin/markdown.js" defer></script> |
18 | 12 | <script src="../../node_modules/reveal.js/dist/plugin/highlight.js" defer></script> |
|
53 | 47 | <div class="hbox" data-markdown> |
54 | 48 | #### USM Allocation Types |
55 | 49 | </div> |
56 | | - <div class="container"data-markdown> |
| 50 | + <div class="container" data-markdown> |
57 | 51 | | Type | Description | Access host | Access device | Nominal location | |
58 | 52 | |--------|---------------------------------|----------------|----------------|----------------------| |
59 | 53 | | device | device global allocations | ✗ | ✓ | device | |
|
67 | 61 | #### Malloc_device |
68 | 62 | </div> |
69 | 63 | <div class="container"> |
70 | | - <code class="code-100pc"><pre> |
71 | | -void* malloc_device(size_t numBytes, const queue& syclQueue, const property_list &propList = {}); |
| 64 | + <pre><code class="language-cpp"> |
| 65 | +void* malloc_device(size_t numBytes, const queue& syclQueue, const property_list &propList = {}); |
72 | 66 |
|
73 | 67 | template <typename T> |
74 | | -T* malloc_device(size_t count, const queue& syclQueue, const property_list &propList = {}); |
| 68 | +T* malloc_device(size_t count, const queue& syclQueue, const property_list &propList = {}); |
75 | 69 | </code></pre> |
76 | 70 | </div> |
77 | 71 | <div class="container" data-markdown> |
|
88 | 82 | #### Free |
89 | 83 | </div> |
90 | 84 | <div class="container"> |
91 | | - <code class="code-100pc"><pre> |
92 | | -void free(void* ptr, queue& syclQueue); |
| 85 | + <pre><code class="language-cpp"> |
| 86 | +void free(void* ptr, queue& syclQueue); |
93 | 87 | </code></pre> |
94 | 88 | </div> |
95 | 89 | <div class="container" data-markdown> |
|
105 | 99 | #### Memcpy |
106 | 100 | </div> |
107 | 101 | <div class="container"> |
108 | | - <code class="code-100pc"><pre> |
109 | | -event queue::memcpy(void* dest, const void* src, size_t numBytes, const std::vector<event> &depEvents); |
| 102 | + <pre><code class="language-cpp"> |
| 103 | +event queue::memcpy(void* dest, const void* src, size_t numBytes, const std::vector<event> &depEvents); |
110 | 104 | </code></pre> |
111 | 105 | </div> |
112 | 106 | <div class="container" data-markdown> |
|
120 | 114 | <!--Slide 7--> |
121 | 115 | <section> |
122 | 116 | <div class="hbox" data-markdown> |
123 | | - #### Memset & fill |
| 117 | + #### Memset & fill |
124 | 118 | </div> |
125 | 119 | <div class="container"> |
126 | | - <code class="code-100pc"><pre> |
127 | | -event queue::memset(void* ptr, int value, size_t numBytes, const std::vector<event> &depEvents); |
| 120 | + <pre><code class="language-cpp"> |
| 121 | +event queue::memset(void* ptr, int value, size_t numBytes, const std::vector<event> &depEvents); |
128 | 122 |
|
129 | | -event queue::fill(void* ptr, const T& pattern, size_t count, const std::vector<event> &depEvents); |
| 123 | +event queue::fill(void* ptr, const T& pattern, size_t count, const std::vector<event> &depEvents); |
130 | 124 | </code></pre> |
131 | 125 | </div> |
132 | 126 | <div class="container" data-markdown> |
|
142 | 136 | #### Putting it all together |
143 | 137 | </div> |
144 | 138 | <div class="container"> |
145 | | - <code class="code-100pc"><pre> |
| 139 | + <pre><code class="language-cpp"> |
146 | 140 | int square_number(int x){ |
147 | 141 |
|
148 | 142 | auto myQueue = queue{}; |
149 | 143 |
|
150 | | - myQueue.submit([&](handler &cgh){ |
| 144 | + myQueue.submit([&](handler &cgh){ |
151 | 145 | cgh.single_task<square_number>([=](){ |
152 | 146 | /* square some number */ |
153 | 147 | }); |
|
167 | 161 | #### Putting it all together |
168 | 162 | </div> |
169 | 163 | <div class="container"> |
170 | | - <code class="code-100pc" data-noescape><pre> |
| 164 | + <pre><code data-noescape class="language-cpp"> |
171 | 165 | int square_number(int x){ |
172 | 166 |
|
173 | 167 | auto myQueue = queue{<mark>usm_selector{}</mark>}; |
174 | 168 |
|
175 | | - myQueue.submit([&](handler &cgh){ |
| 169 | + myQueue.submit([&](handler &cgh){ |
176 | 170 | cgh.single_task<square_number>([=](){ |
177 | 171 | /* square some number */ |
178 | 172 | }); |
|
192 | 186 | #### Putting it all together |
193 | 187 | </div> |
194 | 188 | <div class="container"> |
195 | | - <code class="code-100pc" data-noescape><pre> |
| 189 | + <pre><code data-noescape class="language-cpp"> |
196 | 190 | int square_number(int x){ |
197 | 191 |
|
198 | 192 | auto myQueue = queue{usm_selector{}}; |
199 | 193 |
|
200 | 194 | <mark>auto devicePtr = malloc_device<int>(1, myQueue);</mark> |
201 | 195 |
|
202 | | - myQueue.submit([&](handler &cgh){ |
| 196 | + myQueue.submit([&](handler &cgh){ |
203 | 197 | cgh.single_task<square_number>([=](){ |
204 | 198 | /* square some number */ |
205 | 199 | }); |
|
220 | 214 | #### Putting it all together |
221 | 215 | </div> |
222 | 216 | <div class="container"> |
223 | | - <code class="code-100pc" data-noescape><pre> |
| 217 | + <pre><code data-noescape class="language-cpp"> |
224 | 218 | int square_number(int x){ |
225 | 219 |
|
226 | 220 | auto myQueue = queue{usm_selector{}}; |
227 | 221 |
|
228 | 222 | auto devicePtr = malloc_device<int>(1, myQueue); |
229 | 223 |
|
230 | | - <mark>myQueue.memcpy(devicePtr, &x, sizeof(int)).wait();</mark> |
| 224 | + <mark>myQueue.memcpy(devicePtr, &x, sizeof(int)).wait();</mark> |
231 | 225 |
|
232 | | - myQueue.submit([&](handler &cgh){ |
| 226 | + myQueue.submit([&](handler &cgh){ |
233 | 227 | cgh.single_task<square>([=](){ |
234 | 228 | /* square some number */ |
235 | 229 | }); |
|
250 | 244 | #### Putting it all together |
251 | 245 | </div> |
252 | 246 | <div class="container"> |
253 | | - <code class="code-100pc" data-noescape><pre> |
| 247 | + <pre><code data-noescape class="language-cpp"> |
254 | 248 | int square_number(int x){ |
255 | 249 |
|
256 | 250 | auto myQueue = queue{usm_selector{}}; |
257 | 251 |
|
258 | 252 | auto devicePtr = malloc_device<int>(1, myQueue); |
259 | 253 |
|
260 | | - myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
| 254 | + myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
261 | 255 |
|
262 | | - myQueue.submit([&](handler &cgh){ |
| 256 | + myQueue.submit([&](handler &cgh){ |
263 | 257 | cgh.single_task<square>([=](){ |
264 | 258 | <mark>*devicePtr = (*devicePtr) * (*devicePtr);</mark> |
265 | 259 | }); |
|
279 | 273 | #### Putting it all together |
280 | 274 | </div> |
281 | 275 | <div class="container"> |
282 | | - <code class="code-100pc" data-noescape><pre> |
| 276 | + <pre><code data-noescape class="language-cpp"> |
283 | 277 | int square_number(int x){ |
284 | 278 |
|
285 | 279 | auto myQueue = queue{usm_selector{}}; |
286 | 280 |
|
287 | 281 | auto devicePtr = malloc_device<int>(1, myQueue); |
288 | 282 |
|
289 | | - myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
| 283 | + myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
290 | 284 |
|
291 | | - myQueue.submit([&](handler &cgh){ |
| 285 | + myQueue.submit([&](handler &cgh){ |
292 | 286 | cgh.single_task<square>([=](){ |
293 | 287 | *devicePtr = (*devicePtr) * (*devicePtr); |
294 | 288 | }); |
295 | 289 | }).wait(); |
296 | 290 |
|
297 | | - <mark>myQueue.memcpy(&x, devicePtr, sizeof(int)).wait();</mark> |
| 291 | + <mark>myQueue.memcpy(&x, devicePtr, sizeof(int)).wait();</mark> |
298 | 292 |
|
299 | 293 | return x; |
300 | 294 | } |
|
310 | 304 | #### Putting it all together |
311 | 305 | </div> |
312 | 306 | <div class="container"> |
313 | | - <code class="code-100pc" data-noescape><pre> |
| 307 | + <pre><code data-noescape class="language-cpp"> |
314 | 308 | int square_number(int x){ |
315 | 309 |
|
316 | 310 | auto myQueue = queue{usm_selector{}}; |
317 | 311 |
|
318 | 312 | auto devicePtr = malloc_device<int>(1, myQueue); |
319 | 313 |
|
320 | | - myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
| 314 | + myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
321 | 315 |
|
322 | | - myQueue.submit([&](handler &cgh){ |
| 316 | + myQueue.submit([&](handler &cgh){ |
323 | 317 | cgh.single_task<square>([=](){ |
324 | 318 | *devicePtr = (*devicePtr) * (*devicePtr); |
325 | 319 | }); |
326 | 320 | }).wait(); |
327 | 321 |
|
328 | | - myQueue.memcpy(&x, devicePtr, sizeof(int)).wait(); |
| 322 | + myQueue.memcpy(&x, devicePtr, sizeof(int)).wait(); |
329 | 323 |
|
330 | 324 | <mark>free(devicePtr, myQueue);</mark> |
331 | 325 |
|
|
343 | 337 | #### Queue shortcuts |
344 | 338 | </div> |
345 | 339 | <div class="container"> |
346 | | - <code class="code-100pc"><pre> |
| 340 | + <pre><code class="language-cpp"> |
347 | 341 | template <typename KernelName, typename KernelType> |
348 | | -event queue::single_task(const KernelType &KernelFunc); |
| 342 | +event queue::single_task(const KernelType &KernelFunc); |
349 | 343 |
|
350 | 344 | template <typename KernelName, typename KernelType, int Dims> |
351 | | -event queue::parallel_for(range<Dims> GlobalRange, const KernelType &KernelFunc); |
| 345 | +event queue::parallel_for(range<Dims> GlobalRange, const KernelType &KernelFunc); |
352 | 346 | </code></pre> |
353 | 347 | </div> |
354 | 348 | <div class="container" data-markdown> |
|
362 | 356 | #### With the queue shortcut |
363 | 357 | </div> |
364 | 358 | <div class="container"> |
365 | | - <code class="code-100pc" data-noescape><pre> |
| 359 | + <pre><code data-noescape class="language-cpp"> |
366 | 360 | int square_number(int x){ |
367 | 361 |
|
368 | 362 | auto myQueue = queue{usm_selector{}}; |
369 | 363 |
|
370 | 364 | auto devicePtr = malloc_device<int>(1, myQueue); |
371 | 365 |
|
372 | | - myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
| 366 | + myQueue.memcpy(devicePtr, &x, sizeof(int)).wait(); |
373 | 367 |
|
374 | 368 | <mark>myQueue.single_task<square>([=](){</mark> |
375 | 369 | <mark>*devicePtr = (*devicePtr) * (*devicePtr);</mark> |
376 | 370 | <mark>}).wait();</mark> |
377 | 371 |
|
378 | | - myQueue.memcpy(&x, devicePtr, sizeof(int)).wait(); |
| 372 | + myQueue.memcpy(&x, devicePtr, sizeof(int)).wait(); |
379 | 373 |
|
380 | 374 | free(devicePtr, myQueue); |
381 | 375 |
|
|
0 commit comments