├── .branch ├── .github └── pull-request.yml ├── level_zero ├── tools │ ├── source │ │ ├── sysman │ │ │ ├── linux │ │ │ │ ├── udev │ │ │ │ │ ├── wedged_file │ │ │ │ │ └── pci_bind_status_file │ │ │ │ └── xml_parser │ │ │ │ │ └── xml_parser_stub.cpp │ │ │ └── ras │ │ │ │ └── linux │ │ │ │ └── udev │ │ │ │ ├── counter_init │ │ │ │ └── 99-drm_ze_intel_gpu.rules │ │ ├── metrics │ │ │ └── linux │ │ │ │ └── os_metric_enumeration_imp_linux.cpp │ │ └── pin │ │ │ ├── linux │ │ │ └── os_pin.h │ │ │ └── windows │ │ │ └── os_pin.h │ └── test │ │ ├── CMakeLists.txt │ │ └── unit_tests │ │ └── sources │ │ ├── CMakeLists.txt │ │ ├── metrics │ │ └── linux │ │ │ └── CMakeLists.txt │ │ └── sysman │ │ ├── CMakeLists.txt │ │ ├── events │ │ ├── CMakeLists.txt │ │ └── windows │ │ │ └── CMakeLists.txt │ │ ├── engine │ │ └── CMakeLists.txt │ │ ├── fan │ │ ├── CMakeLists.txt │ │ └── linux │ │ │ └── CMakeLists.txt │ │ ├── memory │ │ └── CMakeLists.txt │ │ ├── pci │ │ ├── CMakeLists.txt │ │ └── linux │ │ │ └── CMakeLists.txt │ │ ├── power │ │ └── CMakeLists.txt │ │ ├── ras │ │ └── CMakeLists.txt │ │ ├── scheduler │ │ └── CMakeLists.txt │ │ ├── standby │ │ └── CMakeLists.txt │ │ ├── temperature │ │ └── CMakeLists.txt │ │ ├── fabric_port │ │ └── CMakeLists.txt │ │ ├── firmware │ │ ├── CMakeLists.txt │ │ └── linux │ │ │ └── CMakeLists.txt │ │ ├── frequency │ │ └── CMakeLists.txt │ │ ├── global_operations │ │ └── CMakeLists.txt │ │ ├── xml_parser │ │ └── CMakeLists.txt │ │ └── linux │ │ └── nl_api │ │ └── CMakeLists.txt ├── source │ └── CMakeLists.txt ├── experimental │ ├── test │ │ ├── CMakeLists.txt │ │ └── unit_tests │ │ │ └── sources │ │ │ └── CMakeLists.txt │ └── source │ │ ├── experimental.cpp │ │ └── tracing │ │ └── tracing_global_imp.h ├── core │ ├── source │ │ ├── dll │ │ │ ├── linux │ │ │ │ ├── ze.exports │ │ │ │ └── CMakeLists.txt │ │ │ ├── disallow_deferred_deleter.cpp │ │ │ └── windows │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── debugger_l0_windows.cpp │ │ ├── linux │ │ │ ├── registry_path.cpp │ │ │ ├── driver_teardown.cpp │ │ │ └── CMakeLists.txt │ │ ├── compiler_interface │ │ │ ├── l0_reg_path.h │ │ │ └── default_l0_cache_config.h │ │ ├── driver │ │ │ └── driver_version.h.in │ │ ├── windows │ │ │ ├── registry_path.cpp │ │ │ └── CMakeLists.txt │ │ ├── get_extension_function_lookup_map.h │ │ ├── helpers │ │ │ └── l0_populate_factory.h │ │ ├── gen12lp │ │ │ ├── dg1 │ │ │ │ └── kernel_dg1.cpp │ │ │ └── tgllp │ │ │ │ └── kernel_tgllp.cpp │ │ ├── kernel │ │ │ └── kernel.cpp │ │ ├── gen9 │ │ │ ├── cfl │ │ │ │ └── kernel_cfl.cpp │ │ │ ├── kbl │ │ │ │ └── kernel_kbl.cpp │ │ │ └── skl │ │ │ │ └── kernel_skl.cpp │ │ ├── gen11 │ │ │ └── icllp │ │ │ │ └── kernel_icllp.cpp │ │ ├── module │ │ │ └── module_extra_options.cpp │ │ ├── debugger │ │ │ ├── linux │ │ │ │ └── CMakeLists.txt │ │ │ ├── windows │ │ │ │ └── CMakeLists.txt │ │ │ └── debug_manager.cpp │ │ ├── additional_kernel_properties.cpp │ │ ├── gen8 │ │ │ └── debugger_gen8.cpp │ │ ├── get_extension_function_lookup_map.cpp │ │ └── hw_helpers │ │ │ ├── l0_hw_helper.cpp │ │ │ └── l0_hw_helper_base.inl │ └── test │ │ ├── CMakeLists.txt │ │ └── unit_tests │ │ ├── ult_configuration.cpp │ │ ├── mock.h │ │ ├── sources │ │ ├── context │ │ │ └── CMakeLists.txt │ │ ├── device │ │ │ └── CMakeLists.txt │ │ ├── event │ │ │ └── CMakeLists.txt │ │ ├── fence │ │ │ └── CMakeLists.txt │ │ ├── image │ │ │ └── CMakeLists.txt │ │ ├── kernel │ │ │ └── CMakeLists.txt │ │ ├── memory │ │ │ └── CMakeLists.txt │ │ ├── module │ │ │ └── CMakeLists.txt │ │ ├── sampler │ │ │ └── CMakeLists.txt │ │ ├── printf_handler │ │ │ └── CMakeLists.txt │ │ ├── cmdqueue │ │ │ └── CMakeLists.txt │ │ ├── CMakeLists.txt │ │ ├── helper │ │ │ └── CMakeLists.txt │ │ ├── memory_manager │ │ │ └── CMakeLists.txt │ │ ├── debugger │ │ │ └── linux │ │ │ │ └── CMakeLists.txt │ │ └── driver │ │ │ └── CMakeLists.txt │ │ ├── fixtures │ │ └── device_fixture.cpp │ │ ├── gen8 │ │ └── CMakeLists.txt │ │ └── test_mode.h ├── api │ ├── experimental │ │ ├── CMakeLists.txt │ │ └── tracing │ │ │ └── CMakeLists.txt │ ├── sysman │ │ └── CMakeLists.txt │ └── tools │ │ └── CMakeLists.txt └── cmake │ ├── not_supported_platforms.cmake │ └── UdevRulesDir.cmake ├── .ctags ├── .gitattributes ├── opencl ├── test │ └── unit_test │ │ ├── test_files │ │ ├── linux │ │ │ ├── by-path │ │ │ │ ├── pci-0000-device-card │ │ │ │ └── pci-0000-device-render │ │ │ └── devices │ │ │ │ └── device │ │ │ │ └── drm │ │ │ │ └── card1 │ │ │ │ └── gt_max_freq_mhz │ │ ├── kernel_for_specific_device_options.txt │ │ ├── igdrcl_string.config │ │ ├── binary_with_zeroes │ │ ├── kernel_for_specific_device.skl │ │ ├── stateful_copy_buffer_ocloc_options.txt │ │ ├── emptykernel.cl │ │ ├── kernel_num_args.cl │ │ ├── simple_header.h │ │ ├── stateless_kernel.cl │ │ ├── simple_arg_int.cl │ │ ├── shouldfail.cl │ │ ├── printf.cl │ │ ├── stateful_copy_buffer.cl │ │ ├── copybuffer.cl │ │ ├── copybuffer_with_header.cl │ │ ├── CopyBuffer_simd16.cl │ │ ├── CopyBuffer_simd32.cl │ │ ├── CopyBuffer_simd8.cl │ │ ├── simple_kernels_opts.cl │ │ └── test_basic_constant.cl │ │ ├── lsan_suppressions.txt │ │ ├── mock_gl │ │ └── CMakeLists.txt │ │ ├── mocks │ │ ├── gl │ │ │ └── CMakeLists.txt │ │ ├── mock_async_event_handler.cpp │ │ ├── mock_gmm_memory_base.cpp │ │ ├── mock_sharing_factory.h │ │ └── mock_tbx_stream.h │ │ ├── command_queue │ │ └── gl │ │ │ └── CMakeLists.txt │ │ ├── helpers │ │ ├── windows │ │ │ ├── mock_function.h │ │ │ └── mock_function.cpp │ │ ├── ult_limits.h │ │ ├── test_debug_variables.inl │ │ ├── static_size3.h │ │ └── kernel_binary_helper_hash_value.cpp │ │ ├── igdrcl_tests_pch.cpp │ │ ├── mt_tests │ │ ├── gen11 │ │ │ ├── CMakeLists.txt │ │ │ └── icllp │ │ │ │ └── CMakeLists.txt │ │ ├── gen8 │ │ │ ├── CMakeLists.txt │ │ │ └── bdw │ │ │ │ └── CMakeLists.txt │ │ ├── gen9 │ │ │ ├── CMakeLists.txt │ │ │ └── skl │ │ │ │ └── CMakeLists.txt │ │ ├── gen12lp │ │ │ ├── CMakeLists.txt │ │ │ └── tgllp │ │ │ │ └── CMakeLists.txt │ │ ├── os_interface │ │ │ └── CMakeLists.txt │ │ ├── test_mode.h │ │ ├── device_queue │ │ │ └── CMakeLists.txt │ │ └── event │ │ │ └── CMakeLists.txt │ │ ├── memory_manager │ │ ├── gfx_partition_tests.cpp │ │ └── memory_manager_allocate_in_preferred_pool_tests.cpp │ │ ├── os_interface │ │ ├── windows │ │ │ ├── self_lib_win.cpp │ │ │ ├── mock_environment_variables.h │ │ │ ├── wddm_create.cpp │ │ │ └── gl │ │ │ │ └── CMakeLists.txt │ │ └── linux │ │ │ └── self_lib_lin.cpp │ │ ├── test_dynamic_lib │ │ ├── test_dynamic_lib_win.cpp │ │ └── test_dynamic_lib_lin.cpp │ │ ├── linux │ │ ├── drm_other_requests.cpp │ │ ├── linux_tests_configuration.cpp │ │ └── test_mode.h │ │ ├── aub_tests │ │ ├── gen8 │ │ │ ├── bdw │ │ │ │ └── CMakeLists.txt │ │ │ ├── execution_model │ │ │ │ └── CMakeLists.txt │ │ │ └── aub_tests_configuration_gen8.cpp │ │ ├── gen9 │ │ │ ├── bxt │ │ │ │ └── CMakeLists.txt │ │ │ ├── skl │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── command_queue │ │ │ │ │ └── CMakeLists.txt │ │ │ ├── execution_model │ │ │ │ └── CMakeLists.txt │ │ │ ├── aub_tests_configuration_gen9.cpp │ │ │ ├── batch_buffer │ │ │ │ └── CMakeLists.txt │ │ │ └── CMakeLists.txt │ │ ├── gen11 │ │ │ ├── icllp │ │ │ │ └── CMakeLists.txt │ │ │ ├── execution_model │ │ │ │ └── CMakeLists.txt │ │ │ ├── aub_tests_configuration_gen11.cpp │ │ │ └── batch_buffer │ │ │ │ └── CMakeLists.txt │ │ ├── gen12lp │ │ │ ├── tgllp │ │ │ │ └── CMakeLists.txt │ │ │ ├── execution_model │ │ │ │ └── CMakeLists.txt │ │ │ └── batch_buffer │ │ │ │ └── CMakeLists.txt │ │ ├── mem_obj │ │ │ └── CMakeLists.txt │ │ ├── aub_tests_configuration.h │ │ ├── test_mode.h │ │ ├── unified_memory │ │ │ └── CMakeLists.txt │ │ └── aub_tests_configuration.cpp │ │ ├── command_stream │ │ └── thread_arbitration_policy_helper.h │ │ ├── abort.cpp │ │ ├── sharings │ │ ├── gl │ │ │ ├── windows │ │ │ │ └── gl_library_name.cpp │ │ │ └── CMakeLists.txt │ │ ├── d3d │ │ │ └── CMakeLists.txt │ │ └── CMakeLists.txt │ │ ├── options_unit_tests.cpp │ │ ├── config │ │ └── test_mode.h │ │ ├── preemption │ │ └── CMakeLists.txt │ │ ├── windows │ │ └── test_mode.h │ │ ├── device │ │ └── gl │ │ │ └── CMakeLists.txt │ │ ├── gen12lp │ │ ├── cmd_parse │ │ │ └── cmd_parse_gen12lp.inl │ │ ├── dg1 │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ ├── adls │ │ │ └── linux │ │ │ │ ├── dll │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ ├── rkl │ │ │ └── linux │ │ │ │ ├── dll │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ └── tgllp │ │ │ └── linux │ │ │ └── dll │ │ │ └── CMakeLists.txt │ │ ├── profiling │ │ └── CMakeLists.txt │ │ ├── accelerators │ │ └── CMakeLists.txt │ │ ├── ult_configuration.cpp │ │ ├── gmm_helper │ │ └── CMakeLists.txt │ │ ├── gen9 │ │ ├── bxt │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ ├── cfl │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ ├── glk │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ ├── kbl │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ ├── skl │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ └── windows │ │ │ └── CMakeLists.txt │ │ ├── gen8 │ │ ├── bdw │ │ │ ├── linux │ │ │ │ ├── dll │ │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ │ └── windows │ │ │ │ └── CMakeLists.txt │ │ ├── windows │ │ │ └── CMakeLists.txt │ │ └── unit_test_helper_gen8.cpp │ │ ├── libult │ │ ├── debug_manager.cpp │ │ └── os_interface.cpp │ │ ├── execution_environment │ │ └── CMakeLists.txt │ │ ├── gen11 │ │ ├── ehl │ │ │ └── linux │ │ │ │ ├── dll │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ ├── lkf │ │ │ └── linux │ │ │ │ ├── dll │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ ├── icllp │ │ │ └── linux │ │ │ │ ├── dll │ │ │ │ └── CMakeLists.txt │ │ │ │ └── CMakeLists.txt │ │ ├── windows │ │ │ └── CMakeLists.txt │ │ └── unit_test_helper_gen11.cpp │ │ ├── aub │ │ └── aub_helper_tests.cpp │ │ ├── platform │ │ └── CMakeLists.txt │ │ ├── perf_tests │ │ └── api │ │ │ └── CMakeLists.txt │ │ ├── built_ins │ │ └── built_ins_file_names.h │ │ ├── aub_mem_dump │ │ └── CMakeLists.txt │ │ ├── context │ │ └── gl │ │ │ └── windows │ │ │ └── CMakeLists.txt │ │ ├── fixtures │ │ └── built_in_fixture.h │ │ ├── api │ │ └── cl_unload_compiler_tests.inl │ │ └── scenarios │ │ └── windows │ │ └── CMakeLists.txt └── source │ ├── gen12lp │ ├── definitions │ │ ├── hardware_commands_helper_gen12lp.inl │ │ └── command_queue_helpers_gen12lp.inl │ ├── CMakeLists.txt │ ├── sampler_gen12lp.cpp │ ├── linux │ │ └── hw_info_config_adls.inl │ └── windows │ │ └── gmm_callbacks_gen12lp.cpp │ ├── gen11 │ ├── CMakeLists.txt │ └── buffer_gen11.cpp │ ├── gen8 │ ├── CMakeLists.txt │ ├── hw_info_gen8.cpp │ ├── linux │ │ └── hw_info_config_gen8.cpp │ ├── command_stream_receiver_simulated_common_hw_gen8.cpp │ └── buffer_gen8.cpp │ ├── gen9 │ ├── CMakeLists.txt │ ├── command_stream_receiver_simulated_common_hw_gen9.cpp │ └── buffer_gen9.cpp │ ├── dll │ ├── linux │ │ ├── devices │ │ │ └── devices.inl │ │ └── ocl_release.exports │ ├── create_tbx_sockets.cpp │ ├── debug_manager.cpp │ ├── create_deferred_deleter.cpp │ └── source_level_debugger_dll.cpp │ ├── command_queue │ ├── resource_barrier.h │ └── flush.h │ ├── os_interface │ ├── ocl_reg_path.h │ ├── linux │ │ ├── ocl_reg_path.cpp │ │ └── device_caps_init_linux.cpp │ └── windows │ │ └── ocl_reg_path.cpp │ ├── sharings │ ├── gl │ │ └── windows │ │ │ ├── gl_library_windows.cpp │ │ │ └── include │ │ │ └── gl_types.h │ ├── unified │ │ └── unified_enable_name.cpp │ ├── sharing_factory.inl │ └── va │ │ └── va_extension.cpp │ ├── helpers │ ├── base_object.cpp │ ├── built_ins_helper.h │ ├── cl_device_helpers.cpp │ ├── helper_options.cpp │ └── cl_hw_helper.cpp │ ├── program │ └── additional_options.cpp │ ├── api │ ├── additional_extensions.h │ └── additional_extensions.cpp │ ├── kernel │ └── kernel_execution_type.h │ ├── compiler_interface │ └── default_cl_cache_config.h │ ├── mem_obj │ ├── definitions │ │ ├── image_ext.inl │ │ └── buffer_ext.inl │ ├── buffer_factory_init.inl │ └── image_factory_init.inl │ ├── execution_model │ └── CMakeLists.txt │ ├── guidelines │ └── CMakeLists.txt │ ├── context │ └── context_type.h │ ├── command_stream │ └── per_dss_backed_buffer.cpp │ └── gtpin │ └── gtpin_hw_helper.cpp ├── third_party ├── .clang-tidy ├── metrics_library │ └── .revision ├── metrics_discovery │ └── .revision ├── uapi │ └── dg1 │ │ └── drm │ │ └── README.md └── aub_stream │ └── headers │ ├── page_info.h │ └── engine_node.h ├── scripts ├── tests │ └── copyright │ │ ├── in │ │ ├── file2.sh │ │ ├── file1.cpp │ │ ├── file1.sh │ │ ├── file2.cpp │ │ ├── file3.sh │ │ ├── file3.cpp │ │ ├── file6.cpp │ │ ├── file7.cpp │ │ ├── file4.sh │ │ ├── file4.cpp │ │ └── file5.cpp │ │ └── out │ │ ├── file2.sh │ │ ├── file2.cpp │ │ ├── file5.cpp │ │ ├── file1.sh │ │ ├── file3.sh │ │ ├── file1.cpp │ │ ├── file3.cpp │ │ ├── file4.sh │ │ ├── file6.cpp │ │ ├── file7.cpp │ │ └── file4.cpp ├── build-arch-docker.sh ├── build-arch-clang.sh ├── build-fedora31-copr-docker.sh ├── build-fedora32-copr-docker.sh ├── prepare-arch.sh ├── prepare-arch-clang.sh └── docker │ └── Dockerfile-arch ├── .gitignore ├── Jenkinsfile ├── ubsan.supp ├── .gitreview ├── package_config.cmake ├── shared ├── test │ └── unit_test │ │ ├── test_files │ │ ├── 17475704436818206941_options.txt │ │ └── 13936718464051189346_images_options.txt │ │ ├── page_fault_manager │ │ └── default_asan_options.cpp │ │ ├── helpers │ │ ├── ult_hw_config.inl │ │ ├── default_hw_info.inl │ │ └── default_hw_info.h │ │ ├── built_ins │ │ └── CMakeLists.txt │ │ ├── heap_assigner │ │ └── CMakeLists.txt │ │ ├── indirect_heap │ │ └── CMakeLists.txt │ │ ├── test_mode.h │ │ ├── unified_memory │ │ └── CMakeLists.txt │ │ ├── debug_settings │ │ └── debug_manager.cpp │ │ ├── preemption │ │ └── CMakeLists.txt │ │ ├── direct_submission │ │ └── CMakeLists.txt │ │ ├── gen12lp │ │ └── cmd_parse │ │ │ └── cmd_parse_gen12lp.inl │ │ ├── os_interface │ │ └── windows │ │ │ └── mock_gdi_interface.cpp │ │ ├── gen9 │ │ └── skl │ │ │ └── CMakeLists.txt │ │ ├── image │ │ └── CMakeLists.txt │ │ ├── command_container │ │ └── CMakeLists.txt │ │ ├── memory_manager │ │ └── CMakeLists.txt │ │ ├── preamble │ │ └── CMakeLists.txt │ │ └── tests_configuration.h ├── source │ ├── os_interface │ │ ├── windows │ │ │ ├── os_socket.h │ │ │ ├── windows_inc.cpp │ │ │ ├── environment_variables.h │ │ │ ├── wddm_allocation.cpp │ │ │ ├── wddm_additional_context_flags.cpp │ │ │ └── os_inc.h │ │ ├── linux │ │ │ ├── os_socket.h │ │ │ ├── linux_inc.cpp │ │ │ ├── allocator_helper.h │ │ │ ├── engine_info.h │ │ │ ├── memory_info.h │ │ │ ├── flags │ │ │ │ └── drm_query_flags.h │ │ │ ├── drm_engine_mapper.h │ │ │ ├── hw_device_id_linux.cpp │ │ │ ├── sys_calls.h │ │ │ ├── drm_buffer_object_extended.cpp │ │ │ └── os_inc.h │ │ ├── os_environment.h │ │ ├── hw_info_config_bdw_plus.inl │ │ └── os_thread.h │ ├── gen8 │ │ ├── hw_cmds.h │ │ ├── hw_info.h │ │ ├── enable_hw_info_config_gen8.cpp │ │ ├── hw_info_gen8.h │ │ └── state_base_address_gen8.cpp │ ├── debug_settings │ │ ├── definitions │ │ │ ├── debug_variables.inl │ │ │ ├── translate_debug_settings.h │ │ │ └── translate_debug_settings.cpp │ │ ├── debug_variables_helper.h │ │ └── windows │ │ │ └── debug_variables_helper.cpp │ ├── helpers │ │ ├── abort.h │ │ ├── deferred_deleter_helper.h │ │ ├── get_info_status.h │ │ ├── abort.cpp │ │ ├── completion_stamp.cpp │ │ ├── api_specific_config.h │ │ ├── populate_factory.h │ │ ├── timestamp_packet_extra.cpp │ │ ├── windows │ │ │ └── gmm_callbacks.cpp │ │ ├── definitions │ │ │ └── engine_group_types.h │ │ ├── pipeline_select_args.h │ │ ├── timestamp_offsets.h │ │ ├── simd_helper.h │ │ ├── extendable_enum.h │ │ ├── array_count.h │ │ ├── allow_deferred_deleter.cpp │ │ └── compiler_options_parser.h │ ├── kernel │ │ ├── kernel_descriptor.cpp │ │ ├── grf_config.h │ │ └── debug_data.h │ ├── utilities │ │ ├── spinlock.h │ │ ├── cpuintrinsics.h │ │ ├── heap_allocator.cpp │ │ ├── directory.h │ │ └── compiler_support.h │ ├── aub_mem_dump │ │ ├── aub_data.h │ │ └── context_flags.cpp │ ├── compiler_interface │ │ ├── compiler_options │ │ │ └── compiler_options.h │ │ └── default_cache_config.h │ ├── command_stream │ │ ├── queue_throttle.h │ │ ├── aub_subcapture_status.h │ │ └── definitions │ │ │ └── csr_properties_flags.h │ ├── commands │ │ └── CMakeLists.txt │ ├── gen11 │ │ ├── hw_cmds.h │ │ ├── hw_info.h │ │ ├── hw_info_gen11.h │ │ └── state_base_address_gen11.cpp │ ├── built_ins │ │ ├── builtinops │ │ │ ├── built_in_ops.h │ │ │ └── CMakeLists.txt │ │ ├── sip_kernel_type.h │ │ └── kernels │ │ │ └── aux_translation.builtin_kernel │ ├── dll │ │ └── options_dll.cpp │ ├── gmm_helper │ │ ├── windows │ │ │ └── gmm_memory.cpp │ │ ├── client_context │ │ │ └── gmm_client_context.cpp │ │ └── gmm_lib.h │ ├── memory_manager │ │ ├── definitions │ │ │ ├── engine_limits.h │ │ │ └── storage_info.h │ │ ├── eviction_status.h │ │ └── residency_container.h │ ├── debugger │ │ └── CMakeLists.txt │ ├── gen_common │ │ └── CMakeLists.txt │ ├── indirect_heap │ │ └── CMakeLists.txt │ ├── gen12lp │ │ ├── hw_info.h │ │ ├── hw_info_gen12lp.h │ │ └── state_base_address_gen12lp.cpp │ ├── gen9 │ │ ├── hw_info_gen9.h │ │ └── state_base_address_gen9.cpp │ └── image │ │ └── image_skl_plus.inl └── offline_compiler │ ├── CMakeLists.txt │ └── source │ ├── utilities │ ├── get_current_dir.h │ ├── safety_caller.h │ └── windows │ │ └── get_current_dir_windows.cpp │ ├── ocloc_validator.h │ ├── main.cpp │ └── offline_compiler_options.cpp ├── target_unit_tests ├── gen11 │ ├── CMakeLists.txt │ ├── ehl │ │ └── CMakeLists.txt │ ├── lkf │ │ └── CMakeLists.txt │ └── icllp │ │ └── CMakeLists.txt ├── gen8 │ ├── CMakeLists.txt │ └── bdw │ │ └── CMakeLists.txt ├── gen9 │ ├── CMakeLists.txt │ ├── bxt │ │ └── CMakeLists.txt │ ├── cfl │ │ └── CMakeLists.txt │ ├── glk │ │ └── CMakeLists.txt │ ├── kbl │ │ └── CMakeLists.txt │ └── skl │ │ └── CMakeLists.txt └── gen12lp │ ├── CMakeLists.txt │ ├── adls │ └── CMakeLists.txt │ ├── rkl │ └── CMakeLists.txt │ └── tgllp │ └── CMakeLists.txt ├── lib_names.h.in ├── cmake └── fill_gens.cmake ├── driver_version.h.in └── igc.opencl.h.in /.branch: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.github/pull-request.yml: -------------------------------------------------------------------------------- 1 | defaultbranch: master 2 | -------------------------------------------------------------------------------- /level_zero/tools/source/sysman/linux/udev/wedged_file: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.ctags: -------------------------------------------------------------------------------- 1 | -R 2 | -h .inl.h 3 | --langmap=c++:.inl.cpp.h 4 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | manifests/manifest.yml filter=repo_converter 2 | -------------------------------------------------------------------------------- /level_zero/tools/source/sysman/linux/udev/pci_bind_status_file: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /level_zero/tools/source/sysman/ras/linux/udev/counter_init: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/linux/by-path/pci-0000-device-card: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third_party/.clang-tidy: -------------------------------------------------------------------------------- 1 | --- 2 | Checks: '-*' 3 | ... 4 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/linux/by-path/pci-0000-device-render: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file2.sh: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017 XYZ 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .vs/* 2 | CMakeSettings.json 3 | build/* 4 | build_linux/* 5 | out/* -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * No copyright at all 3 | */ 4 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file1.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | 4 | echo 123 5 | -------------------------------------------------------------------------------- /third_party/metrics_library/.revision: -------------------------------------------------------------------------------- 1 | I0cb6316de4bac5f9243a0b305043045cb853f0ff -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/linux/devices/device/drm/card1/gt_max_freq_mhz: -------------------------------------------------------------------------------- 1 | 1000 -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017 XYZ 3 | */ 4 | -------------------------------------------------------------------------------- /third_party/metrics_discovery/.revision: -------------------------------------------------------------------------------- 1 | 0928b82f6242217637c3a89d01eb630c55a52ce7 -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file3.sh: -------------------------------------------------------------------------------- 1 | # 2 | # This comment shouldn't be removed 3 | # 4 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/kernel_for_specific_device_options.txt: -------------------------------------------------------------------------------- 1 | -cl-opt-disable 2 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file3.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This comment shouldn't be removed 3 | // 4 | -------------------------------------------------------------------------------- /Jenkinsfile: -------------------------------------------------------------------------------- 1 | #!groovy 2 | dependenciesRevision='ac8c1c2332230b8adde0a34cfdbcf8466e26cd15-1561' 3 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file6.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // header file with # in first line 4 | -------------------------------------------------------------------------------- /ubsan.supp: -------------------------------------------------------------------------------- 1 | vptr:std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release() 2 | vptr:ocloc 3 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/igdrcl_string.config: -------------------------------------------------------------------------------- 1 | StringTestKey = TestValue 2 | IntTestKey = 1 3 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file7.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // header file with # in first line 4 | -------------------------------------------------------------------------------- /.gitreview: -------------------------------------------------------------------------------- 1 | [gerrit] 2 | defaultremote=origin 3 | defaultbranch=master 4 | track=true 5 | defaultrebase=false 6 | -------------------------------------------------------------------------------- /opencl/test/unit_test/lsan_suppressions.txt: -------------------------------------------------------------------------------- 1 | leak:OsAgnosticMemoryManager_pleaseDetectLeak_Test::TestBody() 2 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file4.sh: -------------------------------------------------------------------------------- 1 | # 2 | # No copyright at all 3 | # 4 | 5 | echo "file.h" 6 | 7 | exit 1 8 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/binary_with_zeroes: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/kernel_for_specific_device.skl: -------------------------------------------------------------------------------- 1 | __kernel void simple_device_specific_kernel() { 2 | } -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file4.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * No copyright at all 3 | */ 4 | 5 | #include "file.h" 6 | 7 | class C; 8 | -------------------------------------------------------------------------------- /scripts/tests/copyright/in/file5.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2012 - 2016 Intel Corporation 3 | * 4 | * No spdx header 5 | */ 6 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file2.sh: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file5.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2012-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | -------------------------------------------------------------------------------- /level_zero/source/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | add_subdirectories() 8 | 9 | -------------------------------------------------------------------------------- /third_party/uapi/dg1/drm/README.md: -------------------------------------------------------------------------------- 1 | Source location of Linux kernel DRM/i915 interface headers: 2 | https://repositories.intel.com/graphics/kernel-api/index.html 3 | -------------------------------------------------------------------------------- /level_zero/experimental/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | add_subdirectories() 8 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mock_gl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | add_subdirectories() 8 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mocks/gl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | add_subdirectories() 8 | -------------------------------------------------------------------------------- /package_config.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(ENV{LD_LIBRARY_PATH} ${CPACK_LD_LIBRARY_PATH}) 8 | -------------------------------------------------------------------------------- /opencl/source/gen12lp/definitions/hardware_commands_helper_gen12lp.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | -------------------------------------------------------------------------------- /opencl/test/unit_test/command_queue/gl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | add_subdirectories() 8 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file1.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2020 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | 9 | 10 | echo 123 11 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file3.sh: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | # 8 | # This comment shouldn't be removed 9 | # 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/helpers/windows/mock_function.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | const char *realFunction(); 9 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/stateful_copy_buffer_ocloc_options.txt: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | -force_stos_opt 9 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | /* 9 | * No copyright at all 10 | */ 11 | -------------------------------------------------------------------------------- /shared/test/unit_test/test_files/17475704436818206941_options.txt: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | -cl-fast-relaxed-math 9 | -------------------------------------------------------------------------------- /target_unit_tests/gen11/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN11) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /target_unit_tests/gen8/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN8) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /target_unit_tests/gen9/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN9) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /level_zero/core/source/dll/linux/ze.exports: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | { 9 | local: 10 | cl*; 11 | }; 12 | -------------------------------------------------------------------------------- /opencl/source/gen11/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(SUPPORT_GEN11) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/source/gen8/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(SUPPORT_GEN8) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/source/gen9/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(SUPPORT_GEN9) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /shared/test/unit_test/test_files/13936718464051189346_images_options.txt: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | -cl-fast-relaxed-math 9 | -------------------------------------------------------------------------------- /target_unit_tests/gen12lp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN12LP) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /level_zero/core/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(NOT SKIP_L0_UNIT_TESTS) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /level_zero/experimental/source/experimental.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | namespace L0 { 9 | } // namespace L0 10 | -------------------------------------------------------------------------------- /level_zero/tools/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(NOT SKIP_L0_UNIT_TESTS) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/source/gen12lp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(SUPPORT_GEN12LP) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/igdrcl_tests_pch.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/igdrcl_tests_pch.h" 9 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file3.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | // 9 | // This comment shouldn't be removed 10 | // 11 | -------------------------------------------------------------------------------- /shared/source/os_interface/windows/os_socket.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen11/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN11) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen8/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN8) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen9/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN9) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /opencl/source/dll/linux/devices/devices.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/dll/linux/devices/devices_base.inl" 9 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen12lp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN12LP) 8 | add_subdirectories() 9 | endif() 10 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file4.sh: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | # 8 | # No copyright at all 9 | # 10 | 11 | echo "file.h" 12 | 13 | exit 1 14 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file6.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | // header file with # in first line 11 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file7.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | 10 | // header file with # in first line 11 | -------------------------------------------------------------------------------- /level_zero/core/source/linux/registry_path.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | namespace L0 { 9 | const char *registryPath = ""; 10 | } 11 | -------------------------------------------------------------------------------- /shared/offline_compiler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | add_subdirectory(source) 8 | set(CLOC_LIB_SRCS_LIB ${CLOC_LIB_SRCS_LIB} PARENT_SCOPE) 9 | -------------------------------------------------------------------------------- /opencl/source/command_queue/resource_barrier.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | namespace NEO { 9 | struct BarrierCommand {}; 10 | } // namespace NEO -------------------------------------------------------------------------------- /shared/source/gen8/hw_cmds.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #ifdef SUPPORT_BDW 10 | #include "hw_cmds_bdw.h" 11 | #endif 12 | -------------------------------------------------------------------------------- /shared/source/gen8/hw_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #ifdef SUPPORT_BDW 10 | #include "hw_info_bdw.h" 11 | #endif 12 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/os_socket.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | typedef int SOCKET; 11 | -------------------------------------------------------------------------------- /shared/source/os_interface/windows/windows_inc.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | namespace Os { 9 | const char *fileSeparator = "/"; 10 | } 11 | -------------------------------------------------------------------------------- /shared/source/debug_settings/definitions/debug_variables.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_variables_base.inl" 9 | -------------------------------------------------------------------------------- /scripts/tests/copyright/out/file4.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | /* 9 | * No copyright at all 10 | */ 11 | 12 | #include "file.h" 13 | 14 | class C; 15 | -------------------------------------------------------------------------------- /shared/source/helpers/abort.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | [[noreturn]] void abortExecution(); 12 | } 13 | -------------------------------------------------------------------------------- /opencl/source/gen12lp/definitions/command_queue_helpers_gen12lp.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/command_queue/enqueue_resource_barrier.h" 9 | -------------------------------------------------------------------------------- /opencl/test/unit_test/memory_manager/gfx_partition_tests.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/memory_manager/gfx_partition_tests.inl" 9 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/emptykernel.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | /* No character after the last "}" */ 9 | __kernel void empty() 10 | { 11 | } -------------------------------------------------------------------------------- /shared/source/helpers/deferred_deleter_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | namespace NEO { 9 | bool isDeferredDeleterEnabled(); 10 | } // namespace NEO 11 | -------------------------------------------------------------------------------- /shared/source/kernel/kernel_descriptor.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/kernel/kernel_descriptor.h" 9 | 10 | namespace NEO { 11 | } 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/os_interface/windows/self_lib_win.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | extern "C" __declspec(dllexport) void selfDynamicLibraryFunc() { 9 | } 10 | -------------------------------------------------------------------------------- /opencl/source/os_interface/ocl_reg_path.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | namespace NEO { 10 | extern const char *oclRegPath; 11 | } // namespace NEO 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_dynamic_lib/test_dynamic_lib_win.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | extern "C" __declspec(dllexport) void testDynamicLibraryFunc() { 9 | } 10 | -------------------------------------------------------------------------------- /level_zero/api/experimental/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_EXPERIMENTAL_API 8 | ) 9 | 10 | set_property(GLOBAL PROPERTY L0_EXPERIMENTAL_API ${L0_EXPERIMENTAL_API}) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/helpers/windows/mock_function.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "mock_function.h" 9 | 10 | const char *realFunction() { return "value"; } 11 | -------------------------------------------------------------------------------- /level_zero/core/source/compiler_interface/l0_reg_path.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | namespace L0 { 10 | extern const char *registryPath; 11 | } // namespace L0 12 | -------------------------------------------------------------------------------- /lib_names.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #cmakedefine SLD_LIBRARY_NAME "${CMAKE_SHARED_LIBRARY_PREFIX}${SLD_LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}" 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/os_interface/linux/self_lib_lin.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | extern "C" __attribute__((visibility("default"))) void selfDynamicLibraryFunc() { 9 | } 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/linux/drm_other_requests.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | 10 | int drmOtherRequests(unsigned long int request, ...) { return 0; } 11 | -------------------------------------------------------------------------------- /shared/offline_compiler/source/utilities/get_current_dir.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | extern std::string getCurrentDirectoryOwn(std::string outDirForBuilds); -------------------------------------------------------------------------------- /opencl/test/unit_test/test_dynamic_lib/test_dynamic_lib_lin.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | extern "C" __attribute__((visibility("default"))) void testDynamicLibraryFunc() { 9 | } 10 | -------------------------------------------------------------------------------- /target_unit_tests/gen11/ehl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_EHL) 8 | set(unit_test_config "ehl/1/4/8/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen11/lkf/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_LKF) 8 | set(unit_test_config "lkf/1/8/8/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen8/bdw/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_BDW) 8 | set(unit_test_config "bdw/1/3/8/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen9/bxt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_BXT) 8 | set(unit_test_config "bxt/1/3/6/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen9/cfl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_CFL) 8 | set(unit_test_config "cfl/1/3/6/9") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen9/glk/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GLK) 8 | set(unit_test_config "glk/1/3/6/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen9/kbl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_KBL) 8 | set(unit_test_config "kbl/1/3/6/9") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen9/skl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_SKL) 8 | set(unit_test_config "skl/1/3/8/9") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /cmake/fill_gens.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | list(APPEND ALL_GEN_TYPES "GEN8") 8 | list(APPEND ALL_GEN_TYPES "GEN9") 9 | list(APPEND ALL_GEN_TYPES "GEN11") 10 | list(APPEND ALL_GEN_TYPES "GEN12LP") 11 | -------------------------------------------------------------------------------- /opencl/source/sharings/gl/windows/gl_library_windows.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | 10 | namespace Os { 11 | const char *openglDllName = "opengl32.dll"; 12 | } 13 | -------------------------------------------------------------------------------- /scripts/build-arch-docker.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2018-2019 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | git fetch -t 9 | git clone ../compute-runtime neo 10 | docker build -f scripts/docker/Dockerfile-arch -t neo-arch:ci . 11 | 12 | -------------------------------------------------------------------------------- /shared/source/debug_settings/debug_variables_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | 12 | bool isDebugKeysReadEnabled(); 13 | 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/source/utilities/spinlock.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace NEO { 13 | using SpinLock = std::mutex; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /target_unit_tests/gen11/icllp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_ICLLP) 8 | set(unit_test_config "icllp/1/8/8/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen12lp/adls/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_ADLS) 8 | set(unit_test_config "adls/1/2/16/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /target_unit_tests/gen12lp/rkl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_RKL) 8 | set(unit_test_config "rkl/1/2/16/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/ult_configuration.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "test_mode.h" 9 | 10 | namespace NEO { 11 | TestMode testMode = defaultTestMode; 12 | } // namespace NEO 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/kernel_num_args.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void test(__global float *argGlobal, __read_only image3d_t argImg3D, __constant float *argConst) { 9 | } 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/simple_header.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | extern __kernel void AddBuffer( 11 | __global float *src, 12 | __global float *dst); 13 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/linux_inc.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/linux/os_inc.h" 9 | namespace Os { 10 | const char *fileSeparator = "/"; 11 | } 12 | -------------------------------------------------------------------------------- /target_unit_tests/gen12lp/tgllp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_TGLLP) 8 | set(unit_test_config "tgllp/1/6/16/0") 9 | include(${NEO_SOURCE_DIR}/cmake/run_ult_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/source/os_interface/linux/ocl_reg_path.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/os_interface/ocl_reg_path.h" 9 | 10 | namespace NEO { 11 | const char *oclRegPath = ""; 12 | } 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/stateless_kernel.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void statelessKernel(__global uchar* src) { 9 | uint tid = get_global_id(0); 10 | src[tid] = 0xCD; 11 | } -------------------------------------------------------------------------------- /scripts/build-arch-clang.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2018-2019 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | git fetch -t 9 | git clone ../compute-runtime neo 10 | docker build -f scripts/docker/Dockerfile-arch-clang -t neo-arch-clang:ci . 11 | 12 | -------------------------------------------------------------------------------- /shared/source/aub_mem_dump/aub_data.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | struct AubGTTData { 13 | bool present; 14 | bool localMemory; 15 | }; 16 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/allocator_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | size_t getSizeToReserve(); 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen8/bdw/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_BDW) 8 | set(aub_test_config "bdw/1/3/8/0") 9 | include(${OPENCL_AUB_TEST_DIR}/cmake/run_aub_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/bxt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_BXT) 8 | set(aub_test_config "bxt/1/3/6/0") 9 | include(${OPENCL_AUB_TEST_DIR}/cmake/run_aub_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/linux/linux_tests_configuration.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "test_mode.h" 9 | 10 | namespace NEO { 11 | TestMode testMode = defaultTestMode; 12 | } // namespace NEO 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen8/bdw/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_BDW) 8 | set(mt_test_config "bdw/1/3/8/0") 9 | include(${OPENCL_MT_TEST_DIR}/cmake/run_mt_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen9/skl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_SKL) 8 | set(mt_test_config "skl/1/3/8/9") 9 | include(${OPENCL_MT_TEST_DIR}/cmake/run_mt_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/simple_arg_int.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void SimpleArg(int src, __global int *dst) { 9 | int id = (int)get_global_id(0); 10 | dst[id] = src; 11 | } 12 | -------------------------------------------------------------------------------- /shared/source/helpers/get_info_status.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | enum class GetInfoStatus { 11 | INVALID_CONTEXT = -2, 12 | INVALID_VALUE = -1, 13 | SUCCESS = 0 14 | }; 15 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/metrics/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_query_pool_linux.cpp 9 | ) 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/helpers/ult_limits.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | constexpr uint32_t maxRootDeviceCount = 3u; 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/memory_manager/memory_manager_allocate_in_preferred_pool_tests.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/memory_manager/memory_manager_allocate_in_preferred_pool_tests.inl" 9 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen11/icllp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_ICLLP) 8 | set(mt_test_config "icllp/1/8/8/0") 9 | include(${OPENCL_MT_TEST_DIR}/cmake/run_mt_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /shared/source/compiler_interface/compiler_options/compiler_options.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/source/compiler_interface/compiler_options/compiler_options_base.h" 11 | -------------------------------------------------------------------------------- /shared/test/unit_test/page_fault_manager/default_asan_options.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | extern "C" { 9 | const char *__asan_default_options() { 10 | return "allow_user_segv_handler=1"; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /level_zero/experimental/test/unit_tests/sources/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} 8 | PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/events/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | add_subdirectories() 11 | -------------------------------------------------------------------------------- /opencl/source/helpers/base_object.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/helpers/base_object.h" 9 | 10 | namespace NEO { 11 | 12 | std::thread::id invalidThreadID; 13 | 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen11/icllp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_ICLLP) 8 | set(aub_test_config "icllp/1/8/8/0") 9 | include(${OPENCL_AUB_TEST_DIR}/cmake/run_aub_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen12lp/tgllp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_TGLLP) 8 | set(aub_test_config "tgllp/1/6/16/0") 9 | include(${OPENCL_AUB_TEST_DIR}/cmake/run_aub_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/gen12lp/tgllp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_TGLLP) 8 | set(mt_test_config "tgllp/1/6/16/0") 9 | include(${OPENCL_MT_TEST_DIR}/cmake/run_mt_test_target.cmake) 10 | endif() 11 | -------------------------------------------------------------------------------- /shared/test/unit_test/helpers/ult_hw_config.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/test/unit_test/helpers/ult_hw_config.h" 9 | 10 | namespace NEO { 11 | UltHwConfig ultHwConfig{}; 12 | } // namespace NEO 13 | -------------------------------------------------------------------------------- /driver_version.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #ifndef DRIVER_VERSION_H 9 | #define DRIVER_VERSION_H 10 | 11 | #cmakedefine NEO_OCL_DRIVER_VERSION ${NEO_OCL_DRIVER_VERSION} 12 | 13 | #endif /* DRIVER_VERSION_H */ 14 | -------------------------------------------------------------------------------- /level_zero/experimental/source/tracing/tracing_global_imp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | extern "C" { 11 | 12 | ZE_APIEXPORT ze_result_t ZE_APICALL 13 | zeInit_Tracing(ze_init_flags_t flags); 14 | } 15 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/engine/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/fan/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/memory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/pci/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/power/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/ras/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/scheduler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | add_subdirectories() 11 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/standby/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/temperature/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | add_subdirectories() 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/command_stream/thread_arbitration_policy_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | namespace NEO { 10 | uint32_t getNewKernelArbitrationPolicy(uint32_t policy); 11 | } // namespace NEO -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/fabric_port/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/firmware/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/frequency/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/global_operations/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | add_subdirectories() 11 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/xml_parser/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ) 10 | 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /shared/offline_compiler/source/utilities/safety_caller.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | namespace NEO { 10 | class OfflineCompiler; 11 | } 12 | 13 | extern int buildWithSafetyGuard(NEO::OfflineCompiler *compiler); -------------------------------------------------------------------------------- /opencl/source/os_interface/windows/ocl_reg_path.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/os_interface/ocl_reg_path.h" 9 | 10 | namespace NEO { 11 | const char *oclRegPath = "Software\\Intel\\IGFX\\OCL\\"; 12 | } 13 | -------------------------------------------------------------------------------- /scripts/build-fedora31-copr-docker.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2018-2019 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | git fetch -t 9 | git clone ../compute-runtime neo 10 | docker info 11 | docker build -f scripts/docker/Dockerfile-fedora-31-copr -t neo-fedora-31-copr:ci . 12 | -------------------------------------------------------------------------------- /scripts/build-fedora32-copr-docker.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2018-2020 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | git fetch -t 9 | git clone ../compute-runtime neo 10 | docker info 11 | docker build -f scripts/docker/Dockerfile-fedora-32-copr -t neo-fedora-32-copr:ci . 12 | -------------------------------------------------------------------------------- /level_zero/cmake/not_supported_platforms.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_NOT_SUPPORTED_PRODUCT_FAMILIES 8 | "IGFX_GEMINILAKE" 9 | "IGFX_BROXTON" 10 | "IGFX_LAKEFIELD" 11 | "IGFX_ELKHARTLAKE" 12 | "IGFX_BROADWELL" 13 | ) 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mocks/mock_async_event_handler.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/mocks/mock_async_event_handler.h" 9 | namespace MockAsyncEventHandlerGlobals { 10 | bool destructorCalled = false; 11 | } -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/shouldfail.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void shouldfail(global ushort *dst) { 9 | // idx and dummy are not defined, compiler should fail the build. 10 | dst[idx] = dummy; 11 | } 12 | -------------------------------------------------------------------------------- /shared/source/os_interface/windows/environment_variables.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | uint32_t getEnvironmentVariable(const char *name, char *outBuffer, uint32_t outBufferSize); 13 | -------------------------------------------------------------------------------- /level_zero/core/source/driver/driver_version.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #ifndef L0_DRIVER_VERSION_H 9 | #define L0_DRIVER_VERSION_H 10 | 11 | #define L0_DRIVER_VERSION @L0_DRIVER_VERSION@ 12 | 13 | #endif /* L0_DRIVER_VERSION_H */ 14 | -------------------------------------------------------------------------------- /level_zero/core/source/windows/registry_path.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/compiler_interface/l0_reg_path.h" 9 | 10 | namespace L0 { 11 | const char *registryPath = "Software\\Intel\\IGFX\\L0\\"; 12 | } 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/skl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_SKL) 8 | add_subdirectories() 9 | set(aub_test_config "skl/1/3/8/9") 10 | include(${OPENCL_AUB_TEST_DIR}/cmake/run_aub_test_target.cmake) 11 | endif() 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/os_interface/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | target_sources(igdrcl_mt_tests PRIVATE 9 | ${CMAKE_CURRENT_SOURCE_DIR}/linux/drm_memory_manager_mt_tests.cpp 10 | ) 11 | endif() 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/os_interface/windows/mock_environment_variables.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | 10 | extern uint32_t (*getEnvironmentVariableMock)(const char *name, char *outBuffer, uint32_t outBufferSize); 11 | -------------------------------------------------------------------------------- /shared/source/helpers/abort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/abort.h" 9 | 10 | #include 11 | 12 | namespace NEO { 13 | void abortExecution() { 14 | abort(); 15 | } 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/test/unit_test/built_ins/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/built_in_tests_shared.inl 10 | ) 11 | -------------------------------------------------------------------------------- /shared/test/unit_test/heap_assigner/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/heap_assigner_tests.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /shared/test/unit_test/helpers/default_hw_info.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/test/unit_test/helpers/default_hw_info.h" 9 | 10 | namespace NEO { 11 | 12 | std::unique_ptr defaultHwInfo; 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /level_zero/core/source/dll/disallow_deferred_deleter.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/deferred_deleter_helper.h" 9 | 10 | bool NEO::isDeferredDeleterEnabled() { 11 | return false; 12 | } // namespace NEO 13 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/mock.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | namespace L0 { 10 | namespace ult { 11 | 12 | template 13 | struct Mock : public Type {}; 14 | 15 | } // namespace ult 16 | } // namespace L0 17 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/context/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_context.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/device/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/event/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_event.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/fence/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_fence.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/image/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_image.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/kernel/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_kernel.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/memory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_memory.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/module/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_module.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/sampler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_sampler.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/source/dll/linux/ocl_release.exports: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | { 9 | global: 10 | clGetExtensionFunctionAddress; 11 | clIcdGetPlatformIDsKHR; 12 | clGetPlatformInfo; 13 | GTPin_Init; 14 | local: *; 15 | }; 16 | -------------------------------------------------------------------------------- /opencl/source/gen8/hw_info_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #ifdef SUPPORT_BDW 9 | #include "hw_info_bdw.inl" 10 | #endif 11 | 12 | namespace NEO { 13 | const char *GfxFamilyMapper::name = "Gen8"; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/source/os_interface/linux/device_caps_init_linux.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/cl_device/cl_device.h" 9 | 10 | namespace NEO { 11 | 12 | void ClDevice::initializeOsSpecificCaps() { 13 | } 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/helpers/test_debug_variables.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | DECLARE_DEBUG_VARIABLE(std::string, StringTestKey, "DefaultTestValue", "TestDescription") 9 | DECLARE_DEBUG_VARIABLE(int32_t, IntTestKey, 1, "TestDescription") 10 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/printf.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void test() { 9 | printf("OpenCL\n"); 10 | } 11 | 12 | __kernel void test_printf_number(__global uint* in) { 13 | printf("in[0] = %d\n", in[0]); 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/os_interface/os_environment.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | struct OsEnvironment { 12 | OsEnvironment() = default; 13 | virtual ~OsEnvironment() = default; 14 | }; 15 | } // namespace NEO -------------------------------------------------------------------------------- /shared/test/unit_test/indirect_heap/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/indirect_heap_tests.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/api/sysman/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_SYSMAN_API 8 | ${CMAKE_CURRENT_SOURCE_DIR}/ze_sysman_loader.cpp 9 | ${CMAKE_CURRENT_SOURCE_DIR}/zes_sysman.cpp 10 | ) 11 | set_property(GLOBAL PROPERTY L0_SYSMAN_API ${L0_SYSMAN_API}) 12 | -------------------------------------------------------------------------------- /opencl/source/program/additional_options.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/program/program.h" 9 | 10 | namespace NEO { 11 | void Program::applyAdditionalOptions(std::string &internalOptions) { 12 | } 13 | }; // namespace NEO 14 | -------------------------------------------------------------------------------- /shared/source/command_stream/queue_throttle.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | enum QueueThrottle : uint32_t { 13 | LOW, 14 | MEDIUM, 15 | HIGH 16 | }; 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /shared/source/helpers/completion_stamp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/completion_stamp.h" 9 | 10 | namespace NEO { 11 | 12 | const uint32_t CompletionStamp::notReady = 0xFFFFFFF0; 13 | 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/test/unit_test/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::UnitTests; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/test/unit_test/unified_memory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/unified_memory_tests.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/api/experimental/tracing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_EXPERIMENTAL_TRACING_API 8 | ${CMAKE_CURRENT_SOURCE_DIR}/zet_tracing.cpp 9 | ) 10 | 11 | set_property(GLOBAL PROPERTY L0_EXPERIMENTAL_TRACING_API ${L0_EXPERIMENTAL_TRACING_API}) 12 | -------------------------------------------------------------------------------- /level_zero/core/source/get_extension_function_lookup_map.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | namespace L0 { 12 | std::unordered_map getExtensionFunctionsLookupMap(); 13 | } // namespace L0 -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/fixtures/device_fixture.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" 9 | 10 | namespace L0 { 11 | namespace ult { 12 | 13 | } // namespace ult 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/abort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/abort.h" 9 | 10 | #include 11 | 12 | namespace NEO { 13 | void abortExecution() { 14 | throw std::exception(); 15 | } 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/mem_obj/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/create_image_aub_tests.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/sharings/gl/windows/gl_library_name.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | // above is workaround for copyright checker issue 10 | 11 | namespace Os { 12 | const char *openglDllName = "mock_opengl32.dll"; 13 | } 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/stateful_copy_buffer.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void StatefulCopyBuffer( 9 | const __global uchar* src, 10 | __global uchar* dst) 11 | { 12 | uint id = get_global_id(0); 13 | dst[id] = src[id]; 14 | } -------------------------------------------------------------------------------- /shared/source/command_stream/aub_subcapture_status.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | 12 | struct AubSubCaptureStatus { 13 | bool isActive; 14 | bool wasActiveInPreviousEnqueue; 15 | }; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/helpers/api_specific_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | namespace NEO { 10 | struct ApiSpecificConfig { 11 | static bool getHeapConfiguration(); 12 | static bool getBindlessConfiguration(); 13 | }; 14 | } // namespace NEO -------------------------------------------------------------------------------- /shared/source/helpers/populate_factory.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | 12 | // Method called by global factory enabler 13 | template 14 | void populateFactoryTable(); 15 | 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/test/unit_test/debug_settings/debug_manager.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_settings_manager.h" 9 | 10 | namespace NEO { 11 | DebugSettingsManager DebugManager(""); 12 | } 13 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/gen8/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN8) 8 | target_sources(${TARGET_NAME} PRIVATE 9 | ${COMPUTE_RUNTIME_ULT_GEN8} 10 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 11 | ) 12 | endif() 13 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/printf_handler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_printf_handler.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::UnitTests; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/aub_tests_configuration.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | struct AubTestsConfig { 11 | bool testCanonicalAddress; 12 | }; 13 | 14 | template 15 | AubTestsConfig GetAubTestsConfig(); 16 | -------------------------------------------------------------------------------- /opencl/test/unit_test/options_unit_tests.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | 10 | namespace NEO { 11 | const char *folderAUB = "aub_out"; 12 | 13 | uint32_t initialHardwareTag = static_cast(0xFFFFFF00); 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/source/compiler_interface/default_cache_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/source/compiler_interface/compiler_cache.h" 11 | 12 | namespace NEO { 13 | CompilerCacheConfig getDefaultCompilerCacheConfig(); 14 | } 15 | -------------------------------------------------------------------------------- /level_zero/core/source/helpers/l0_populate_factory.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace L0 { 11 | 12 | // Method called by global factory enabler 13 | template 14 | void populateFactoryTable(); 15 | 16 | } // namespace L0 17 | -------------------------------------------------------------------------------- /opencl/source/api/additional_extensions.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "config.h" 11 | #include 12 | 13 | namespace NEO { 14 | 15 | void *CL_API_CALL getAdditionalExtensionFunctionAddress(const char *funcName); 16 | } 17 | -------------------------------------------------------------------------------- /opencl/source/kernel/kernel_execution_type.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | enum class KernelExecutionType { 12 | Default = 0x0u, 13 | Concurrent = 0x1u, 14 | NotApplicable = 0x2u 15 | }; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::AubTests; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/config/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::UnitTests; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/linux/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::NotSpecified; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::UnitTests; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/preemption/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/preemption_tests.cpp 10 | ) 11 | 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/windows/test_mode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/test/unit_test/tests_configuration.h" 11 | 12 | namespace NEO { 13 | constexpr TestMode defaultTestMode = TestMode::UnitTests; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/source/kernel/grf_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace GrfConfig { 13 | constexpr uint32_t DefaultGrfNumber = 128u; 14 | constexpr uint32_t NotApplicable = 0u; 15 | } // namespace GrfConfig 16 | -------------------------------------------------------------------------------- /shared/test/unit_test/helpers/default_hw_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | #include 11 | 12 | namespace NEO { 13 | struct HardwareInfo; 14 | extern std::unique_ptr defaultHwInfo; 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /level_zero/tools/source/sysman/linux/xml_parser/xml_parser_stub.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "sysman/linux/xml_parser/xml_parser.h" 9 | 10 | namespace L0 { 11 | 12 | XmlParser *XmlParser::create() { 13 | return nullptr; 14 | } 15 | 16 | } // namespace L0 17 | -------------------------------------------------------------------------------- /shared/source/utilities/cpuintrinsics.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | namespace CpuIntrinsics { 12 | 13 | void clFlush(void const *ptr); 14 | 15 | void pause(); 16 | 17 | } // namespace CpuIntrinsics 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /level_zero/core/source/gen12lp/dg1/kernel_dg1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel_hw.h" 9 | 10 | namespace L0 { 11 | 12 | static KernelPopulateFactory> populateDG1; 13 | 14 | } // namespace L0 -------------------------------------------------------------------------------- /level_zero/core/source/kernel/kernel.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel.h" 9 | 10 | #include "igfxfmid.h" 11 | 12 | namespace L0 { 13 | 14 | KernelAllocatorFn kernelFactory[IGFX_MAX_PRODUCT] = {}; 15 | 16 | } // namespace L0 17 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/cmdqueue/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_cmdqueue.cpp 10 | ) 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /opencl/source/compiler_interface/default_cl_cache_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/source/compiler_interface/compiler_cache.h" 11 | 12 | namespace NEO { 13 | 14 | CompilerCacheConfig getDefaultClCompilerCacheConfig(); 15 | } 16 | -------------------------------------------------------------------------------- /opencl/source/gen12lp/sampler_gen12lp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen12lp/hw_cmds_base.h" 9 | using Family = NEO::TGLLPFamily; 10 | constexpr static auto gfxCore = IGFX_GEN12LP_CORE; 11 | #include "opencl/source/sampler/sampler_tgllp_plus.inl" 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/skl/command_queue/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/run_kernel_aub_tests_skl.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/device/gl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(WIN32) 8 | set(IGDRCL_SRCS_tests_device_gl 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_caps_gl_tests.cpp 10 | ) 11 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_device_gl}) 12 | endif() 13 | -------------------------------------------------------------------------------- /scripts/prepare-arch.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2018-2019 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | set -e 9 | set -x 10 | 11 | mkdir /root/build 12 | pacman -Suy --noconfirm gcc cmake git make pkg-config ninja libva \ 13 | intel-gmmlib intel-opencl-clang spirv-llvm-translator intel-graphics-compiler 14 | 15 | -------------------------------------------------------------------------------- /shared/source/commands/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_COMMANDS 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/bxml_generator_glue.h 10 | ) 11 | 12 | set_property(GLOBAL PROPERTY NEO_CORE_COMMANDS ${NEO_CORE_COMMANDS}) 13 | -------------------------------------------------------------------------------- /shared/source/gen11/hw_cmds.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #ifdef SUPPORT_ICLLP 10 | #include "hw_cmds_icllp.h" 11 | #endif 12 | #ifdef SUPPORT_LKF 13 | #include "hw_cmds_lkf.h" 14 | #endif 15 | #ifdef SUPPORT_EHL 16 | #include "hw_cmds_ehl.h" 17 | #endif 18 | -------------------------------------------------------------------------------- /shared/source/gen11/hw_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #ifdef SUPPORT_ICLLP 10 | #include "hw_info_icllp.h" 11 | #endif 12 | #ifdef SUPPORT_LKF 13 | #include "hw_info_lkf.h" 14 | #endif 15 | #ifdef SUPPORT_EHL 16 | #include "hw_info_ehl.h" 17 | #endif 18 | -------------------------------------------------------------------------------- /shared/test/unit_test/preemption/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/preemption_tests.cpp 10 | ) 11 | 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /level_zero/core/source/compiler_interface/default_l0_cache_config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "shared/source/compiler_interface/compiler_cache.h" 11 | 12 | namespace L0 { 13 | 14 | NEO::CompilerCacheConfig getDefaultL0CompilerCacheConfig(); 15 | } 16 | -------------------------------------------------------------------------------- /level_zero/core/source/dll/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_SRCS_DLL_LINUX 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_linux.cpp 10 | ) 11 | 12 | set_property(GLOBAL PROPERTY L0_SRCS_DLL_LINUX ${L0_SRCS_DLL_LINUX}) 13 | -------------------------------------------------------------------------------- /level_zero/core/source/gen9/cfl/kernel_cfl.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel_hw.h" 9 | 10 | namespace L0 { 11 | 12 | static KernelPopulateFactory> populateCFL; 13 | 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /level_zero/core/source/gen9/kbl/kernel_kbl.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel_hw.h" 9 | 10 | namespace L0 { 11 | 12 | static KernelPopulateFactory> populateKBL; 13 | 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /level_zero/core/source/gen9/skl/kernel_skl.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel_hw.h" 9 | 10 | namespace L0 { 11 | 12 | static KernelPopulateFactory> populateSKL; 13 | 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter_test.cpp 10 | ) 11 | 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/helper/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/heap_assigner_l0_tests.cpp 10 | ) 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen11/execution_model/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_parent_kernel_tests_gen11.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen8/execution_model/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_parent_kernel_tests_gen8.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/execution_model/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_parent_kernel_tests_gen9.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/cmd_parse/cmd_parse_gen12lp.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | size_t getAdditionalCommandLengthHwSpecific(void *cmd) { 9 | return 0; 10 | } 11 | 12 | const char *getAdditionalCommandNameHwSpecific(void *cmd) { 13 | return "UNKNOWN"; 14 | } 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/copybuffer.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void CopyBuffer(__global unsigned int *src, __global unsigned int *dst) { 9 | int id = (int)get_global_id(0); 10 | dst[id] = lgamma((float)src[id]); 11 | dst[id] = src[id]; 12 | } 13 | -------------------------------------------------------------------------------- /shared/source/aub_mem_dump/context_flags.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/aub_mem_dump/aub_mem_dump.h" 9 | 10 | namespace AubMemDump { 11 | void LrcaHelper::setContextSaveRestoreFlags(uint32_t &ctxSrCtlValue) const { 12 | } 13 | } // namespace AubMemDump 14 | -------------------------------------------------------------------------------- /shared/source/built_ins/builtinops/built_in_ops.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "shared/source/built_ins/built_in_ops_base.h" 10 | 11 | namespace NEO { 12 | namespace EBuiltInOps { 13 | constexpr Type MaxCoreValue{MaxBaseValue}; 14 | } 15 | } // namespace NEO -------------------------------------------------------------------------------- /shared/source/dll/options_dll.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | 10 | namespace NEO { 11 | // AUB file folder location 12 | const char *folderAUB = "."; 13 | 14 | // Initial value for HW tag 15 | uint32_t initialHardwareTag = 0; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/gmm_helper/windows/gmm_memory.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "gmm_memory.h" 9 | 10 | namespace NEO { 11 | GmmMemory *GmmMemory::create(GmmClientContext *gmmClientContext) { 12 | return new GmmMemory(gmmClientContext); 13 | } 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/source/helpers/timestamp_packet_extra.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/timestamp_packet.h" 9 | 10 | namespace NEO { 11 | void TimestampPacketHelper::overrideSupportedDevicesCount(uint32_t &numSupportedDevices) { 12 | } 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /shared/test/unit_test/direct_submission/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_tests.cpp 10 | ) 11 | 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /shared/test/unit_test/gen12lp/cmd_parse/cmd_parse_gen12lp.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | size_t getAdditionalCommandLengthHwSpecific(void *cmd) { 9 | return 0; 10 | } 11 | 12 | const char *getAdditionalCommandNameHwSpecific(void *cmd) { 13 | return "UNKNOWN"; 14 | } 15 | -------------------------------------------------------------------------------- /opencl/source/dll/create_tbx_sockets.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/tbx/tbx_sockets_imp.h" 9 | 10 | using namespace NEO; 11 | 12 | namespace NEO { 13 | TbxSockets *TbxSockets::create() { 14 | return new TbxSocketsImp; 15 | } 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/source/gen12lp/linux/hw_info_config_adls.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/hw_info.h" 9 | #include "shared/source/os_interface/hw_info_config.h" 10 | 11 | namespace NEO { 12 | template class HwInfoConfigHw; 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen12lp/execution_model/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_parent_kernel_tests_gen12lp.cpp 10 | ) 11 | -------------------------------------------------------------------------------- /opencl/test/unit_test/profiling/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_profiling 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/profiling_tests.cpp 10 | ) 11 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_profiling}) 12 | -------------------------------------------------------------------------------- /scripts/prepare-arch-clang.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (C) 2018-2019 Intel Corporation 4 | # 5 | # SPDX-License-Identifier: MIT 6 | # 7 | 8 | set -e 9 | set -x 10 | 11 | mkdir /root/build 12 | pacman -Suy --noconfirm clang cmake git make pkg-config ninja libva \ 13 | intel-gmmlib intel-opencl-clang spirv-llvm-translator intel-graphics-compiler 14 | 15 | -------------------------------------------------------------------------------- /shared/source/debug_settings/windows/debug_variables_helper.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_variables_helper.h" 9 | 10 | namespace NEO { 11 | 12 | bool isDebugKeysReadEnabled() { 13 | return false; 14 | } 15 | 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /third_party/aub_stream/headers/page_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2019 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | #pragma once 8 | namespace aub_stream { 9 | 10 | struct PageInfo { 11 | uint64_t physicalAddress; 12 | size_t size; 13 | bool isLocalMemory; 14 | uint32_t memoryBank; 15 | }; 16 | } // namespace aub_stream -------------------------------------------------------------------------------- /level_zero/core/source/dll/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_SRCS_DLL_WINDOWS 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_windows.cpp 10 | ) 11 | 12 | set_property(GLOBAL PROPERTY L0_SRCS_DLL_WINDOWS ${L0_SRCS_DLL_WINDOWS}) 13 | -------------------------------------------------------------------------------- /level_zero/core/source/gen11/icllp/kernel_icllp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel_hw.h" 9 | 10 | namespace L0 { 11 | 12 | static KernelPopulateFactory> populateICLLP; 13 | 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /opencl/source/gen8/linux/hw_info_config_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/hw_info_config.inl" 9 | #include "shared/source/os_interface/hw_info_config_bdw_plus.inl" 10 | 11 | #ifdef SUPPORT_BDW 12 | #include "hw_info_config_bdw.inl" 13 | #endif 14 | -------------------------------------------------------------------------------- /opencl/source/mem_obj/definitions/image_ext.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/mem_obj/image.h" 9 | 10 | namespace NEO { 11 | 12 | template 13 | void ImageHw::appendSurfaceStateExt(void *memory) { 14 | } 15 | 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/helpers/windows/gmm_callbacks.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | long(__stdcall *notifyAubCaptureImpl)(void *csrHandle, uint64_t gfxAddress, size_t gfxSize, bool allocate) = nullptr; 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /shared/source/utilities/heap_allocator.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/utilities/heap_allocator.h" 9 | 10 | namespace NEO { 11 | 12 | bool operator<(const HeapChunk &hc1, const HeapChunk &hc2) { 13 | return hc1.ptr < hc2.ptr; 14 | } 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /level_zero/core/source/gen12lp/tgllp/kernel_tgllp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/kernel/kernel_hw.h" 9 | 10 | namespace L0 { 11 | 12 | static KernelPopulateFactory> populateTGLLP; 13 | 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/memory_manager/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/compression_selector_l0_tests.cpp 10 | ) 11 | add_subdirectories() 12 | -------------------------------------------------------------------------------- /opencl/source/execution_model/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(RUNTIME_SRCS_EXECUTION_MODEL 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_enqueue.h 10 | ) 11 | 12 | target_sources(${NEO_STATIC_LIB_NAME} PRIVATE ${RUNTIME_SRCS_EXECUTION_MODEL}) 13 | -------------------------------------------------------------------------------- /opencl/source/mem_obj/buffer_factory_init.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | template <> 9 | void populateFactoryTable>() { 10 | extern BufferFactoryFuncs bufferFactory[IGFX_MAX_CORE]; 11 | bufferFactory[gfxCore].createBufferFunction = BufferHw::create; 12 | } 13 | -------------------------------------------------------------------------------- /opencl/source/mem_obj/definitions/buffer_ext.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/mem_obj/buffer.h" 9 | 10 | namespace NEO { 11 | 12 | template 13 | void BufferHw::appendSurfaceStateExt(void *memory) { 14 | } 15 | 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/helpers/static_size3.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | template 11 | struct StatickSize3 { 12 | operator const size_t *() { 13 | static const size_t v[] = {X, Y, Z}; 14 | return v; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mocks/mock_gmm_memory_base.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "mock_gmm_memory.h" 9 | 10 | namespace NEO { 11 | GmmMemory *GmmMemory::create(GmmClientContext *gmmClientContext) { 12 | return new MockGmmMemory(gmmClientContext); 13 | } 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/source/memory_manager/definitions/engine_limits.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | namespace EngineLimits { 13 | 14 | constexpr uint32_t maxHandleCount = 1u; 15 | 16 | }; // namespace EngineLimits 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/debugger/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | target_sources(${TARGET_NAME} PRIVATE 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/test_l0_debugger_linux.cpp 11 | ) 12 | endif() 13 | -------------------------------------------------------------------------------- /opencl/source/api/additional_extensions.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/api/additional_extensions.h" 9 | 10 | namespace NEO { 11 | void *CL_API_CALL getAdditionalExtensionFunctionAddress(const char *funcName) { 12 | return nullptr; 13 | } 14 | 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /opencl/test/unit_test/accelerators/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_accelerators 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/media_image_arg_tests.cpp 10 | ) 11 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_accelerators}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen8/aub_tests_configuration_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/aub_tests/aub_tests_configuration.inl" 9 | 10 | #include "hw_cmds.h" 11 | 12 | using namespace NEO; 13 | 14 | template AubTestsConfig GetAubTestsConfig(); 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/aub_tests_configuration_gen9.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/aub_tests/aub_tests_configuration.inl" 9 | 10 | #include "hw_cmds.h" 11 | 12 | using namespace NEO; 13 | 14 | template AubTestsConfig GetAubTestsConfig(); 15 | -------------------------------------------------------------------------------- /shared/source/built_ins/sip_kernel_type.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace NEO { 13 | 14 | enum class SipKernelType : std::uint32_t { 15 | Csr = 0, 16 | DbgCsr, 17 | DbgCsrLocal, 18 | COUNT 19 | }; 20 | 21 | } // namespace NEO 22 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/engine_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | 12 | struct EngineInfo { 13 | EngineInfo() = default; 14 | virtual ~EngineInfo() = 0; 15 | }; 16 | 17 | inline EngineInfo::~EngineInfo() {} 18 | 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/memory_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | 12 | struct MemoryInfo { 13 | MemoryInfo() = default; 14 | virtual ~MemoryInfo() = 0; 15 | }; 16 | 17 | inline MemoryInfo::~MemoryInfo(){}; 18 | 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /level_zero/core/source/module/module_extra_options.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/module/module_imp.h" 9 | 10 | namespace L0 { 11 | 12 | void ModuleImp::createBuildExtraOptions(std::string &apiOptions, std::string &nternalBuildOptions) { 13 | } 14 | 15 | } // namespace L0 -------------------------------------------------------------------------------- /opencl/source/guidelines/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(RUNTIME_CODING_GUIDELINES 8 | ${NEO_SOURCE_DIR}/GUIDELINES.md 9 | ) 10 | target_sources(${NEO_STATIC_LIB_NAME} PRIVATE ${RUNTIME_CODING_GUIDELINES}) 11 | set_property(GLOBAL PROPERTY RUNTIME_CODING_GUIDELINES ${RUNTIME_CODING_GUIDELINES}) 12 | -------------------------------------------------------------------------------- /opencl/source/sharings/gl/windows/include/gl_types.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/windows/windows_wrapper.h" 9 | 10 | #include 11 | 12 | #define OSAPI WINAPI 13 | 14 | typedef uint32_t GLType; 15 | typedef HDC GLDisplay; 16 | typedef HGLRC GLContext; 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen11/aub_tests_configuration_gen11.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/aub_tests/aub_tests_configuration.inl" 9 | 10 | #include "hw_cmds.h" 11 | 12 | using namespace NEO; 13 | 14 | template AubTestsConfig GetAubTestsConfig(); 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/copybuffer_with_header.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "simple_header.h" 9 | __kernel void 10 | CopyBuffer( 11 | __global unsigned int *src, 12 | __global unsigned int *dst) { 13 | int id = (int)get_global_id(0); 14 | dst[id] = src[id]; 15 | } 16 | -------------------------------------------------------------------------------- /shared/source/helpers/definitions/engine_group_types.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace NEO { 13 | 14 | enum class EngineGroupType : uint32_t { 15 | RenderCompute = 0, 16 | Compute, 17 | Copy, 18 | MaxEngineGroups 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /shared/source/memory_manager/eviction_status.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | 13 | enum class EvictionStatus : uint32_t { 14 | SUCCESS = 0, 15 | FAILED, 16 | NOT_APPLIED, 17 | UNKNOWN 18 | }; 19 | 20 | } // namespace NEO 21 | -------------------------------------------------------------------------------- /shared/source/os_interface/windows/wddm_allocation.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/windows/wddm_allocation.h" 9 | 10 | namespace NEO { 11 | std::string WddmAllocation::getAllocationInfoString() const { 12 | return getHandleInfoString(); 13 | } 14 | } // namespace NEO -------------------------------------------------------------------------------- /shared/source/utilities/directory.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | #include 11 | 12 | namespace NEO { 13 | 14 | class Directory { 15 | public: 16 | static std::vector getFiles(const std::string &path); 17 | }; 18 | }; // namespace NEO 19 | -------------------------------------------------------------------------------- /opencl/source/context/context_type.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | 13 | enum ContextType : uint32_t { 14 | CONTEXT_TYPE_DEFAULT, 15 | CONTEXT_TYPE_SPECIALIZED, 16 | CONTEXT_TYPE_UNRESTRICTIVE 17 | }; 18 | 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /opencl/source/dll/debug_manager.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_settings_manager.h" 9 | 10 | #include "opencl/source/os_interface/ocl_reg_path.h" 11 | 12 | namespace NEO { 13 | DebugSettingsManager DebugManager(oclRegPath); 14 | } 15 | -------------------------------------------------------------------------------- /opencl/source/sharings/unified/unified_enable_name.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/sharings/unified/enable_unified.h" 9 | 10 | namespace NEO { 11 | std::string UnifiedSharingBuilderFactory::getExtensions(DriverInfo *driverInfo) { 12 | return ""; 13 | } 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/sharings/gl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_sharings_gl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/gl_dll_helper.h 10 | ) 11 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_sharings_gl}) 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/ult_configuration.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "test_mode.h" 9 | 10 | namespace NEO { 11 | unsigned int ultIterationMaxTime = 45; 12 | bool useMockGmm = true; 13 | const char *executionDirectorySuffix = ""; 14 | TestMode testMode = defaultTestMode; 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /shared/source/debugger/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_DEBUGGER 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/debugger.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/debugger.h 11 | ) 12 | 13 | set_property(GLOBAL PROPERTY NEO_CORE_DEBUGGER ${NEO_CORE_DEBUGGER}) 14 | -------------------------------------------------------------------------------- /shared/source/gmm_helper/client_context/gmm_client_context.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "gmm_client_context.h" 9 | 10 | namespace NEO { 11 | GmmClientContext::GmmClientContext(OSInterface *osInterface, HardwareInfo *hwInfo) : GmmClientContextBase(osInterface, hwInfo){}; 12 | } // namespace NEO 13 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/fan/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | target_sources(${TARGET_NAME} 9 | PRIVATE 10 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 11 | ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_fan.cpp 12 | ) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/source/command_stream/per_dss_backed_buffer.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/command_stream/command_stream_receiver.h" 9 | 10 | namespace NEO { 11 | 12 | bool CommandStreamReceiver::createPerDssBackedBuffer(Device &device) { 13 | return true; 14 | } 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gmm_helper/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gmm_helper 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/gmm_helper_tests.cpp 10 | ) 11 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gmm_helper}) 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /shared/source/gen_common/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_GEN_COMMON 8 | ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/aub_mapper.h 9 | ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/reg_configs_common.h 10 | ) 11 | 12 | set_property(GLOBAL PROPERTY NEO_CORE_GEN_COMMON ${NEO_CORE_GEN_COMMON}) 13 | -------------------------------------------------------------------------------- /shared/source/helpers/pipeline_select_args.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | struct PipelineSelectArgs { 12 | bool specialPipelineSelectMode = false; 13 | bool mediaSamplerRequired = false; 14 | bool is3DPipelineRequired = false; 15 | }; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/indirect_heap/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_INDIRECT_HEAP 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/indirect_heap.h 10 | ) 11 | 12 | set_property(GLOBAL PROPERTY NEO_CORE_INDIRECT_HEAP ${NEO_CORE_INDIRECT_HEAP}) 13 | add_subdirectories() 14 | -------------------------------------------------------------------------------- /shared/test/unit_test/os_interface/windows/mock_gdi_interface.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/test/unit_test/os_interface/windows/mock_gdi_interface.h" 9 | 10 | namespace NEO { 11 | UINT64 MockGdi::pagingFenceReturnValue = 0x3ull; 12 | LUID MockGdi::adapterLuidToReturn{}; 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /level_zero/tools/source/metrics/linux/os_metric_enumeration_imp_linux.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/tools/source/metrics/metric_enumeration_imp.h" 9 | 10 | namespace L0 { 11 | 12 | const char *MetricEnumeration::getMetricsDiscoveryFilename() { return "libmd.so"; } 13 | 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/bxt/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen9_bxt 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen9_bxt}) 12 | -------------------------------------------------------------------------------- /shared/source/built_ins/kernels/aux_translation.builtin_kernel: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | R"===( 9 | __kernel void fullCopy(__global const uint* src, __global uint* dst) { 10 | unsigned int gid = get_global_id(0); 11 | uint4 loaded = vload4(gid, src); 12 | vstore4(loaded, gid, dst); 13 | } 14 | )===" 15 | -------------------------------------------------------------------------------- /shared/source/gmm_helper/gmm_lib.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #ifdef WIN32 10 | #include "shared/source/os_interface/windows/windows_wrapper.h" 11 | 12 | #else 13 | #ifndef C_ASSERT 14 | #define C_ASSERT(e) static_assert(e, #e) 15 | #endif 16 | #define __stdcall 17 | #endif 18 | #include "GmmLib.h" 19 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/flags/drm_query_flags.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace NEO { 13 | namespace DrmQueryItemFlags { 14 | constexpr uint32_t empty = 0; 15 | constexpr uint32_t topology = 0; 16 | } // namespace DrmQueryItemFlags 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /shared/source/os_interface/windows/wddm_additional_context_flags.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/windows/wddm/wddm.h" 9 | 10 | namespace NEO { 11 | void Wddm::applyAdditionalContextFlags(CREATECONTEXT_PVTDATA &privateData, OsContextWin &osContext) { 12 | } 13 | } // namespace NEO 14 | -------------------------------------------------------------------------------- /shared/test/unit_test/gen9/skl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_TESTS_GEN9_SKL 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_skl.cpp 10 | ) 11 | set_property(GLOBAL PROPERTY NEO_CORE_TESTS_GEN9_SKL ${NEO_CORE_TESTS_GEN9_SKL}) 12 | add_subdirectories() 13 | -------------------------------------------------------------------------------- /shared/test/unit_test/image/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_fixture.h 10 | ${CMAKE_CURRENT_SOURCE_DIR}/image_surface_state_tests.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /level_zero/core/source/dll/windows/debugger_l0_windows.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/debugger/debugger_l0.h" 9 | 10 | namespace L0 { 11 | std::unique_ptr DebuggerL0::create(NEO::Device *device) { 12 | return std::unique_ptr(nullptr); 13 | } 14 | } // namespace L0 -------------------------------------------------------------------------------- /level_zero/core/test/unit_tests/sources/driver/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/host_pointer_manager_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/test_driver.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /level_zero/tools/source/sysman/ras/linux/udev/99-drm_ze_intel_gpu.rules: -------------------------------------------------------------------------------- 1 | # 2 | ## Copyright (C) 2020 Intel Corporation 3 | ## 4 | ## SPDX-License-Identifier: MIT 5 | ## 6 | # 7 | 8 | ACTION=="change", \ 9 | SUBSYSTEM=="drm", \ 10 | ENV{RESET}=="1", \ 11 | RUN+="/bin/sh -c 'val=`cat /var/lib/libze_intel_gpu/ras_reset_count` && newval=`expr $val + 1` && echo $newval > /var/lib/libze_intel_gpu/ras_reset_count'" 12 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/events/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(WIN32) 8 | target_sources(${TARGET_NAME} 9 | PRIVATE 10 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 11 | ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_events.cpp 12 | ) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/source/dll/create_deferred_deleter.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/memory_manager/deferred_deleter.h" 9 | 10 | namespace NEO { 11 | std::unique_ptr createDeferredDeleter() { 12 | return std::unique_ptr(new DeferredDeleter()); 13 | } 14 | } // namespace NEO -------------------------------------------------------------------------------- /opencl/source/mem_obj/image_factory_init.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | template class ImageHw; 9 | template <> 10 | void populateFactoryTable>() { 11 | extern ImageFactoryFuncs imageFactory[IGFX_MAX_CORE]; 12 | imageFactory[gfxCore].createImageFunction = ImageHw::create; 13 | } 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/dg1/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen12_dg1 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_dg1.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen12_dg1}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen8/bdw/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen8_bdw 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_bdw.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen8_bdw}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/cfl/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen9_cfl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_cfl.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen9_cfl}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/glk/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen9_glk 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_glk.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen9_glk}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/kbl/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen9_kbl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_kbl.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen9_kbl}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/skl/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen9_skl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_skl.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen9_skl}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/libult/debug_manager.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_settings_manager.h" 9 | 10 | #include "opencl/source/os_interface/ocl_reg_path.h" 11 | 12 | namespace NEO { 13 | DebugSettingsManager DebugManager(oclRegPath); 14 | } 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/CopyBuffer_simd16.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __attribute__((intel_reqd_sub_group_size(16))) 9 | __kernel void 10 | CopyBuffer( 11 | __global unsigned int* src, 12 | __global unsigned int* dst ) 13 | { 14 | int id = (int)get_global_id(0); 15 | dst[id] = src[id]; 16 | } 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/CopyBuffer_simd32.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __attribute__((intel_reqd_sub_group_size(32))) 9 | __kernel void 10 | CopyBuffer( 11 | __global unsigned int* src, 12 | __global unsigned int* dst ) 13 | { 14 | int id = (int)get_global_id(0); 15 | dst[id] = src[id]; 16 | } 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/CopyBuffer_simd8.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __attribute__((intel_reqd_sub_group_size(8))) 9 | __kernel void 10 | CopyBuffer( 11 | __global unsigned int* src, 12 | __global unsigned int* dst ) 13 | { 14 | int id = (int)get_global_id(0); 15 | dst[id] = src[id]; 16 | } 17 | -------------------------------------------------------------------------------- /shared/source/helpers/timestamp_offsets.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #define KERNEL_TIMESTAMP_EVENT_GLOBAL_START_OFFSET (1) 11 | #define KERNEL_TIMESTAMP_EVENT_GLOBAL_END_OFFSET (3) 12 | #define KERNEL_TIMESTAMP_EVENT_CONTEXT_START_OFFSET (0) 13 | #define KERNEL_TIMESTAMP_EVENT_CONTEXT_END_OFFSET (2) 14 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/drm_engine_mapper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "engine_node.h" 11 | 12 | namespace NEO { 13 | 14 | class DrmEngineMapper { 15 | public: 16 | static unsigned int engineNodeMap(aub_stream::EngineType engineType); 17 | }; 18 | 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /level_zero/core/source/debugger/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_SRCS_DEBUGGER_LINUX 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_linux.cpp 10 | ) 11 | 12 | if(UNIX) 13 | set_property(GLOBAL PROPERTY L0_SRCS_DEBUGGER_LINUX ${L0_SRCS_DEBUGGER_LINUX}) 14 | endif() 15 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/firmware/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | target_sources(${TARGET_NAME} 9 | PRIVATE 10 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 11 | ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_firmware.cpp 12 | ) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/source/command_queue/flush.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | template 12 | cl_int CommandQueueHw::flush() { 13 | return getGpgpuCommandStreamReceiver().flushBatchedSubmissions() ? CL_SUCCESS : CL_OUT_OF_RESOURCES; 14 | } 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /opencl/source/helpers/built_ins_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "shared/source/built_ins/built_ins.h" 10 | #include "shared/source/program/program_info.h" 11 | 12 | namespace NEO { 13 | class Device; 14 | 15 | void initSipKernel(SipKernelType type, Device &device); 16 | 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /opencl/test/unit_test/execution_environment/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_execution_environment 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/execution_environment_tests.cpp 10 | ) 11 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_execution_environment}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/ehl/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen11_ehl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_ehl.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen11_ehl}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/lkf/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen11_lkf 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_lkf.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen11_lkf}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/adls/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen12_adls 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_adls.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen12_adls}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/rkl/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen12_rkl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_rkl.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen12_rkl}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen8/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen8_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/gmm_callbacks_tests_gen8.cpp 10 | ) 11 | if(WIN32) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen8_windows}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/gmm_callbacks_tests_gen9.cpp 10 | ) 11 | if(WIN32) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_windows}) 13 | endif() 14 | -------------------------------------------------------------------------------- /shared/source/kernel/debug_data.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace NEO { 13 | struct DebugData { 14 | uint32_t vIsaSize = 0; 15 | uint32_t genIsaSize = 0; 16 | const char *vIsa = nullptr; 17 | const char *genIsa = nullptr; 18 | }; 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /shared/test/unit_test/command_container/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/command_container_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/command_encoder_tests.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /shared/test/unit_test/memory_manager/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(${TARGET_NAME} PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/multi_graphics_allocation_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/special_heap_pool_tests.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /level_zero/core/source/additional_kernel_properties.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/device/device_imp.h" 9 | 10 | namespace L0 { 11 | 12 | void DeviceImp::processAdditionalKernelProperties(NEO::HwHelper &hwHelper, ze_device_module_properties_t *pKernelProperties) { 13 | } 14 | } // namespace L0 15 | -------------------------------------------------------------------------------- /level_zero/tools/source/pin/linux/os_pin.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "level_zero/tools/source/pin/pin.h" 11 | 12 | namespace L0 { 13 | 14 | typedef uint32_t (*OpenGTPin_fn)(void *gtPinInit); 15 | 16 | const std::string PinContext::gtPinLibraryFilename = "libgtpin.so"; 17 | 18 | } // namespace L0 19 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub/aub_helper_tests.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/aub/aub_helper_tests.inl" 9 | 10 | TEST(AubHelper, GivenHwInfoWhenGetMemBankSizeIsCalledThenItReturnsCorrectValue) { 11 | EXPECT_EQ(2 * MemoryConstants::gigaByte, AubHelper::getMemBankSize(defaultHwInfo.get())); 12 | } 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/icllp/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen11_icllp 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_icllp.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen11_icllp}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen11_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/gmm_callbacks_tests_gen11.cpp 10 | ) 11 | if(WIN32) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen11_windows}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/sharings/d3d/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(WIN32) 8 | set(IGDRCL_SRCS_tests_sharings_d3d 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/context_d3d_tests.cpp 11 | ) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_sharings_d3d}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/simple_kernels_opts.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void SimpleArg(int src, __global int *dst) { 9 | int id = (int)get_global_id(0); 10 | 11 | #ifdef DEF_WAS_SPECIFIED 12 | int val = 1; 13 | #else 14 | // fail to compile 15 | #endif 16 | 17 | dst[id] = src + val; 18 | } 19 | -------------------------------------------------------------------------------- /opencl/test/unit_test/test_files/test_basic_constant.cl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | __kernel void constant_kernel(__global float *out, __constant float *tmpF, __constant int *tmpI) { 9 | int tid = get_global_id(0); 10 | 11 | float ftmp = tmpF[tid]; 12 | float Itmp = tmpI[tid]; 13 | out[tid] = ftmp * Itmp; 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/debug_settings/definitions/translate_debug_settings.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | 12 | struct DebugVariables; 13 | 14 | inline void translateDebugSettingsBase(DebugVariables &) { 15 | } 16 | 17 | void translateDebugSettings(DebugVariables &); 18 | 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /shared/source/memory_manager/definitions/storage_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | namespace NEO { 11 | struct StorageInfo { 12 | uint32_t getNumBanks() const; 13 | uint32_t getMemoryBanks() const { return 0u; } 14 | bool multiStorage = false; 15 | }; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /level_zero/core/source/debugger/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_SRCS_DEBUGGER_WINDOWS 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/debugger_l0_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | set_property(GLOBAL PROPERTY L0_SRCS_DEBUGGER_WINDOWS ${L0_SRCS_DEBUGGER_WINDOWS}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/batch_buffer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_batch_buffer_tests.h 10 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_batch_buffer_tests.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/tgllp/linux/dll/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_linux_dll_tests_gen12lp_tgllp 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/device_id_tests_tgllp.cpp 10 | ) 11 | target_sources(igdrcl_linux_dll_tests PRIVATE ${IGDRCL_SRCS_linux_dll_tests_gen12lp_tgllp}) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/helpers/kernel_binary_helper_hash_value.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/helpers/kernel_binary_helper.h" 9 | 10 | const std::string KernelBinaryHelper::BUILT_INS("17475704436818206941"); 11 | const std::string KernelBinaryHelper::BUILT_INS_WITH_IMAGES("13936718464051189346_images"); 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/device_queue/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_mt_tests_device_queue 8 | # local files 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/device_queue_mt_tests.cpp 11 | ) 12 | target_sources(igdrcl_mt_tests PRIVATE ${IGDRCL_SRCS_mt_tests_device_queue}) 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/platform/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_platform 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/platform_icd_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/platform_tests.cpp 11 | ) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_platform}) 13 | -------------------------------------------------------------------------------- /level_zero/api/tools/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(L0_TOOLS_API 8 | ${CMAKE_CURRENT_SOURCE_DIR}/ze_tools_loader.cpp 9 | ${CMAKE_CURRENT_SOURCE_DIR}/zet_debug.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/zet_metric.cpp 11 | ${CMAKE_CURRENT_SOURCE_DIR}/zet_module.cpp 12 | ) 13 | set_property(GLOBAL PROPERTY L0_TOOLS_API ${L0_TOOLS_API}) 14 | -------------------------------------------------------------------------------- /level_zero/core/source/debugger/debug_manager.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_settings_manager.h" 9 | 10 | #include "level_zero/core/source/compiler_interface/l0_reg_path.h" 11 | 12 | namespace NEO { 13 | DebugSettingsManager DebugManager(L0::registryPath); 14 | } 15 | -------------------------------------------------------------------------------- /level_zero/core/source/gen8/debugger_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/debugger/debugger_l0.inl" 9 | 10 | namespace NEO { 11 | 12 | struct BDWFamily; 13 | using GfxFamily = BDWFamily; 14 | 15 | } // namespace NEO 16 | 17 | namespace L0 { 18 | template class DebuggerL0Hw; 19 | } // namespace L0 -------------------------------------------------------------------------------- /level_zero/tools/source/pin/windows/os_pin.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "level_zero/tools/source/pin/pin.h" 11 | 12 | namespace L0 { 13 | 14 | typedef uint32_t(__fastcall *OpenGTPin_fn)(void *gtPinInit); 15 | 16 | const std::string PinContext::gtPinLibraryFilename = "gtpin.dll"; 17 | 18 | } // namespace L0 19 | -------------------------------------------------------------------------------- /opencl/source/gen12lp/windows/gmm_callbacks_gen12lp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen12lp/hw_cmds.h" 9 | 10 | #include "opencl/source/helpers/windows/gmm_callbacks_tgllp_plus.inl" 11 | 12 | using namespace NEO; 13 | 14 | template struct DeviceCallbacks; 15 | template struct TTCallbacks; 16 | -------------------------------------------------------------------------------- /opencl/source/helpers/cl_device_helpers.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/helpers/cl_device_helpers.h" 9 | 10 | namespace NEO { 11 | void ClDeviceHelper::getExtraDeviceInfo(const ClDevice &clDevice, cl_device_info paramName, cl_uint ¶m, const void *&src, size_t &size, size_t &retSize) {} 12 | } // namespace NEO 13 | -------------------------------------------------------------------------------- /opencl/source/helpers/helper_options.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | namespace NEO { 12 | // AUB file folder location 13 | const char *folderAUB = "."; 14 | 15 | // Initial value for HW tag 16 | uint32_t initialHardwareTag = std::numeric_limits::max(); 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/unified_memory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/unified_memory_aub_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/unified_memory_copy_aub_tests.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/dg1/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen12_dg1_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_dg1.cpp 10 | ) 11 | if(WIN32) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12_dg1_windows}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/perf_tests/api/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_perf_tests_api 8 | "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt" 9 | "${CMAKE_CURRENT_SOURCE_DIR}/api_tests.cpp" 10 | "${CMAKE_CURRENT_SOURCE_DIR}/api_tests.h" 11 | "${CMAKE_CURRENT_SOURCE_DIR}/context_tests.cpp" 12 | PARENT_SCOPE 13 | ) 14 | -------------------------------------------------------------------------------- /shared/source/command_stream/definitions/csr_properties_flags.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace NEO { 12 | namespace AdditionalKernelExecInfo { 13 | constexpr uint32_t NotSet = 1u; 14 | constexpr uint32_t NotApplicable = 2u; 15 | } // namespace AdditionalKernelExecInfo 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/gen12lp/hw_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #ifdef SUPPORT_TGLLP 10 | #include "hw_info_tgllp.h" 11 | #endif 12 | #ifdef SUPPORT_DG1 13 | #include "hw_info_dg1.h" 14 | #endif 15 | #ifdef SUPPORT_RKL 16 | #include "hw_info_rkl.h" 17 | #endif 18 | #ifdef SUPPORT_ADLS 19 | #include "hw_info_adls.h" 20 | #endif 21 | -------------------------------------------------------------------------------- /shared/source/gen8/enable_hw_info_config_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen8/hw_cmds.h" 9 | #include "shared/source/os_interface/hw_info_config.h" 10 | 11 | namespace NEO { 12 | 13 | #ifdef SUPPORT_BDW 14 | static EnableProductHwInfoConfig enableBDW; 15 | #endif 16 | 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /shared/source/helpers/simd_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | template 12 | constexpr typename WALKER_TYPE::SIMD_SIZE getSimdConfig(uint32_t simdSize) { 13 | return static_cast((simdSize == 1) ? (32 >> 4) : (simdSize >> 4)); 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/os_interface/hw_info_config_bdw_plus.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/hw_info_config.h" 9 | 10 | namespace NEO { 11 | template 12 | uint64_t HwInfoConfigHw::getCrossDeviceSharedMemCapabilities() { 13 | return 0; 14 | } 15 | 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/hw_device_id_linux.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/linux/hw_device_id.h" 9 | #include "shared/source/os_interface/linux/sys_calls.h" 10 | 11 | namespace NEO { 12 | 13 | HwDeviceId::~HwDeviceId() { 14 | SysCalls::close(fileDescriptor); 15 | } 16 | 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/sys_calls.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | namespace SysCalls { 12 | int close(int fileDescriptor); 13 | int open(const char *file, int flags); 14 | int ioctl(int fileDescriptor, unsigned long int request, void *arg); 15 | } // namespace SysCalls 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/test/unit_test/preamble/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_PREAMBLE_TESTS 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/preamble_fixture.h 10 | ${CMAKE_CURRENT_SOURCE_DIR}/preamble_tests.cpp 11 | ) 12 | set_property(GLOBAL PROPERTY NEO_CORE_PREAMBLE_TESTS ${NEO_CORE_PREAMBLE_TESTS}) 13 | -------------------------------------------------------------------------------- /opencl/source/helpers/cl_hw_helper.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/helpers/cl_hw_helper.h" 9 | 10 | namespace NEO { 11 | 12 | ClHwHelper *clHwHelperFactory[IGFX_MAX_CORE] = {}; 13 | 14 | ClHwHelper &ClHwHelper::get(GFXCORE_FAMILY gfxCore) { 15 | return *clHwHelperFactory[gfxCore]; 16 | } 17 | 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen11/batch_buffer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_batch_buffer_tests_gen11.h 10 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_batch_buffer_tests_gen11.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/built_ins/built_ins_file_names.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | #pragma once 12 | 13 | namespace NEO { 14 | std::vector getBuiltInFileNames(bool imagesSupport); 15 | std::string getBuiltInHashFileName(uint64_t hash, bool imagesSupport); 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/offline_compiler/source/ocloc_validator.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | #include 12 | 13 | class OclocArgHelper; 14 | 15 | namespace NEO { 16 | namespace Ocloc { 17 | 18 | int validate(const std::vector &args, OclocArgHelper *argHelper); 19 | } 20 | 21 | } // namespace NEO 22 | -------------------------------------------------------------------------------- /shared/source/built_ins/builtinops/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(NEO_CORE_SRCS_BUILT_INS_OPS 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/built_in_ops.h 10 | ) 11 | add_subdirectories() 12 | 13 | set_property(GLOBAL PROPERTY NEO_CORE_SRCS_BUILT_INS_OPS ${NEO_CORE_SRCS_BUILT_INS_OPS}) 14 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/drm_buffer_object_extended.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/linux/drm_buffer_object.h" 9 | 10 | namespace NEO { 11 | 12 | void BufferObject::fillExecObjectImpl(drm_i915_gem_exec_object2 &execObject, OsContext *osContext, uint32_t vmHandleId) {} 13 | 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /level_zero/core/source/get_extension_function_lookup_map.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/get_extension_function_lookup_map.h" 9 | 10 | namespace L0 { 11 | std::unordered_map getExtensionFunctionsLookupMap() { 12 | return std::unordered_map(); 13 | } 14 | 15 | } // namespace L0 -------------------------------------------------------------------------------- /opencl/source/gen8/command_stream_receiver_simulated_common_hw_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/command_stream/command_stream_receiver_simulated_common_hw_bdw_plus.inl" 9 | 10 | namespace NEO { 11 | typedef BDWFamily Family; 12 | 13 | template class CommandStreamReceiverSimulatedCommonHw; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/source/gen9/command_stream_receiver_simulated_common_hw_gen9.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/command_stream/command_stream_receiver_simulated_common_hw_bdw_plus.inl" 9 | 10 | namespace NEO { 11 | typedef SKLFamily Family; 12 | 13 | template class CommandStreamReceiverSimulatedCommonHw; 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_mem_dump/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_aub_mem_dump_tests 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_alloc_dump_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/lrca_helper_tests.cpp 11 | ) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_aub_mem_dump_tests}) 13 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen9/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(TESTS_GEN9) 8 | target_sources(igdrcl_aub_tests PRIVATE 9 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_tests_configuration_gen9.cpp 10 | ${NEO_SOURCE_DIR}/opencl/test/unit_test/gen9/unit_test_helper_gen9.cpp 11 | ) 12 | add_subdirectories() 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/context/gl/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(WIN32) 8 | set(IGDRCL_SRCS_tests_context_gl_windows 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/context_gl_tests_windows.cpp 11 | ) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_context_gl_windows}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen8/bdw/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen8_bdw_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_bdw_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen8_bdw_windows}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/bxt/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_bxt_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_bxt_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_bxt_windows}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/cfl/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_cfl_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_cfl_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_cfl_windows}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/glk/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_glk_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_glk_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_glk_windows}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/kbl/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_kbl_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_kbl_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_kbl_windows}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/skl/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_skl_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_skl_windows.cpp 10 | ) 11 | 12 | if(WIN32) 13 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_skl_windows}) 14 | endif() 15 | -------------------------------------------------------------------------------- /shared/source/gen11/hw_info_gen11.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "shared/source/helpers/hw_info.h" 10 | 11 | namespace NEO { 12 | 13 | struct ICLFamily; 14 | 15 | template <> 16 | struct GfxFamilyMapper { 17 | typedef ICLFamily GfxFamily; 18 | static const char *name; 19 | }; 20 | } // namespace NEO 21 | -------------------------------------------------------------------------------- /shared/source/gen8/hw_info_gen8.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "shared/source/helpers/hw_info.h" 10 | 11 | namespace NEO { 12 | 13 | struct BDWFamily; 14 | 15 | template <> 16 | struct GfxFamilyMapper { 17 | typedef BDWFamily GfxFamily; 18 | static const char *name; 19 | }; 20 | } // namespace NEO 21 | -------------------------------------------------------------------------------- /shared/source/gen8/state_base_address_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/state_base_address.h" 9 | #include "shared/source/helpers/state_base_address_bdw.inl" 10 | #include "shared/source/helpers/state_base_address_bdw_plus.inl" 11 | 12 | namespace NEO { 13 | template struct StateBaseAddressHelper; 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/gen9/hw_info_gen9.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "shared/source/helpers/hw_info.h" 10 | 11 | namespace NEO { 12 | 13 | struct SKLFamily; 14 | 15 | template <> 16 | struct GfxFamilyMapper { 17 | typedef SKLFamily GfxFamily; 18 | static const char *name; 19 | }; 20 | } // namespace NEO 21 | -------------------------------------------------------------------------------- /shared/source/os_interface/linux/os_inc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #define PATH_SEPARATOR '/' 11 | #define __cdecl 12 | namespace Os { 13 | // Pci Path 14 | extern const char *sysFsPciPathPrefix; 15 | extern const char *pciDevicesDirectory; 16 | // Proc Path 17 | extern const char *sysFsProcPathPrefix; 18 | } // namespace Os 19 | -------------------------------------------------------------------------------- /shared/source/os_interface/os_thread.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | namespace NEO { 11 | 12 | class Thread { 13 | public: 14 | static std::unique_ptr create(void *(*func)(void *), void *arg); 15 | virtual void join() = 0; 16 | virtual ~Thread() = default; 17 | }; 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /level_zero/core/source/linux/driver_teardown.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/driver/driver_handle_imp.h" 9 | 10 | using namespace L0; 11 | 12 | void __attribute__((destructor)) driverHandleDestructor() { 13 | if (GlobalDriver != nullptr) { 14 | delete GlobalDriver; 15 | GlobalDriver = nullptr; 16 | } 17 | } -------------------------------------------------------------------------------- /opencl/source/gtpin/gtpin_hw_helper.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/gtpin/gtpin_hw_helper.h" 9 | 10 | namespace NEO { 11 | GTPinHwHelper *gtpinHwHelperFactory[IGFX_MAX_CORE] = {}; 12 | 13 | GTPinHwHelper >PinHwHelper::get(GFXCORE_FAMILY gfxCore) { 14 | return *gtpinHwHelperFactory[gfxCore]; 15 | } 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/gen12lp/batch_buffer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | target_sources(igdrcl_aub_tests PRIVATE 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_batch_buffer_tests_gen12lp.h 10 | ${CMAKE_CURRENT_SOURCE_DIR}/aub_batch_buffer_tests_gen12lp.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /opencl/test/unit_test/fixtures/built_in_fixture.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | class BuiltIns; 12 | class Device; 13 | } // namespace NEO 14 | 15 | class BuiltInFixture { 16 | public: 17 | void SetUp(NEO::Device *pDevice); 18 | void TearDown(); 19 | 20 | NEO::BuiltIns *pBuiltIns = nullptr; 21 | }; 22 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/bxt/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_bxt_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_bxt_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/libult/os_interface.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/os_interface/os_interface.h" 9 | 10 | #include "shared/source/helpers/constants.h" 11 | 12 | namespace NEO { 13 | 14 | bool OSInterface::osEnableLocalMemory = true; 15 | 16 | void OSInterface::setGmmInputArgs(void *args) {} 17 | 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mocks/mock_sharing_factory.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/source/sharings/sharing_factory.h" 9 | 10 | class SharingFactoryMock : public NEO::SharingFactory { 11 | public: 12 | using NEO::SharingFactory::sharings; 13 | 14 | SharingFactoryMock() = default; 15 | ~SharingFactoryMock() = default; 16 | }; 17 | -------------------------------------------------------------------------------- /shared/source/gen9/state_base_address_gen9.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/state_base_address.h" 9 | #include "shared/source/helpers/state_base_address_bdw_plus.inl" 10 | #include "shared/source/helpers/state_base_address_skl_plus.inl" 11 | 12 | namespace NEO { 13 | template struct StateBaseAddressHelper; 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/helpers/extendable_enum.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | struct ExtendableEnum { 13 | constexpr operator uint32_t() const { 14 | return value; 15 | } 16 | 17 | constexpr ExtendableEnum(uint32_t val) : value(val) {} 18 | 19 | protected: 20 | uint32_t value; 21 | }; 22 | -------------------------------------------------------------------------------- /third_party/aub_stream/headers/engine_node.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2019 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | 11 | namespace aub_stream { 12 | 13 | enum EngineType : uint32_t { 14 | ENGINE_RCS = 0, 15 | ENGINE_BCS, 16 | ENGINE_VCS, 17 | ENGINE_VECS, 18 | ENGINE_CCS, 19 | NUM_ENGINES 20 | }; 21 | 22 | } // namespace aub_stream 23 | -------------------------------------------------------------------------------- /level_zero/core/source/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | set(L0_SOURCES_LINUX 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/registry_path.cpp 11 | ${CMAKE_CURRENT_SOURCE_DIR}/driver_teardown.cpp 12 | ) 13 | set_property(GLOBAL PROPERTY L0_SOURCES_LINUX ${L0_SOURCES_LINUX}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/source/dll/source_level_debugger_dll.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/source_level_debugger/source_level_debugger.h" 9 | 10 | namespace NEO { 11 | 12 | OsLibrary *SourceLevelDebugger::loadDebugger() { 13 | return OsLibrary::load(OsLibrary::createFullSystemPath(SourceLevelDebugger::dllName)); 14 | } 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /opencl/source/gen8/buffer_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen8/hw_cmds.h" 9 | 10 | #include "opencl/source/mem_obj/buffer_base.inl" 11 | 12 | namespace NEO { 13 | 14 | typedef BDWFamily Family; 15 | static auto gfxCore = IGFX_GEN8_CORE; 16 | 17 | #include "opencl/source/mem_obj/buffer_factory_init.inl" 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /opencl/source/gen9/buffer_gen9.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen9/hw_cmds.h" 9 | 10 | #include "opencl/source/mem_obj/buffer_base.inl" 11 | 12 | namespace NEO { 13 | 14 | typedef SKLFamily Family; 15 | static auto gfxCore = IGFX_GEN9_CORE; 16 | 17 | #include "opencl/source/mem_obj/buffer_factory_init.inl" 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /opencl/source/sharings/sharing_factory.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "opencl/source/sharings/sharing_factory.h" 10 | 11 | namespace NEO { 12 | 13 | template 14 | SharingFactory::RegisterSharing::RegisterSharing() { 15 | sharingContextBuilder[T::sharingId] = new F; 16 | }; 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /opencl/test/unit_test/api/cl_unload_compiler_tests.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "test.h" 9 | 10 | using namespace NEO; 11 | 12 | namespace ULT { 13 | 14 | TEST(clUnloadCompilerTests, WhenUnloadingCompilerThenSuccessIsReturned) { 15 | auto retVal = clUnloadCompiler(); 16 | EXPECT_EQ(CL_SUCCESS, retVal); 17 | } 18 | 19 | } // namespace ULT 20 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/dg1/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen12_dg1_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_dg1.cpp 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12_dg1_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen8/bdw/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen8_bdw_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_bdw.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen8_bdw_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen8/unit_test_helper_gen8.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen8/hw_info.h" 9 | 10 | #include "opencl/test/unit_test/helpers/unit_test_helper.h" 11 | #include "opencl/test/unit_test/helpers/unit_test_helper.inl" 12 | 13 | namespace NEO { 14 | 15 | template struct UnitTestHelper; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/cfl/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_cfl_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_cfl.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_cfl_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/glk/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_glk_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_glk.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_glk_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/kbl/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_kbl_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_kbl.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_kbl_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen9/skl/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen9_skl_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_skl.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_skl_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/os_interface/windows/wddm_create.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "opencl/test/unit_test/mocks/mock_wddm.h" 9 | 10 | namespace NEO { 11 | Wddm *Wddm::createWddm(std::unique_ptr hwDeviceId, RootDeviceEnvironment &rootDeviceEnvironment) { 12 | return new WddmMock(rootDeviceEnvironment); 13 | } 14 | } // namespace NEO 15 | -------------------------------------------------------------------------------- /shared/source/gen11/state_base_address_gen11.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/state_base_address.h" 9 | #include "shared/source/helpers/state_base_address_bdw_plus.inl" 10 | #include "shared/source/helpers/state_base_address_skl_plus.inl" 11 | 12 | namespace NEO { 13 | template struct StateBaseAddressHelper; 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/gen12lp/hw_info_gen12lp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include "shared/source/helpers/hw_info.h" 10 | 11 | namespace NEO { 12 | 13 | struct TGLLPFamily; 14 | 15 | template <> 16 | struct GfxFamilyMapper { 17 | typedef TGLLPFamily GfxFamily; 18 | static const char *name; 19 | }; 20 | } // namespace NEO 21 | -------------------------------------------------------------------------------- /shared/source/helpers/array_count.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | template 13 | constexpr size_t arrayCount(const T (&)[N]) { 14 | return N; 15 | } 16 | 17 | template 18 | constexpr bool isInRange(size_t idx, const T (&)[N]) { 19 | return (idx < N); 20 | } 21 | -------------------------------------------------------------------------------- /level_zero/cmake/UdevRulesDir.cmake: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(UDEV_RULES_DIR_FOUND FALSE) 8 | 9 | foreach(rules_dir IN ITEMS "/lib/udev/rules.d" "/usr/lib/udev/rules.d") 10 | if(IS_DIRECTORY ${rules_dir}) 11 | set(UDEV_RULES_DIR ${rules_dir} CACHE PATH "Install path for udev rules") 12 | set(UDEV_RULES_DIR_FOUND TRUE) 13 | break() 14 | endif() 15 | endforeach() 16 | -------------------------------------------------------------------------------- /level_zero/core/source/hw_helpers/l0_hw_helper.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/hw_helpers/l0_hw_helper.h" 9 | 10 | namespace L0 { 11 | 12 | L0HwHelper *l0HwHelperFactory[IGFX_MAX_CORE] = {}; 13 | 14 | L0HwHelper &L0HwHelper::get(GFXCORE_FAMILY gfxCore) { 15 | return *l0HwHelperFactory[gfxCore]; 16 | } 17 | 18 | } // namespace L0 19 | -------------------------------------------------------------------------------- /level_zero/core/source/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(WIN32) 8 | set(L0_SOURCES_WINDOWS 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/registry_path.cpp 11 | ${CMAKE_CURRENT_SOURCE_DIR}/driver_teardown.cpp 12 | ) 13 | set_property(GLOBAL PROPERTY L0_SOURCES_WINDOWS ${L0_SOURCES_WINDOWS}) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/source/gen11/buffer_gen11.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen11/hw_cmds.h" 9 | 10 | #include "opencl/source/mem_obj/buffer_base.inl" 11 | 12 | namespace NEO { 13 | 14 | typedef ICLFamily Family; 15 | static auto gfxCore = IGFX_GEN11_CORE; 16 | 17 | #include "opencl/source/mem_obj/buffer_factory_init.inl" 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/ehl/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2019-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen11_ehl_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_ehl.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen11_ehl_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/lkf/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen11_lkf_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_lkf.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen11_lkf_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/unit_test_helper_gen11.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/gen11/hw_info.h" 9 | 10 | #include "opencl/test/unit_test/helpers/unit_test_helper.h" 11 | #include "opencl/test/unit_test/helpers/unit_test_helper.inl" 12 | 13 | namespace NEO { 14 | 15 | template struct UnitTestHelper; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/adls/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen12_adls_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_adls.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12_adls_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen12lp/rkl/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen12_rkl_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_rkl.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12_rkl_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mocks/mock_tbx_stream.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "opencl/source/command_stream/tbx_command_stream_receiver.h" 11 | 12 | namespace NEO { 13 | 14 | struct MockTbxStream : public TbxCommandStreamReceiver::TbxStream { 15 | using TbxCommandStreamReceiver::TbxStream::socket; 16 | }; 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /opencl/test/unit_test/os_interface/windows/gl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_os_interface_windows_gl 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_gl_context_info_khr_tests.cpp 10 | ) 11 | if(WIN32) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_os_interface_windows_gl}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/scenarios/windows/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_scenarios_windows 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_read_write_buffer_scenarios_windows_tests.cpp 10 | ) 11 | if(WIN32) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_scenarios_windows}) 13 | endif() 14 | -------------------------------------------------------------------------------- /opencl/test/unit_test/sharings/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_sharings 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/sharing_factory_tests.cpp 10 | ${CMAKE_CURRENT_SOURCE_DIR}/sharing_tests.cpp 11 | ) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_sharings}) 13 | add_subdirectories() 14 | -------------------------------------------------------------------------------- /scripts/docker/Dockerfile-arch: -------------------------------------------------------------------------------- 1 | FROM docker.io/archlinux/base 2 | LABEL maintainer="jacek.danecki@intel.com" 3 | 4 | COPY neo /root/neo 5 | COPY scripts/prepare-arch.sh /root 6 | 7 | RUN /root/prepare-arch.sh 8 | RUN cd /root/build ; cmake -G Ninja -DCMAKE_BUILD_TYPE=Release \ 9 | -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ \ 10 | -DBUILD_WITH_L0=FALSE \ 11 | -DDO_NOT_RUN_AUB_TESTS=1 ../neo ; \ 12 | ninja -j 1 13 | CMD ["/bin/bash"] 14 | -------------------------------------------------------------------------------- /shared/offline_compiler/source/main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "ocloc_api.h" 9 | 10 | int main(int argc, const char *argv[]) { 11 | return oclocInvoke(argc, argv, 12 | 0, nullptr, nullptr, nullptr, 13 | 0, nullptr, nullptr, nullptr, 14 | nullptr, nullptr, nullptr, nullptr); 15 | } 16 | -------------------------------------------------------------------------------- /shared/offline_compiler/source/offline_compiler_options.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | namespace NEO { 12 | // AUB file folder location 13 | const char *folderAUB = "aub_out"; 14 | 15 | // Initial value for HW tag 16 | uint32_t initialHardwareTag = std::numeric_limits::max(); 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /shared/offline_compiler/source/utilities/windows/get_current_dir_windows.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "windows.h" 9 | 10 | #include 11 | 12 | std::string getCurrentDirectoryOwn(std::string outDirForBuilds) { 13 | char buf[256]; 14 | GetCurrentDirectoryA(256, buf); 15 | return std::string(buf) + "\\" + outDirForBuilds + "\\"; 16 | } 17 | -------------------------------------------------------------------------------- /shared/source/debug_settings/definitions/translate_debug_settings.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/definitions/translate_debug_settings.h" 9 | 10 | namespace NEO { 11 | 12 | void translateDebugSettings(DebugVariables &debugVariables) { 13 | translateDebugSettingsBase(debugVariables); 14 | } 15 | 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /shared/source/gen12lp/state_base_address_gen12lp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2019-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/helpers/state_base_address.h" 9 | #include "shared/source/helpers/state_base_address_bdw_plus.inl" 10 | #include "shared/source/helpers/state_base_address_skl_plus.inl" 11 | 12 | namespace NEO { 13 | template struct StateBaseAddressHelper; 14 | } 15 | -------------------------------------------------------------------------------- /shared/source/helpers/allow_deferred_deleter.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "shared/source/debug_settings/debug_settings_manager.h" 9 | #include "shared/source/helpers/deferred_deleter_helper.h" 10 | 11 | namespace NEO { 12 | bool isDeferredDeleterEnabled() { 13 | return DebugManager.flags.EnableDeferredDeleter.get(); 14 | } 15 | } // namespace NEO 16 | -------------------------------------------------------------------------------- /igc.opencl.h.in: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #ifndef COMPILER_SETUP_H 9 | #define COMPILER_SETUP_H 10 | 11 | #cmakedefine IGC_LIBRARY_NAME "${CMAKE_SHARED_LIBRARY_PREFIX}${IGC_LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}" 12 | #cmakedefine FCL_LIBRARY_NAME "${CMAKE_SHARED_LIBRARY_PREFIX}${FCL_LIBRARY_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}" 13 | 14 | #endif /* COMPILER_SETUP_H */ 15 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | if(LIBGENL_FOUND) 9 | target_sources(${TARGET_NAME} 10 | PRIVATE 11 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 12 | ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_nl_api.cpp 13 | ) 14 | endif() 15 | endif() 16 | -------------------------------------------------------------------------------- /opencl/source/sharings/va/va_extension.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #ifdef LIBVA 9 | 10 | #include "opencl/source/sharings/va/enable_va.h" 11 | 12 | #include 13 | 14 | namespace NEO { 15 | 16 | void *VaSharingBuilderFactory::getExtensionFunctionAddressExtra(const std::string &functionName) { 17 | return nullptr; 18 | } 19 | 20 | } // namespace NEO 21 | #endif -------------------------------------------------------------------------------- /opencl/test/unit_test/aub_tests/aub_tests_configuration.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "test_mode.h" 9 | 10 | namespace NEO { 11 | // max time per single test iteration 12 | unsigned int ultIterationMaxTime = 180; 13 | bool useMockGmm = false; 14 | const char *executionDirectorySuffix = "_aub"; 15 | TestMode testMode = defaultTestMode; 16 | } // namespace NEO 17 | -------------------------------------------------------------------------------- /opencl/test/unit_test/gen11/icllp/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2018-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_tests_gen11_icllp_linux 8 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 9 | ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_icllp.cpp 10 | ) 11 | if(UNIX) 12 | target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen11_icllp_linux}) 13 | add_subdirectory(dll) 14 | endif() 15 | -------------------------------------------------------------------------------- /opencl/test/unit_test/mt_tests/event/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2017-2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | set(IGDRCL_SRCS_mt_tests_event 8 | # local files 9 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 10 | ${CMAKE_CURRENT_SOURCE_DIR}/event_tests_mt.cpp 11 | ${CMAKE_CURRENT_SOURCE_DIR}/user_events_tests_mt.cpp 12 | ) 13 | target_sources(igdrcl_mt_tests PRIVATE ${IGDRCL_SRCS_mt_tests_event}) 14 | -------------------------------------------------------------------------------- /shared/source/helpers/compiler_options_parser.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | 12 | namespace NEO { 13 | 14 | extern const std::string clStdOptionName; 15 | 16 | bool requiresOpenClCFeatures(const std::string &compileOptions); 17 | bool requiresAdditionalExtensions(const std::string &compileOptions); 18 | 19 | } // namespace NEO 20 | -------------------------------------------------------------------------------- /shared/source/image/image_skl_plus.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | template <> 9 | void setMipTailStartLod(Family::RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) { 10 | surfaceState->setMipTailStartLod(0); 11 | 12 | if (gmm != nullptr) { 13 | surfaceState->setMipTailStartLod(gmm->gmmResourceInfo->getMipTailStartLodSurfaceState()); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /shared/source/memory_manager/residency_container.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #include 10 | #include 11 | 12 | namespace NEO { 13 | class GraphicsAllocation; 14 | using ResidencyContainer = std::vector; 15 | using AllocationView = std::pair; 16 | 17 | } // namespace NEO 18 | -------------------------------------------------------------------------------- /shared/source/os_interface/windows/os_inc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2017-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | #define PATH_SEPARATOR '\\' 10 | 11 | // For now we need to keep this file clean of OS specific #includes. 12 | // Only issues to address portability should be covered here. 13 | 14 | namespace Os { 15 | // OS GDI name 16 | extern const char *gdiDllName; 17 | }; // namespace Os 18 | -------------------------------------------------------------------------------- /shared/source/utilities/compiler_support.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | #if !defined __has_cpp_attribute 11 | 12 | #define CPP_ATTRIBUTE_FALLTHROUGH 13 | 14 | #else 15 | 16 | #if !__has_cpp_attribute(fallthrough) 17 | #define CPP_ATTRIBUTE_FALLTHROUGH 18 | #else 19 | #define CPP_ATTRIBUTE_FALLTHROUGH [[fallthrough]] 20 | #endif 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /shared/test/unit_test/tests_configuration.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2018-2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #pragma once 9 | 10 | namespace NEO { 11 | enum class TestMode { NotSpecified, 12 | UnitTests, 13 | AubTests, 14 | AubTestsWithTbx, 15 | TbxTests }; 16 | 17 | extern TestMode testMode; 18 | } // namespace NEO 19 | -------------------------------------------------------------------------------- /level_zero/core/source/hw_helpers/l0_hw_helper_base.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2020 Intel Corporation 3 | * 4 | * SPDX-License-Identifier: MIT 5 | * 6 | */ 7 | 8 | #include "level_zero/core/source/hw_helpers/l0_hw_helper.h" 9 | 10 | namespace L0 { 11 | 12 | template 13 | void L0HwHelperHw::setAdditionalGroupProperty(ze_command_queue_group_properties_t &groupProperty, uint32_t groupType) const { 14 | } 15 | 16 | } // namespace L0 17 | -------------------------------------------------------------------------------- /level_zero/tools/test/unit_tests/sources/sysman/pci/linux/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # 2 | # Copyright (C) 2020 Intel Corporation 3 | # 4 | # SPDX-License-Identifier: MIT 5 | # 6 | 7 | if(UNIX) 8 | target_sources(${TARGET_NAME} 9 | PRIVATE 10 | ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt 11 | ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_pci.h 12 | ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_pci.cpp 13 | ) 14 | endif() 15 | --------------------------------------------------------------------------------