| // Copyright 2019 The IREE Authors | |
| // | |
| // Licensed under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // Vulkan Graphics + IREE API Integration Sample. | |
| // Vulkan GUI utility functions | |
| // Other matters here: we need to pull in this first to make sure Vulkan API | |
| // prototypes are defined so that we can statically link against them. | |
| #include "iree/testing/vulkan/vulkan_gui_util.h" | |
| // IREE's C API: | |
| #include "iree/base/api.h" | |
| #include "iree/hal/api.h" | |
| #include "iree/hal/vulkan/api.h" | |
| #include "iree/hal/vulkan/registration/driver_module.h" | |
| #include "iree/modules/hal/module.h" | |
| #include "iree/vm/api.h" | |
| #include "iree/vm/bytecode_module.h" | |
| #include "iree/vm/ref_cc.h" | |
| // Other dependencies (helpers, etc.) | |
| #include "iree/base/internal/main.h" | |
| #include "iree/base/logging.h" | |
| // Compiled module embedded here to avoid file IO: | |
| #include "samples/vulkan/simple_mul_bytecode_module_c.h" | |
| static VkAllocationCallbacks* g_Allocator = NULL; | |
| static VkInstance g_Instance = VK_NULL_HANDLE; | |
| static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE; | |
| static VkDevice g_Device = VK_NULL_HANDLE; | |
| static uint32_t g_QueueFamily = (uint32_t)-1; | |
| static VkQueue g_Queue = VK_NULL_HANDLE; | |
| static VkPipelineCache g_PipelineCache = VK_NULL_HANDLE; | |
| static VkDescriptorPool g_DescriptorPool = VK_NULL_HANDLE; | |
| static ImGui_ImplVulkanH_Window g_MainWindowData; | |
| static uint32_t g_MinImageCount = 2; | |
| static bool g_SwapChainRebuild = false; | |
| static int g_SwapChainResizeWidth = 0; | |
| static int g_SwapChainResizeHeight = 0; | |
| static void check_vk_result(VkResult err) { | |
| if (err == 0) return; | |
| IREE_LOG(FATAL) << "VkResult: " << err; | |
| } | |
| static void CleanupVulkan() { | |
| vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator); | |
| vkDestroyDevice(g_Device, g_Allocator); | |
| vkDestroyInstance(g_Instance, g_Allocator); | |
| } | |
| static void CleanupVulkanWindow() { | |
| ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, | |
| g_Allocator); | |
| } | |
| namespace iree { | |
| extern "C" int iree_main(int argc, char** argv) { | |
| // -------------------------------------------------------------------------- | |
| // Create a window. | |
| if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0) { | |
| IREE_LOG(FATAL) << "Failed to initialize SDL"; | |
| return 1; | |
| } | |
| // Setup window | |
| // clang-format off | |
| SDL_WindowFlags window_flags = (SDL_WindowFlags)( | |
| SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI); | |
| // clang-format on | |
| SDL_Window* window = SDL_CreateWindow( | |
| "IREE Samples - Vulkan Inference GUI", SDL_WINDOWPOS_CENTERED, | |
| SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags); | |
| // Setup Vulkan | |
| iree_hal_vulkan_features_t iree_vulkan_features = | |
| static_cast<iree_hal_vulkan_features_t>( | |
| IREE_HAL_VULKAN_FEATURE_ENABLE_VALIDATION_LAYERS | | |
| IREE_HAL_VULKAN_FEATURE_ENABLE_DEBUG_UTILS); | |
| std::vector<const char*> layers = GetInstanceLayers(iree_vulkan_features); | |
| std::vector<const char*> extensions = | |
| GetInstanceExtensions(window, iree_vulkan_features); | |
| SetupVulkan(iree_vulkan_features, layers.data(), | |
| static_cast<uint32_t>(layers.size()), extensions.data(), | |
| static_cast<uint32_t>(extensions.size()), g_Allocator, | |
| &g_Instance, &g_QueueFamily, &g_PhysicalDevice, &g_Queue, | |
| &g_Device, &g_DescriptorPool); | |
| // Create Window Surface | |
| VkSurfaceKHR surface; | |
| VkResult err; | |
| if (SDL_Vulkan_CreateSurface(window, g_Instance, &surface) == 0) { | |
| printf("Failed to create Vulkan surface.\n"); | |
| return 1; | |
| } | |
| // Create Framebuffers | |
| int w, h; | |
| SDL_GetWindowSize(window, &w, &h); | |
| ImGui_ImplVulkanH_Window* wd = &g_MainWindowData; | |
| SetupVulkanWindow(wd, g_Allocator, g_Instance, g_QueueFamily, | |
| g_PhysicalDevice, g_Device, surface, w, h, g_MinImageCount); | |
| // Setup Dear ImGui context | |
| IMGUI_CHECKVERSION(); | |
| ImGui::CreateContext(); | |
| ImGuiIO& io = ImGui::GetIO(); | |
| (void)io; | |
| ImGui::StyleColorsDark(); | |
| // Setup Platform/Renderer bindings | |
| ImGui_ImplSDL2_InitForVulkan(window); | |
| ImGui_ImplVulkan_InitInfo init_info = {}; | |
| init_info.Instance = g_Instance; | |
| init_info.PhysicalDevice = g_PhysicalDevice; | |
| init_info.Device = g_Device; | |
| init_info.QueueFamily = g_QueueFamily; | |
| init_info.Queue = g_Queue; | |
| init_info.PipelineCache = g_PipelineCache; | |
| init_info.DescriptorPool = g_DescriptorPool; | |
| init_info.Allocator = g_Allocator; | |
| init_info.MinImageCount = g_MinImageCount; | |
| init_info.ImageCount = wd->ImageCount; | |
| init_info.CheckVkResultFn = check_vk_result; | |
| ImGui_ImplVulkan_Init(&init_info, wd->RenderPass); | |
| // Upload Fonts | |
| { | |
| // Use any command queue | |
| VkCommandPool command_pool = wd->Frames[wd->FrameIndex].CommandPool; | |
| VkCommandBuffer command_buffer = wd->Frames[wd->FrameIndex].CommandBuffer; | |
| err = vkResetCommandPool(g_Device, command_pool, 0); | |
| check_vk_result(err); | |
| VkCommandBufferBeginInfo begin_info = {}; | |
| begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; | |
| begin_info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; | |
| err = vkBeginCommandBuffer(command_buffer, &begin_info); | |
| check_vk_result(err); | |
| ImGui_ImplVulkan_CreateFontsTexture(command_buffer); | |
| VkSubmitInfo end_info = {}; | |
| end_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; | |
| end_info.commandBufferCount = 1; | |
| end_info.pCommandBuffers = &command_buffer; | |
| err = vkEndCommandBuffer(command_buffer); | |
| check_vk_result(err); | |
| err = vkQueueSubmit(g_Queue, 1, &end_info, VK_NULL_HANDLE); | |
| check_vk_result(err); | |
| err = vkDeviceWaitIdle(g_Device); | |
| check_vk_result(err); | |
| ImGui_ImplVulkan_DestroyFontUploadObjects(); | |
| } | |
| // Demo state. | |
| bool show_demo_window = true; | |
| bool show_iree_window = true; | |
| // -------------------------------------------------------------------------- | |
| // -------------------------------------------------------------------------- | |
| // Setup IREE. | |
| // Check API version. | |
| iree_api_version_t actual_version; | |
| iree_status_t status = | |
| iree_api_version_check(IREE_API_VERSION_LATEST, &actual_version); | |
| if (iree_status_is_ok(status)) { | |
| IREE_LOG(INFO) << "IREE runtime API version " << actual_version; | |
| } else { | |
| IREE_LOG(FATAL) << "Unsupported runtime API version " << actual_version; | |
| } | |
| // Register HAL drivers and VM module types. | |
| IREE_CHECK_OK(iree_hal_vulkan_driver_module_register( | |
| iree_hal_driver_registry_default())); | |
| IREE_CHECK_OK(iree_hal_module_register_types()); | |
| // Create a runtime Instance. | |
| iree_vm_instance_t* iree_instance = nullptr; | |
| IREE_CHECK_OK( | |
| iree_vm_instance_create(iree_allocator_system(), &iree_instance)); | |
| // Create IREE Vulkan Driver and Device, sharing our VkInstance/VkDevice. | |
| IREE_LOG(INFO) << "Creating Vulkan driver/device"; | |
| // Load symbols from our static `vkGetInstanceProcAddr` for IREE to use. | |
| iree_hal_vulkan_syms_t* iree_vk_syms = nullptr; | |
| IREE_CHECK_OK(iree_hal_vulkan_syms_create( | |
| reinterpret_cast<void*>(&vkGetInstanceProcAddr), iree_allocator_system(), | |
| &iree_vk_syms)); | |
| // Create the driver sharing our VkInstance. | |
| iree_hal_driver_t* iree_vk_driver = nullptr; | |
| iree_string_view_t driver_identifier = iree_make_cstring_view("vulkan"); | |
| iree_hal_vulkan_driver_options_t driver_options; | |
| driver_options.api_version = VK_API_VERSION_1_0; | |
| driver_options.requested_features = static_cast<iree_hal_vulkan_features_t>( | |
| IREE_HAL_VULKAN_FEATURE_ENABLE_DEBUG_UTILS); | |
| IREE_CHECK_OK(iree_hal_vulkan_driver_create_using_instance( | |
| driver_identifier, &driver_options, iree_vk_syms, g_Instance, | |
| iree_allocator_system(), &iree_vk_driver)); | |
| // Create a device sharing our VkDevice and queue. | |
| // We could also create a separate (possibly low priority) compute queue for | |
| // IREE, and/or provide a dedicated transfer queue. | |
| iree_string_view_t device_identifier = iree_make_cstring_view("vulkan"); | |
| iree_hal_vulkan_queue_set_t compute_queue_set; | |
| compute_queue_set.queue_family_index = g_QueueFamily; | |
| compute_queue_set.queue_indices = 1 << 0; | |
| iree_hal_vulkan_queue_set_t transfer_queue_set; | |
| transfer_queue_set.queue_indices = 0; | |
| iree_hal_device_t* iree_vk_device = nullptr; | |
| IREE_CHECK_OK(iree_hal_vulkan_wrap_device( | |
| device_identifier, &driver_options.device_options, iree_vk_syms, | |
| g_Instance, g_PhysicalDevice, g_Device, &compute_queue_set, | |
| &transfer_queue_set, iree_allocator_system(), &iree_vk_device)); | |
| // Create a HAL module using the HAL device. | |
| iree_vm_module_t* hal_module = nullptr; | |
| IREE_CHECK_OK(iree_hal_module_create(iree_vk_device, iree_allocator_system(), | |
| &hal_module)); | |
| // Load bytecode module from embedded data. | |
| IREE_LOG(INFO) << "Loading simple_mul.mlir..."; | |
| const struct iree_file_toc_t* module_file_toc = | |
| iree_samples_vulkan_simple_mul_bytecode_module_create(); | |
| iree_vm_module_t* bytecode_module = nullptr; | |
| IREE_CHECK_OK(iree_vm_bytecode_module_create( | |
| iree_const_byte_span_t{ | |
| reinterpret_cast<const uint8_t*>(module_file_toc->data), | |
| module_file_toc->size}, | |
| iree_allocator_null(), iree_allocator_system(), &bytecode_module)); | |
| // Query for details about what is in the loaded module. | |
| iree_vm_module_signature_t bytecode_module_signature = | |
| iree_vm_module_signature(bytecode_module); | |
| IREE_LOG(INFO) << "Module loaded, have <" | |
| << bytecode_module_signature.export_function_count | |
| << "> exported functions:"; | |
| for (int i = 0; i < bytecode_module_signature.export_function_count; ++i) { | |
| iree_vm_function_t function; | |
| IREE_CHECK_OK(iree_vm_module_lookup_function_by_ordinal( | |
| bytecode_module, IREE_VM_FUNCTION_LINKAGE_EXPORT, i, &function)); | |
| auto function_name = iree_vm_function_name(&function); | |
| auto function_signature = iree_vm_function_signature(&function); | |
| IREE_LOG(INFO) << " " << i << ": '" | |
| << std::string(function_name.data, function_name.size) | |
| << "' with calling convention '" | |
| << std::string(function_signature.calling_convention.data, | |
| function_signature.calling_convention.size) | |
| << "'"; | |
| } | |
| // Allocate a context that will hold the module state across invocations. | |
| iree_vm_context_t* iree_context = nullptr; | |
| std::vector<iree_vm_module_t*> modules = {hal_module, bytecode_module}; | |
| IREE_CHECK_OK(iree_vm_context_create_with_modules( | |
| iree_instance, IREE_VM_CONTEXT_FLAG_NONE, modules.data(), modules.size(), | |
| iree_allocator_system(), &iree_context)); | |
| IREE_LOG(INFO) << "Context with modules is ready for use"; | |
| // Lookup the entry point function. | |
| iree_vm_function_t main_function; | |
| const char kMainFunctionName[] = "module.simple_mul"; | |
| IREE_CHECK_OK(iree_vm_context_resolve_function( | |
| iree_context, | |
| iree_string_view_t{kMainFunctionName, sizeof(kMainFunctionName) - 1}, | |
| &main_function)); | |
| iree_string_view_t main_function_name = iree_vm_function_name(&main_function); | |
| IREE_LOG(INFO) << "Resolved main function named '" | |
| << std::string(main_function_name.data, | |
| main_function_name.size) | |
| << "'"; | |
| // -------------------------------------------------------------------------- | |
| // -------------------------------------------------------------------------- | |
| // Main loop. | |
| bool done = false; | |
| while (!done) { | |
| SDL_Event event; | |
| while (SDL_PollEvent(&event)) { | |
| if (event.type == SDL_QUIT) { | |
| done = true; | |
| } | |
| ImGui_ImplSDL2_ProcessEvent(&event); | |
| if (event.type == SDL_QUIT) done = true; | |
| if (event.type == SDL_WINDOWEVENT && | |
| event.window.event == SDL_WINDOWEVENT_RESIZED && | |
| event.window.windowID == SDL_GetWindowID(window)) { | |
| g_SwapChainResizeWidth = (int)event.window.data1; | |
| g_SwapChainResizeHeight = (int)event.window.data2; | |
| g_SwapChainRebuild = true; | |
| } | |
| } | |
| if (g_SwapChainRebuild) { | |
| g_SwapChainRebuild = false; | |
| ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount); | |
| ImGui_ImplVulkanH_CreateOrResizeWindow( | |
| g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, | |
| g_QueueFamily, g_Allocator, g_SwapChainResizeWidth, | |
| g_SwapChainResizeHeight, g_MinImageCount); | |
| g_MainWindowData.FrameIndex = 0; | |
| } | |
| // Start the Dear ImGui frame | |
| ImGui_ImplVulkan_NewFrame(); | |
| ImGui_ImplSDL2_NewFrame(window); | |
| ImGui::NewFrame(); | |
| // Demo window. | |
| if (show_demo_window) ImGui::ShowDemoWindow(&show_demo_window); | |
| // Custom window. | |
| { | |
| ImGui::Begin("IREE Vulkan Integration Demo", &show_iree_window, | |
| ImGuiWindowFlags_AlwaysAutoResize); | |
| ImGui::Checkbox("Show ImGui Demo Window", &show_demo_window); | |
| ImGui::Separator(); | |
| // ImGui Inputs for two input tensors. | |
| // Run computation whenever any of the values changes. | |
| static bool dirty = true; | |
| static float input_x[] = {4.0f, 4.0f, 4.0f, 4.0f}; | |
| static float input_y[] = {2.0f, 2.0f, 2.0f, 2.0f}; | |
| static float latest_output[] = {0.0f, 0.0f, 0.0f, 0.0f}; | |
| ImGui::Text("Multiply numbers using IREE"); | |
| ImGui::PushItemWidth(60); | |
| // clang-format off | |
| if (ImGui::DragFloat("= x[0]", &input_x[0], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } ImGui::SameLine(); // NOLINT | |
| if (ImGui::DragFloat("= x[1]", &input_x[1], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } ImGui::SameLine(); // NOLINT | |
| if (ImGui::DragFloat("= x[2]", &input_x[2], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } ImGui::SameLine(); // NOLINT | |
| if (ImGui::DragFloat("= x[3]", &input_x[3], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } // NOLINT | |
| if (ImGui::DragFloat("= y[0]", &input_y[0], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } ImGui::SameLine(); // NOLINT | |
| if (ImGui::DragFloat("= y[1]", &input_y[1], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } ImGui::SameLine(); // NOLINT | |
| if (ImGui::DragFloat("= y[2]", &input_y[2], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } ImGui::SameLine(); // NOLINT | |
| if (ImGui::DragFloat("= y[3]", &input_y[3], 0.5f, 0.f, 0.f, "%.1f")) { dirty = true; } // NOLINT | |
| // clang-format on | |
| ImGui::PopItemWidth(); | |
| if (dirty) { | |
| // Some input values changed, run the computation. | |
| // This is synchronous and doesn't reuse buffers for now. | |
| // Write inputs into mappable buffers. | |
| IREE_DLOG(INFO) << "Creating I/O buffers..."; | |
| constexpr iree_hal_dim_t kElementCount = 4; | |
| iree_hal_allocator_t* allocator = | |
| iree_hal_device_allocator(iree_vk_device); | |
| iree_hal_memory_type_t input_memory_type = | |
| static_cast<iree_hal_memory_type_t>( | |
| IREE_HAL_MEMORY_TYPE_HOST_LOCAL | | |
| IREE_HAL_MEMORY_TYPE_DEVICE_VISIBLE); | |
| iree_hal_buffer_usage_t input_buffer_usage = | |
| static_cast<iree_hal_buffer_usage_t>( | |
| IREE_HAL_BUFFER_USAGE_DISPATCH | | |
| IREE_HAL_BUFFER_USAGE_TRANSFER | IREE_HAL_BUFFER_USAGE_MAPPING | | |
| IREE_HAL_BUFFER_USAGE_CONSTANT); | |
| iree_hal_buffer_params_t buffer_params; | |
| buffer_params.type = input_memory_type; | |
| buffer_params.usage = input_buffer_usage; | |
| // Wrap input buffers in buffer views. | |
| iree_hal_buffer_view_t* input0_buffer_view = nullptr; | |
| iree_hal_buffer_view_t* input1_buffer_view = nullptr; | |
| IREE_CHECK_OK(iree_hal_buffer_view_allocate_buffer( | |
| allocator, | |
| /*shape=*/&kElementCount, /*shape_rank=*/1, | |
| IREE_HAL_ELEMENT_TYPE_FLOAT_32, | |
| IREE_HAL_ENCODING_TYPE_DENSE_ROW_MAJOR, buffer_params, | |
| iree_make_const_byte_span(&input_x, sizeof(input_x)), | |
| &input0_buffer_view)); | |
| IREE_CHECK_OK(iree_hal_buffer_view_allocate_buffer( | |
| allocator, | |
| /*shape=*/&kElementCount, /*shape_rank=*/1, | |
| IREE_HAL_ELEMENT_TYPE_FLOAT_32, | |
| IREE_HAL_ENCODING_TYPE_DENSE_ROW_MAJOR, buffer_params, | |
| iree_make_const_byte_span(&input_y, sizeof(input_y)), | |
| &input1_buffer_view)); | |
| // Marshal inputs through a VM variant list. | |
| // [arg0|arg1] | |
| vm::ref<iree_vm_list_t> inputs; | |
| IREE_CHECK_OK(iree_vm_list_create(/*element_type=*/nullptr, 6, | |
| iree_allocator_system(), &inputs)); | |
| auto input0_buffer_view_ref = | |
| iree_hal_buffer_view_move_ref(input0_buffer_view); | |
| auto input1_buffer_view_ref = | |
| iree_hal_buffer_view_move_ref(input1_buffer_view); | |
| IREE_CHECK_OK( | |
| iree_vm_list_push_ref_move(inputs.get(), &input0_buffer_view_ref)); | |
| IREE_CHECK_OK( | |
| iree_vm_list_push_ref_move(inputs.get(), &input1_buffer_view_ref)); | |
| // Prepare outputs list to accept results from the invocation. | |
| vm::ref<iree_vm_list_t> outputs; | |
| IREE_CHECK_OK(iree_vm_list_create(/*element_type=*/nullptr, | |
| kElementCount * sizeof(float), | |
| iree_allocator_system(), &outputs)); | |
| // Synchronously invoke the function. | |
| IREE_CHECK_OK(iree_vm_invoke(iree_context, main_function, | |
| IREE_VM_INVOCATION_FLAG_NONE, | |
| /*policy=*/nullptr, inputs.get(), | |
| outputs.get(), iree_allocator_system())); | |
| // Read back the results. | |
| IREE_DLOG(INFO) << "Reading back results..."; | |
| auto* output_buffer_view = reinterpret_cast<iree_hal_buffer_view_t*>( | |
| iree_vm_list_get_ref_deref(outputs.get(), 0, | |
| iree_hal_buffer_view_get_descriptor())); | |
| IREE_CHECK_OK(iree_hal_device_transfer_d2h( | |
| iree_vk_device, iree_hal_buffer_view_buffer(output_buffer_view), 0, | |
| latest_output, sizeof(latest_output), | |
| IREE_HAL_TRANSFER_BUFFER_FLAG_DEFAULT, iree_infinite_timeout())); | |
| dirty = false; | |
| } | |
| // Display the latest computation output. | |
| ImGui::Text("X * Y = [%f, %f, %f, %f]", | |
| latest_output[0], // | |
| latest_output[1], // | |
| latest_output[2], // | |
| latest_output[3]); | |
| ImGui::Separator(); | |
| // Framerate counter. | |
| ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", | |
| 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate); | |
| ImGui::End(); | |
| } | |
| // Rendering | |
| ImGui::Render(); | |
| RenderFrame(wd, g_Device, g_Queue); | |
| PresentFrame(wd, g_Queue); | |
| } | |
| // -------------------------------------------------------------------------- | |
| // -------------------------------------------------------------------------- | |
| // Cleanup | |
| iree_vm_module_release(hal_module); | |
| iree_vm_module_release(bytecode_module); | |
| iree_vm_context_release(iree_context); | |
| iree_hal_device_release(iree_vk_device); | |
| iree_hal_driver_release(iree_vk_driver); | |
| iree_hal_vulkan_syms_release(iree_vk_syms); | |
| iree_vm_instance_release(iree_instance); | |
| err = vkDeviceWaitIdle(g_Device); | |
| check_vk_result(err); | |
| ImGui_ImplVulkan_Shutdown(); | |
| ImGui_ImplSDL2_Shutdown(); | |
| ImGui::DestroyContext(); | |
| CleanupVulkanWindow(); | |
| CleanupVulkan(); | |
| SDL_DestroyWindow(window); | |
| SDL_Quit(); | |
| // -------------------------------------------------------------------------- | |
| return 0; | |
| } | |
| } // namespace iree |