Blender V5.3
kernel/device/oneapi/kernel.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021-2022 Intel Corporation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#ifdef WITH_ONEAPI
6
7# include "kernel.h"
8# include <iostream>
9# include <map>
10# include <set>
11
12/* <algorithm> is needed until included upstream in sycl/detail/property_list_base.hpp */
13# include <algorithm>
14# include <sycl/sycl.hpp>
15
19
21
22# include "device/kernel.cpp"
23
24static OneAPIErrorCallback s_error_cb = nullptr;
25static void *s_error_user_ptr = nullptr;
26
27# ifdef WITH_EMBREE_GPU
28static RTCFeatureFlags oneapi_embree_features_from_kernel_features(const uint64_t kernel_features)
29{
30 unsigned int feature_flags = RTC_FEATURE_FLAG_TRIANGLE | RTC_FEATURE_FLAG_INSTANCE |
31 RTC_FEATURE_FLAG_FILTER_FUNCTION_IN_ARGUMENTS;
32
33 if (kernel_features & KERNEL_FEATURE_HAIR_THICK) {
34 feature_flags |= RTC_FEATURE_FLAG_ROUND_CATMULL_ROM_CURVE |
35 RTC_FEATURE_FLAG_ROUND_LINEAR_CURVE;
36 }
37 if (kernel_features & KERNEL_FEATURE_HAIR) {
38 feature_flags |= RTC_FEATURE_FLAG_FLAT_CATMULL_ROM_CURVE;
39 }
40 if (kernel_features & KERNEL_FEATURE_POINTCLOUD) {
41 feature_flags |= RTC_FEATURE_FLAG_POINT;
42 }
43 if (kernel_features & KERNEL_FEATURE_OBJECT_MOTION) {
44 feature_flags |= RTC_FEATURE_FLAG_MOTION_BLUR;
45 }
46 if (kernel_features & KERNEL_FEATURE_GSPLATS) {
47 feature_flags |= RTC_FEATURE_FLAG_USER_GEOMETRY_CALLBACK_IN_ARGUMENTS;
48 }
49
50 return (RTCFeatureFlags)feature_flags;
51}
52# endif
53
54void oneapi_set_error_cb(OneAPIErrorCallback cb, void *user_ptr)
55{
56 s_error_cb = cb;
57 s_error_user_ptr = user_ptr;
58}
59
60size_t oneapi_suggested_gpu_kernel_size(const DeviceKernel kernel)
61{
62 /* This defines are available only to the device code, so making this function
63 * seems to be the most reasonable way to provide access to them for the host code. */
64 switch (kernel) {
73
78
82
85
86 default:
87 return (size_t)0;
88 }
89}
90
91/* NOTE(@nsirgien): Execution of this simple kernel will check basic functionality like
92 * memory allocations, memory transfers and execution of kernel with USM memory. */
93bool oneapi_run_test_kernel(SyclQueue *queue_)
94{
95 assert(queue_);
96 sycl::queue *queue = reinterpret_cast<sycl::queue *>(queue_);
97 const size_t N = 8;
98 const size_t memory_byte_size = sizeof(int) * N;
99
100 bool is_computation_correct = true;
101 try {
102 int *A_host = (int *)sycl::aligned_alloc_host(16, memory_byte_size, *queue);
103
104 for (size_t i = (size_t)0; i < N; i++) {
105 A_host[i] = rand() % 32;
106 }
107
108 int *A_device = (int *)sycl::malloc_device(memory_byte_size, *queue);
109 int *B_device = (int *)sycl::malloc_device(memory_byte_size, *queue);
110
111 queue->memcpy(A_device, A_host, memory_byte_size);
112 queue->wait_and_throw();
113
114 queue->submit([&](sycl::handler &cgh) {
115 cgh.parallel_for(N, [=](sycl::id<1> idx) { B_device[idx] = A_device[idx] + idx.get(0); });
116 });
117 queue->wait_and_throw();
118
119 int *B_host = (int *)sycl::aligned_alloc_host(16, memory_byte_size, *queue);
120
121 queue->memcpy(B_host, B_device, memory_byte_size);
122 queue->wait_and_throw();
123
124 for (size_t i = (size_t)0; i < N; i++) {
125 const int expected_result = i + A_host[i];
126 if (B_host[i] != expected_result) {
127 is_computation_correct = false;
128 if (s_error_cb) {
129 s_error_cb(("Incorrect result in test kernel execution - expected " +
130 std::to_string(expected_result) + ", got " + std::to_string(B_host[i]))
131 .c_str(),
132 s_error_user_ptr);
133 }
134 }
135 }
136
137 sycl::free(A_host, *queue);
138 sycl::free(B_host, *queue);
139 sycl::free(A_device, *queue);
140 sycl::free(B_device, *queue);
141 queue->wait_and_throw();
142 }
143 catch (const sycl::exception &e) {
144 if (s_error_cb) {
145 s_error_cb(e.what(), s_error_user_ptr);
146 }
147 return false;
148 }
149
150 return is_computation_correct;
151}
152
153bool oneapi_zero_memory_on_device(SyclQueue *queue_, void *device_pointer, const size_t num_bytes)
154{
155 assert(queue_);
156 sycl::queue *queue = reinterpret_cast<sycl::queue *>(queue_);
157 try {
158 queue->memset(device_pointer, 0, num_bytes);
159 queue->wait_and_throw();
160 return true;
161 }
162 catch (const sycl::exception &e) {
163 if (s_error_cb) {
164 s_error_cb(e.what(), s_error_user_ptr);
165 }
166 return false;
167 }
168}
169
170bool oneapi_kernel_is_required_for_features(const std::string &kernel_name,
171 const uint64_t kernel_features)
172{
173 /* Skip all non-Cycles kernels */
174 if (kernel_name.find("oneapi_kernel_") == std::string::npos) {
175 return false;
176 }
177
178 if ((kernel_features & KERNEL_FEATURE_NODE_RAYTRACE) == 0 &&
180 std::string::npos)
181 {
182 return false;
183 }
184
185 if ((kernel_features & KERNEL_FEATURE_MNEE) == 0 &&
187 std::string::npos)
188 {
189 return false;
190 }
191
192 if ((kernel_features & KERNEL_FEATURE_VOLUME) == 0 &&
194 std::string::npos)
195 {
196 return false;
197 }
198
199 if (((kernel_features & (KERNEL_FEATURE_PATH_TRACING | KERNEL_FEATURE_BAKING)) == 0) &&
201 std::string::npos) ||
203 std::string::npos) ||
205 std::string::npos) ||
207 std::string::npos) ||
208 (kernel_name.find(device_kernel_as_string(
210 {
211 return false;
212 }
213
214 return true;
215}
216
217bool oneapi_kernel_is_compatible_with_hardware_raytracing(const std::string &kernel_name)
218{
219 /* MNEE and Ray-trace kernels work correctly with Hardware Ray-tracing starting with Embree 4.1.
220 */
221# if defined(RTC_VERSION) && RTC_VERSION < 40100
223 std::string::npos) &&
224 (kernel_name.find(device_kernel_as_string(
226# else
227 return true;
228# endif
229}
230
231bool oneapi_kernel_has_intersections(const std::string &kernel_name)
232{
233 for (int i = 0; i < (int)DEVICE_KERNEL_NUM; i++) {
234 DeviceKernel kernel = (DeviceKernel)i;
235 if (device_kernel_has_intersection(kernel)) {
236 if (kernel_name.find(device_kernel_as_string(kernel)) != std::string::npos) {
237 return true;
238 }
239 }
240 }
241 return false;
242}
243
244bool oneapi_load_kernels(SyclQueue *queue_,
245 const uint64_t kernel_features,
246 bool use_hardware_raytracing)
247{
248 assert(queue_);
249 sycl::queue *queue = reinterpret_cast<sycl::queue *>(queue_);
250
251# ifdef WITH_EMBREE_GPU
252 /* For best performance, we always JIT compile the kernels that are using Embree. */
253 if (use_hardware_raytracing) {
254 try {
255 sycl::kernel_bundle<sycl::bundle_state::input> all_kernels_bundle =
256 sycl::get_kernel_bundle<sycl::bundle_state::input>(queue->get_context(),
257 {queue->get_device()});
258
259 for (const sycl::kernel_id &kernel_id : all_kernels_bundle.get_kernel_ids()) {
260 const std::string &kernel_name = kernel_id.get_name();
261
262 if (!oneapi_kernel_is_required_for_features(kernel_name, kernel_features) ||
263 !(oneapi_kernel_has_intersections(kernel_name) &&
264 oneapi_kernel_is_compatible_with_hardware_raytracing(kernel_name)))
265 {
266 continue;
267 }
268
269 sycl::kernel_bundle<sycl::bundle_state::input> one_kernel_bundle_input =
270 sycl::get_kernel_bundle<sycl::bundle_state::input>(
271 queue->get_context(), {queue->get_device()}, {kernel_id});
272
273 const RTCFeatureFlags embree_features = oneapi_embree_features_from_kernel_features(
274 kernel_features);
275 one_kernel_bundle_input
276 .set_specialization_constant<ONEAPIKernelContext::oneapi_embree_features>(
277 embree_features);
278 sycl::build(one_kernel_bundle_input);
279 }
280 }
281 catch (const sycl::exception &e) {
282 if (s_error_cb) {
283 s_error_cb(e.what(), s_error_user_ptr);
284 }
285 return false;
286 }
287 }
288# endif
289
290 try {
291 sycl::kernel_bundle<sycl::bundle_state::input> all_kernels_bundle =
292 sycl::get_kernel_bundle<sycl::bundle_state::input>(queue->get_context(),
293 {queue->get_device()});
294
295 for (const sycl::kernel_id &kernel_id : all_kernels_bundle.get_kernel_ids()) {
296 const std::string &kernel_name = kernel_id.get_name();
297
298 /* In case HWRT is on, compilation of kernels using Embree is already handled in previous
299 * block. */
300 if (!oneapi_kernel_is_required_for_features(kernel_name, kernel_features) ||
301 (use_hardware_raytracing && oneapi_kernel_has_intersections(kernel_name) &&
302 oneapi_kernel_is_compatible_with_hardware_raytracing(kernel_name)))
303 {
304 continue;
305 }
306
307# ifdef WITH_EMBREE_GPU
308 if (oneapi_kernel_has_intersections(kernel_name)) {
309 sycl::kernel_bundle<sycl::bundle_state::input> one_kernel_bundle_input =
310 sycl::get_kernel_bundle<sycl::bundle_state::input>(
311 queue->get_context(), {queue->get_device()}, {kernel_id});
312 one_kernel_bundle_input
313 .set_specialization_constant<ONEAPIKernelContext::oneapi_embree_features>(
314 RTC_FEATURE_FLAG_NONE);
315 sycl::build(one_kernel_bundle_input);
316 continue;
317 }
318# endif
319 /* This call will ensure that AoT or cached JIT binaries are available
320 * for execution. It will trigger compilation if it is not already the case. */
321 (void)sycl::get_kernel_bundle<sycl::bundle_state::executable>(
322 queue->get_context(), {queue->get_device()}, {kernel_id});
323 }
324 }
325 catch (const sycl::exception &e) {
326 if (s_error_cb) {
327 s_error_cb(e.what(), s_error_user_ptr);
328 }
329 return false;
330 }
331 return true;
332}
333
334bool oneapi_enqueue_kernel(KernelContext *kernel_context,
335 const int kernel,
336 const size_t global_size,
337 const size_t local_size,
338 const uint64_t kernel_features,
339 bool use_hardware_raytracing,
340 void **args)
341{
342 bool success = true;
343 ::DeviceKernel device_kernel = (::DeviceKernel)kernel;
344 KernelGlobalsGPU *kg = (KernelGlobalsGPU *)kernel_context->kernel_globals;
345 sycl::queue *queue = reinterpret_cast<sycl::queue *>(kernel_context->queue);
346 assert(queue);
347 if (!queue) {
348 return false;
349 }
350
351 /* Let the compiler throw an error if there are any kernels missing in this implementation. */
352# if defined(_WIN32)
353# pragma warning(error : 4062)
354# elif defined(__GNUC__)
355# pragma GCC diagnostic push
356# pragma GCC diagnostic error "-Wswitch"
357# endif
358
359 int max_shaders = 0;
360
361 if (device_kernel == DEVICE_KERNEL_INTEGRATOR_SORT_BUCKET_PASS ||
363 {
364 max_shaders = (kernel_context->scene_max_shaders);
365 }
366
367 try {
368 queue->submit([&](sycl::handler &cgh) {
369# ifdef WITH_EMBREE_GPU
370 /* Spec says it has no effect if the called kernel doesn't support the below specialization
371 * constant but it can still trigger a recompilation, so we set it only if needed. */
372 if (device_kernel_has_intersection(device_kernel)) {
373 const RTCFeatureFlags embree_features = use_hardware_raytracing ?
374 oneapi_embree_features_from_kernel_features(
375 kernel_features) :
376 RTC_FEATURE_FLAG_NONE;
377 cgh.set_specialization_constant<ONEAPIKernelContext::oneapi_embree_features>(
378 embree_features);
379 }
380# else
381 (void)kernel_features;
382# endif
383 switch (device_kernel) {
385 oneapi_call(kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_reset);
386 break;
387 }
389 oneapi_call(
390 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_init_from_camera);
391 break;
392 }
394 oneapi_call(
395 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_init_from_bake);
396 break;
397 }
399 oneapi_call(
400 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_intersect_closest);
401 break;
402 }
404 oneapi_call(
405 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_intersect_shadow);
406 break;
407 }
409 oneapi_call(kg,
410 cgh,
411 global_size,
413 args,
414 oneapi_kernel_integrator_intersect_subsurface);
415 break;
416 }
418 oneapi_call(kg,
419 cgh,
420 global_size,
422 args,
423 oneapi_kernel_integrator_intersect_volume_stack);
424 break;
425 }
427 oneapi_call(kg,
428 cgh,
429 global_size,
431 args,
432 oneapi_kernel_integrator_intersect_dedicated_light);
433 break;
434 }
436 oneapi_call(
437 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_intersect_mnee);
438 break;
439 }
441 oneapi_call(
442 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_shade_background);
443 break;
444 }
446 oneapi_call(
447 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_shade_light_nee);
448 break;
449 }
451 oneapi_call(kg,
452 cgh,
453 global_size,
455 args,
456 oneapi_kernel_integrator_shade_light_forward);
457 break;
458 }
460 oneapi_call(
461 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_shade_shadow);
462 break;
463 }
465 oneapi_call(
466 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_shade_surface);
467 break;
468 }
470 oneapi_call(kg,
471 cgh,
472 global_size,
474 args,
475 oneapi_kernel_integrator_shade_surface_raytrace);
476 break;
477 }
479 oneapi_call(
480 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_shade_volume);
481 break;
482 }
484 oneapi_call(kg,
485 cgh,
486 global_size,
488 args,
489 oneapi_kernel_integrator_shade_volume_ray_marching);
490 break;
491 }
493 oneapi_call(kg,
494 cgh,
495 global_size,
497 args,
498 oneapi_kernel_integrator_shade_dedicated_light);
499 break;
500 }
502 oneapi_call(
503 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_queued_paths_array);
504 break;
505 }
507 oneapi_call(kg,
508 cgh,
509 global_size,
511 args,
512 oneapi_kernel_integrator_queued_shadow_paths_array);
513 break;
514 }
516 oneapi_call(
517 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_active_paths_array);
518 break;
519 }
521 oneapi_call(kg,
522 cgh,
523 global_size,
525 args,
526 oneapi_kernel_integrator_terminated_paths_array);
527 break;
528 }
530 oneapi_call(kg,
531 cgh,
532 global_size,
534 args,
535 oneapi_kernel_integrator_terminated_shadow_paths_array);
536 break;
537 }
539 oneapi_call(
540 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_sorted_paths_array);
541 break;
542 }
544 sycl::local_accessor<int> local_mem(max_shaders, cgh);
545 oneapi_kernel_integrator_sort_bucket_pass(kg,
546 global_size,
548 cgh,
549 *(int *)(args[0]),
550 *(int *)(args[1]),
551 *(int *)(args[2]),
552 *(int **)(args[3]),
553 *(int *)(args[4]),
554 local_mem);
555 break;
556 }
558 sycl::local_accessor<int> local_mem(max_shaders, cgh);
559 oneapi_kernel_integrator_sort_write_pass(kg,
560 global_size,
562 cgh,
563 *(int *)(args[0]),
564 *(int *)(args[1]),
565 *(int *)(args[2]),
566 *(int **)(args[3]),
567 *(int *)(args[4]),
568 local_mem);
569 break;
570 }
572 oneapi_call(kg,
573 cgh,
574 global_size,
576 args,
577 oneapi_kernel_integrator_compact_paths_array);
578 break;
579 }
581 oneapi_call(kg,
582 cgh,
583 global_size,
585 args,
586 oneapi_kernel_integrator_compact_shadow_paths_array);
587 break;
588 }
590 oneapi_call(kg,
591 cgh,
592 global_size,
594 args,
595 oneapi_kernel_adaptive_sampling_convergence_check);
596 break;
597 }
599 oneapi_call(
600 kg, cgh, global_size, local_size, args, oneapi_kernel_adaptive_sampling_filter_x);
601 break;
602 }
604 oneapi_call(
605 kg, cgh, global_size, local_size, args, oneapi_kernel_adaptive_sampling_filter_y);
606 break;
607 }
609 oneapi_call(kg, cgh, global_size, local_size, args, oneapi_kernel_shader_eval_displace);
610 break;
611 }
613 oneapi_call(
614 kg, cgh, global_size, local_size, args, oneapi_kernel_shader_eval_background);
615 break;
616 }
618 oneapi_call(kg,
619 cgh,
620 global_size,
622 args,
623 oneapi_kernel_shader_eval_curve_shadow_transparency);
624 break;
625 }
627 oneapi_call(
628 kg, cgh, global_size, local_size, args, oneapi_kernel_shader_eval_volume_density);
629 break;
630 }
632 oneapi_call(kg, cgh, global_size, local_size, args, oneapi_kernel_prefix_sum);
633 break;
634 }
636 oneapi_call(
637 kg, cgh, global_size, local_size, args, oneapi_kernel_volume_guiding_filter_x);
638 break;
639 }
641 oneapi_call(
642 kg, cgh, global_size, local_size, args, oneapi_kernel_volume_guiding_filter_y);
643 break;
644 }
645
646 /* clang-format off */
647 # define DEVICE_KERNEL_FILM_CONVERT_PARTIAL(VARIANT, variant) \
648 case DEVICE_KERNEL_FILM_CONVERT_## VARIANT: { \
649 oneapi_call(kg, cgh, \
650 global_size, \
651 local_size, \
652 args, \
653 oneapi_kernel_film_convert_## variant); \
654 break; \
655 }
656
657# define DEVICE_KERNEL_FILM_CONVERT(variant, VARIANT) \
658 DEVICE_KERNEL_FILM_CONVERT_PARTIAL(VARIANT, variant) \
659 DEVICE_KERNEL_FILM_CONVERT_PARTIAL(VARIANT## _HALF_RGBA, variant## _half_rgba)
660
661 DEVICE_KERNEL_FILM_CONVERT(depth, DEPTH);
662 DEVICE_KERNEL_FILM_CONVERT(mist, MIST);
663 DEVICE_KERNEL_FILM_CONVERT(volume_majorant, VOLUME_MAJORANT);
664 DEVICE_KERNEL_FILM_CONVERT(sample_count, SAMPLE_COUNT);
665 DEVICE_KERNEL_FILM_CONVERT(float, FLOAT);
666 DEVICE_KERNEL_FILM_CONVERT(light_path, LIGHT_PATH);
667 DEVICE_KERNEL_FILM_CONVERT(rgbe, RGBE);
668 DEVICE_KERNEL_FILM_CONVERT(float3, FLOAT3);
669 DEVICE_KERNEL_FILM_CONVERT(motion, MOTION);
670 DEVICE_KERNEL_FILM_CONVERT(cryptomatte, CRYPTOMATTE);
671 DEVICE_KERNEL_FILM_CONVERT(shadow_catcher, SHADOW_CATCHER);
672 DEVICE_KERNEL_FILM_CONVERT(shadow_catcher_matte_with_shadow,
673 SHADOW_CATCHER_MATTE_WITH_SHADOW);
674 DEVICE_KERNEL_FILM_CONVERT(combined, COMBINED);
675 DEVICE_KERNEL_FILM_CONVERT(float4, FLOAT4);
676
677# undef DEVICE_KERNEL_FILM_CONVERT
678# undef DEVICE_KERNEL_FILM_CONVERT_PARTIAL
679 /* clang-format on */
680
682 oneapi_call(
683 kg, cgh, global_size, local_size, args, oneapi_kernel_filter_guiding_preprocess);
684 break;
685 }
687 oneapi_call(kg,
688 cgh,
689 global_size,
691 args,
692 oneapi_kernel_filter_guiding_set_fake_albedo);
693 break;
694 }
696 oneapi_call(
697 kg, cgh, global_size, local_size, args, oneapi_kernel_filter_color_preprocess);
698 break;
699 }
701 oneapi_call(
702 kg, cgh, global_size, local_size, args, oneapi_kernel_filter_color_postprocess);
703 break;
704 }
706 oneapi_call(kg, cgh, global_size, local_size, args, oneapi_kernel_filter_color_flip_y);
707 break;
708 }
710 oneapi_call(
711 kg, cgh, global_size, local_size, args, oneapi_kernel_cryptomatte_postprocess);
712 break;
713 }
715 oneapi_call(
716 kg, cgh, global_size, local_size, args, oneapi_kernel_integrator_compact_states);
717 break;
718 }
720 oneapi_call(kg,
721 cgh,
722 global_size,
724 args,
725 oneapi_kernel_integrator_compact_shadow_states);
726 break;
727 }
729 oneapi_call(kg,
730 cgh,
731 global_size,
733 args,
734 oneapi_kernel_integrator_shadow_catcher_count_possible_splits);
735 break;
736 }
737 /* Unsupported kernels */
744 kernel_assert(0);
745 break;
746 }
747 });
748 }
749 catch (const sycl::exception &e) {
750 if (s_error_cb) {
751 s_error_cb(e.what(), s_error_user_ptr);
752 success = false;
753 }
754 }
755
756# if defined(_WIN32)
757# pragma warning(default : 4062)
758# elif defined(__GNUC__)
759# pragma GCC diagnostic pop
760# endif
761 return success;
762}
763
764#endif /* WITH_ONEAPI */
#define GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE
Definition block_sizes.h:14
#define GPU_PARALLEL_PREFIX_SUM_DEFAULT_BLOCK_SIZE
Definition block_sizes.h:13
#define GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE
Definition block_sizes.h:12
#define GPU_PARALLEL_SORT_BLOCK_SIZE
Definition block_sizes.h:18
unsigned long long int uint64_t
nullptr FLOAT
#define kernel_assert(cond)
#define KERNEL_FEATURE_VOLUME
#define KERNEL_FEATURE_OBJECT_MOTION
#define KERNEL_FEATURE_HAIR_THICK
#define KERNEL_FEATURE_PATH_TRACING
#define KERNEL_FEATURE_GSPLATS
#define KERNEL_FEATURE_HAIR
#define KERNEL_FEATURE_NODE_RAYTRACE
#define KERNEL_FEATURE_BAKING
#define KERNEL_FEATURE_MNEE
#define KERNEL_FEATURE_POINTCLOUD
bool device_kernel_has_intersection(DeviceKernel kernel)
const char * device_kernel_as_string(DeviceKernel kernel)
#define assert(assertion)
#define local_size(...)
DeviceKernel
@ DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_CHECK
@ DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS_FROM_SURFACE
@ DEVICE_KERNEL_INTEGRATOR_RESET
@ DEVICE_KERNEL_INTEGRATOR_QUEUED_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_SHADE_DEDICATED_LIGHT
@ DEVICE_KERNEL_FILTER_COLOR_PREPROCESS
@ DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE
@ DEVICE_KERNEL_INTEGRATOR_SORT_WRITE_PASS
@ DEVICE_KERNEL_SHADER_EVAL_DISPLACE
@ DEVICE_KERNEL_INTEGRATOR_SHADOW_CATCHER_COUNT_POSSIBLE_SPLITS
@ DEVICE_KERNEL_INTEGRATOR_INTERSECT_MNEE
@ DEVICE_KERNEL_SHADER_EVAL_VOLUME_DENSITY
@ DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE
@ DEVICE_KERNEL_VOLUME_GUIDING_FILTER_X
@ DEVICE_KERNEL_INTEGRATOR_QUEUED_SHADOW_PATHS_ARRAY
@ DEVICE_KERNEL_FILTER_GUIDING_SET_FAKE_ALBEDO
@ DEVICE_KERNEL_FILTER_COLOR_PREPROCESS_TO_SURFACE
@ DEVICE_KERNEL_FILTER_COLOR_FLIP_Y
@ DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS
@ DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW
@ DEVICE_KERNEL_INTEGRATOR_TERMINATED_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK
@ DEVICE_KERNEL_SHADER_EVAL_BACKGROUND
@ DEVICE_KERNEL_INTEGRATOR_SORTED_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_COMPACT_SHADOW_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_COMPACT_SHADOW_STATES
@ DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE
@ DEVICE_KERNEL_INTEGRATOR_SORT_BUCKET_PASS
@ DEVICE_KERNEL_INTEGRATOR_INTERSECT_DEDICATED_LIGHT
@ DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS
@ DEVICE_KERNEL_INTEGRATOR_COMPACT_STATES
@ DEVICE_KERNEL_INTEGRATOR_SHADOW_PATH_MNEE_PENDING
@ DEVICE_KERNEL_INTEGRATOR_TERMINATED_SHADOW_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_MEGAKERNEL
@ DEVICE_KERNEL_NUM
@ DEVICE_KERNEL_INTEGRATOR_ACTIVE_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_INIT_FROM_CAMERA
@ DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_FILTER_Y
@ DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_FORWARD
@ DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME_RAY_MARCHING
@ DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_FILTER_X
@ DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_NEE
@ DEVICE_KERNEL_CRYPTOMATTE_POSTPROCESS
@ DEVICE_KERNEL_INTEGRATOR_COMPACT_PATHS_ARRAY
@ DEVICE_KERNEL_INTEGRATOR_INIT_FROM_BAKE
@ DEVICE_KERNEL_SHADER_EVAL_CURVE_SHADOW_TRANSPARENCY
@ DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME
@ DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW
@ DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST
@ DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND
@ DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS_TO_SURFACE
@ DEVICE_KERNEL_VOLUME_GUIDING_FILTER_Y
@ DEVICE_KERNEL_PREFIX_SUM
#define N
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e