[mlir][vulkan-runner] Avoid dependency on LLVM libraries

[antiagainst]

Summary

The Vulkan runtime wrapper will be compiled to a shared library
that are loaded by the JIT runner. Depending on LLVM libraries
means that LLVM symbols will be compiled into the shared library.
That can cause problems if we are using it with other shared
libraries depending on LLVM, notably Mesa, the open-source graphics
driver framework. The Vulkan API wrappers invoked by the JIT runner
links to the system libvulkan.so. If it's Mesa providing the
implementation, Mesa will normally try to load the system libLLVM.so
for its shader compilation. That causes issues because the JIT runner
already loaded the Vulkan runtime wrapper which has LLVM sybmols
compiled in. So system linker will instruct Mesa to use those symbols
instead.

[denis13]

LGTM! Thanks!

mlir/tools/mlir-vulkan-runner/CMakeLists.txt

if (NOT Vulkan_FOUND)
     message(FATAL_ERROR "Cannot find Vulkan library")
   endif()
 
   add_llvm_library(vulkan-runtime-wrappers SHARED
     vulkan-runtime-wrappers.cpp
     VulkanRuntime.cpp
   )
 
-  target_include_directories(vulkan-runtime-wrappers
-    PRIVATE ${Vulkan_INCLUDE_DIR}
-    LLVMSupport
-  )
-
+  # *IMPORTANT*: This library cannot depend on LLVM libraries. Otherwise,
+  # it may cause LLVM version conflict when used together with other shared
+  # libraries depending on LLVM. Notably, Mesa, who implemnents Vulkan
+  # drivers on Linux, depends on the system libLLVM.so.
   target_link_libraries(vulkan-runtime-wrappers
     PUBLIC
-    LLVMCore
-    LLVMSupport
     ${Vulkan_LIBRARY}
   )
 
   get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
   set(LIBS
     ${dialect_libs}
     ${conversion_libs}

mlir/tools/mlir-vulkan-runner/VulkanRuntime.h

 //===- VulkanRuntime.cpp - MLIR Vulkan runtime ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares Vulkan runtime API.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef VULKAN_RUNTIME_H
 #define VULKAN_RUNTIME_H
 
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/Serialization.h"
-#include "mlir/IR/Module.h"
 #include "mlir/Support/LogicalResult.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/ToolOutputFile.h"
 
+#include <unordered_map>
+#include <vector>
 #include <vulkan/vulkan.h>
 
 using namespace mlir;
 
 using DescriptorSetIndex = uint32_t;
 using BindingIndex = uint32_t;
 
 /// Struct containing information regarding to a device memory buffer.
struct DescriptorSetInfo {
   DescriptorSetIndex descriptorSet{0};
   /// Number of descriptors in a set.
   uint32_t descriptorSize{0};
   /// Type of a descriptor set.
   VkDescriptorType descriptorType{VK_DESCRIPTOR_TYPE_MAX_ENUM};
 };
 
 /// VulkanHostMemoryBuffer mapped into a descriptor set and a binding.
-using ResourceData =
-    llvm::DenseMap<DescriptorSetIndex,
-                   llvm::DenseMap<BindingIndex, VulkanHostMemoryBuffer>>;
+using ResourceData = std::unordered_map<
+    DescriptorSetIndex,
+    std::unordered_map<BindingIndex, VulkanHostMemoryBuffer>>;
+
+/// SPIR-V storage classes.
+/// Note that this duplicates spirv::StorageClass but it keeps the Vulkan
+/// runtime library detached from SPIR-V dialect, so we can avoid pick up lots
+/// of dependencies.
+enum class SPIRVStorageClass {
+  Uniform = 2,
+  StorageBuffer = 12,
+};
 
 /// StorageClass mapped into a descriptor set and a binding.
 using ResourceStorageClassBindingMap =
-    llvm::DenseMap<DescriptorSetIndex,
-                   llvm::DenseMap<BindingIndex, mlir::spirv::StorageClass>>;
-
-inline void emitVulkanError(const llvm::Twine &message, VkResult error) {
-  llvm::errs()
-      << message.concat(" failed with error code ").concat(llvm::Twine{error});
-}
-
-#define RETURN_ON_VULKAN_ERROR(result, msg)                                    \
-  if ((result) != VK_SUCCESS) {                                                \
-    emitVulkanError(msg, (result));                                            \
-    return failure();                                                          \
-  }
+    std::unordered_map<DescriptorSetIndex,
+                       std::unordered_map<BindingIndex, SPIRVStorageClass>>;
 
 /// Vulkan runtime.
 /// The purpose of this class is to run SPIR-V compute shader on Vulkan
 /// device.
 /// Before the run, user must provide and set resource data with descriptors,
 /// SPIR-V shader, number of work groups and entry point. After the creation of
 /// VulkanRuntime, special methods must be called in the following
 /// sequence: initRuntime(), run(), updateHostMemoryBuffers(), destroy();
private:
   LogicalResult submitCommandBuffersToQueue();
 
   //===--------------------------------------------------------------------===//
   // Helper methods.
   //===--------------------------------------------------------------------===//
 
   /// Maps storage class to a descriptor type.
   LogicalResult
-  mapStorageClassToDescriptorType(spirv::StorageClass storageClass,
+  mapStorageClassToDescriptorType(SPIRVStorageClass storageClass,
                                   VkDescriptorType &descriptorType);
 
   /// Maps storage class to buffer usage flags.
   LogicalResult
-  mapStorageClassToBufferUsageFlag(spirv::StorageClass storageClass,
+  mapStorageClassToBufferUsageFlag(SPIRVStorageClass storageClass,
                                    VkBufferUsageFlagBits &bufferUsage);
 
   LogicalResult countDeviceMemorySize();
 
   //===--------------------------------------------------------------------===//
   // Vulkan objects.
   //===--------------------------------------------------------------------===//
 
   VkInstance instance{VK_NULL_HANDLE};
   VkPhysicalDevice physicalDevice{VK_NULL_HANDLE};
   VkDevice device{VK_NULL_HANDLE};
   VkQueue queue{VK_NULL_HANDLE};
 
   /// Specifies VulkanDeviceMemoryBuffers divided into sets.
-  llvm::DenseMap<DescriptorSetIndex,
-                 llvm::SmallVector<VulkanDeviceMemoryBuffer, 1>>
+  std::unordered_map<DescriptorSetIndex, std::vector<VulkanDeviceMemoryBuffer>>
       deviceMemoryBufferMap;
 
   /// Specifies shader module.
   VkShaderModule shaderModule{VK_NULL_HANDLE};
 
   /// Specifies layout bindings.
-  llvm::DenseMap<DescriptorSetIndex,
-                 llvm::SmallVector<VkDescriptorSetLayoutBinding, 1>>
+  std::unordered_map<DescriptorSetIndex,
+                     std::vector<VkDescriptorSetLayoutBinding>>
       descriptorSetLayoutBindingMap;
 
   /// Specifies layouts of descriptor sets.
-  llvm::SmallVector<VkDescriptorSetLayout, 1> descriptorSetLayouts;
+  std::vector<VkDescriptorSetLayout> descriptorSetLayouts;
   VkPipelineLayout pipelineLayout{VK_NULL_HANDLE};
 
   /// Specifies descriptor sets.
-  llvm::SmallVector<VkDescriptorSet, 1> descriptorSets;
+  std::vector<VkDescriptorSet> descriptorSets;
 
   /// Specifies a pool of descriptor set info, each descriptor set must have
   /// information such as type, index and amount of bindings.
-  llvm::SmallVector<DescriptorSetInfo, 1> descriptorSetInfoPool;
+  std::vector<DescriptorSetInfo> descriptorSetInfoPool;
   VkDescriptorPool descriptorPool{VK_NULL_HANDLE};
 
   /// Timestamp query.
   VkQueryPool queryPool{VK_NULL_HANDLE};
   // Number of nonoseconds for timestamp to increase 1
   float timestampPeriod{0.f};
 
   /// Computation pipeline.
   VkPipeline pipeline{VK_NULL_HANDLE};
   VkCommandPool commandPool{VK_NULL_HANDLE};
-  llvm::SmallVector<VkCommandBuffer, 1> commandBuffers;
+  std::vector<VkCommandBuffer> commandBuffers;
 
   //===--------------------------------------------------------------------===//
   // Vulkan memory context.
   //===--------------------------------------------------------------------===//
 
   uint32_t queueFamilyIndex{0};
   VkQueueFamilyProperties queueFamilyProperties{};
   uint32_t memoryTypeIndex{VK_MAX_MEMORY_TYPES};

mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp

 //===- VulkanRuntime.cpp - MLIR Vulkan runtime ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides a library for running a module on a Vulkan device.
 // Implements a Vulkan runtime.
 //
 //===----------------------------------------------------------------------===//
 
 #include "VulkanRuntime.h"
 
-#include "llvm/Support/Format.h"
 #include <chrono>
+#include <cstring>
+// TODO(antiagainst): It's generally bad to access stdout/stderr in a library.
+// Figure out a better way for error reporting.
+#include <iomanip>
+#include <iostream>
+
+inline void emitVulkanError(const char *api, VkResult error) {
+  std::cerr << " failed with error code " << error << " when executing " << api;
+}
+
+#define RETURN_ON_VULKAN_ERROR(result, api)                                    \
+  if ((result) != VK_SUCCESS) {                                                \
+    emitVulkanError(api, (result));                                            \
+    return failure();                                                          \
+  }
 
 using namespace mlir;
 
 void VulkanRuntime::setNumWorkGroups(const NumWorkGroups &numberWorkGroups) {
   numWorkGroups = numberWorkGroups;
 }
 
 void VulkanRuntime::setResourceStorageClassBindingMap(
     const ResourceStorageClassBindingMap &stClassData) {
   resourceStorageClassData = stClassData;
 }
 
 void VulkanRuntime::setResourceData(
     const DescriptorSetIndex desIndex, const BindingIndex bindIndex,
     const VulkanHostMemoryBuffer &hostMemBuffer) {
   resourceData[desIndex][bindIndex] = hostMemBuffer;
   resourceStorageClassData[desIndex][bindIndex] =
-      spirv::StorageClass::StorageBuffer;
+      SPIRVStorageClass::StorageBuffer;
 }
 
 void VulkanRuntime::setEntryPoint(const char *entryPointName) {
   entryPoint = entryPointName;
 }
 
 void VulkanRuntime::setResourceData(const ResourceData &resData) {
   resourceData = resData;
 }
 
 void VulkanRuntime::setShaderModule(uint8_t *shader, uint32_t size) {
   binary = shader;
   binarySize = size;
 }
 
 LogicalResult VulkanRuntime::mapStorageClassToDescriptorType(
-    spirv::StorageClass storageClass, VkDescriptorType &descriptorType) {
+    SPIRVStorageClass storageClass, VkDescriptorType &descriptorType) {
   switch (storageClass) {
-  case spirv::StorageClass::StorageBuffer:
+  case SPIRVStorageClass::StorageBuffer:
     descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
     break;
-  case spirv::StorageClass::Uniform:
+  case SPIRVStorageClass::Uniform:
     descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
     break;
-  default:
-    llvm::errs() << "unsupported storage class";
-    return failure();
   }
   return success();
 }
 
 LogicalResult VulkanRuntime::mapStorageClassToBufferUsageFlag(
-    spirv::StorageClass storageClass, VkBufferUsageFlagBits &bufferUsage) {
+    SPIRVStorageClass storageClass, VkBufferUsageFlagBits &bufferUsage) {
   switch (storageClass) {
-  case spirv::StorageClass::StorageBuffer:
+  case SPIRVStorageClass::StorageBuffer:
     bufferUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
     break;
-  case spirv::StorageClass::Uniform:
+  case SPIRVStorageClass::Uniform:
     bufferUsage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
     break;
-  default:
-    llvm::errs() << "unsupported storage class";
-    return failure();
   }
   return success();
 }
 
 LogicalResult VulkanRuntime::countDeviceMemorySize() {
   for (const auto &resourceDataMapPair : resourceData) {
     const auto &resourceDataMap = resourceDataMapPair.second;
     for (const auto &resourceDataBindingPair : resourceDataMap) {
       if (resourceDataBindingPair.second.size) {
         memorySize += resourceDataBindingPair.second.size;
       } else {
-        llvm::errs()
-            << "expected buffer size greater than zero for resource data";
+        std::cerr << "expected buffer size greater than zero for resource data";
         return failure();
       }
     }
   }
   return success();
 }
 
 LogicalResult VulkanRuntime::initRuntime() {
   if (!resourceData.size()) {
-    llvm::errs() << "Vulkan runtime needs at least one resource";
+    std::cerr << "Vulkan runtime needs at least one resource";
     return failure();
   }
   if (!binarySize || !binary) {
-    llvm::errs() << "binary shader size must be greater than zero";
+    std::cerr << "binary shader size must be greater than zero";
     return failure();
   }
   if (failed(countDeviceMemorySize())) {
     return failure();
   }
   return success();
 }
 
vkFreeCommandBuffers(device, commandPool, commandBuffers.size(),
                        commandBuffers.data());
   vkDestroyQueryPool(device, queryPool, nullptr);
   vkDestroyCommandPool(device, commandPool, nullptr);
   vkFreeDescriptorSets(device, descriptorPool, descriptorSets.size(),
                        descriptorSets.data());
   vkDestroyDescriptorPool(device, descriptorPool, nullptr);
   vkDestroyPipeline(device, pipeline, nullptr);
   vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
-  for (auto &descriptorSetLayout: descriptorSetLayouts) {
+  for (auto &descriptorSetLayout : descriptorSetLayouts) {
     vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
   }
   vkDestroyShaderModule(device, shaderModule, nullptr);
 
   // For each descriptor set.
   for (auto &deviceMemoryBufferMapPair : deviceMemoryBufferMap) {
     auto &deviceMemoryBuffers = deviceMemoryBufferMapPair.second;
     // For each descriptor binding.
RETURN_ON_VULKAN_ERROR(
         vkGetQueryPoolResults(
             device, queryPool, /*firstQuery=*/0, /*queryCount=*/2,
             /*dataSize=*/sizeof(timestamps),
             /*pData=*/reinterpret_cast<void *>(timestamps),
             /*stride=*/sizeof(uint64_t),
             VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT),
         "vkGetQueryPoolResults");
     float microsec = (timestamps[1] - timestamps[0]) * timestampPeriod / 1000;
-    llvm::outs() << "Compute shader execution time: "
-                 << llvm::format("%0.3fus\n", microsec);
+    std::cout << "Compute shader execution time: " << std::setprecision(3)
+              << microsec << "us\n";
   }
 
-  llvm::outs() << "Command buffer submit time: " << submitDuration.count()
-               << "us\nWait idle time: " << execDuration.count() << "us\n";
+  std::cout << "Command buffer submit time: " << submitDuration.count()
 
   return success();
 }
 
 LogicalResult VulkanRuntime::createInstance() {
   VkApplicationInfo applicationInfo = {};
   applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
   applicationInfo.pNext = nullptr;

 }
 
 LogicalResult VulkanRuntime::createDevice() {
   uint32_t physicalDeviceCount = 0;
   RETURN_ON_VULKAN_ERROR(
       vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, 0),
       "vkEnumeratePhysicalDevices");
 
-  llvm::SmallVector<VkPhysicalDevice, 1> physicalDevices(physicalDeviceCount);
+  std::vector<VkPhysicalDevice> physicalDevices(physicalDeviceCount);
   RETURN_ON_VULKAN_ERROR(vkEnumeratePhysicalDevices(instance,
                                                     &physicalDeviceCount,
                                                     physicalDevices.data()),
                          "vkEnumeratePhysicalDevices");
 
   RETURN_ON_VULKAN_ERROR(physicalDeviceCount ? VK_SUCCESS : VK_INCOMPLETE,
                          "physicalDeviceCount");
 
LogicalResult VulkanRuntime::createDevice() {
   return success();
 }
 
 LogicalResult VulkanRuntime::getBestComputeQueue() {
   uint32_t queueFamilyPropertiesCount = 0;
   vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice,
                                            &queueFamilyPropertiesCount, 0);
 
-  SmallVector<VkQueueFamilyProperties, 1> familyProperties(
+  std::vector<VkQueueFamilyProperties> familyProperties(
       queueFamilyPropertiesCount);
   vkGetPhysicalDeviceQueueFamilyProperties(
       physicalDevice, &queueFamilyPropertiesCount, familyProperties.data());
 
   // VK_QUEUE_COMPUTE_BIT specifies that queues in this queue family support
   // compute operations. Try to find a compute-only queue first if possible.
   for (uint32_t i = 0; i < queueFamilyPropertiesCount; ++i) {
     auto flags = familyProperties[i].queueFlags;
for (uint32_t i = 0; i < queueFamilyPropertiesCount; ++i) {
     auto flags = familyProperties[i].queueFlags;
     if ((flags & VK_QUEUE_COMPUTE_BIT)) {
       queueFamilyIndex = i;
       queueFamilyProperties = familyProperties[i];
       return success();
     }
   }
 
-  llvm::errs() << "cannot find valid queue";
+  std::cerr << "cannot find valid queue";
   return failure();
 }
 
 LogicalResult VulkanRuntime::createMemoryBuffers() {
   // For each descriptor set.
   for (const auto &resourceDataMapPair : resourceData) {
-    llvm::SmallVector<VulkanDeviceMemoryBuffer, 1> deviceMemoryBuffers;
+    std::vector<VulkanDeviceMemoryBuffer> deviceMemoryBuffers;
     const auto descriptorSetIndex = resourceDataMapPair.first;
     const auto &resourceDataMap = resourceDataMapPair.second;
 
     // For each descriptor binding.
     for (const auto &resourceDataBindingPair : resourceDataMap) {
       // Create device memory buffer.
       VulkanDeviceMemoryBuffer memoryBuffer;
       memoryBuffer.bindingIndex = resourceDataBindingPair.first;
       VkDescriptorType descriptorType = {};
       VkBufferUsageFlagBits bufferUsage = {};
 
       // Check that descriptor set has storage class map.
       const auto resourceStorageClassMapIt =
           resourceStorageClassData.find(descriptorSetIndex);
       if (resourceStorageClassMapIt == resourceStorageClassData.end()) {
-        llvm::errs()
+        std::cerr
             << "cannot find storage class for resource in descriptor set: "
             << descriptorSetIndex;
         return failure();
       }
 
       // Check that specific descriptor binding has storage class.
       const auto &resourceStorageClassMap = resourceStorageClassMapIt->second;
       const auto resourceStorageClassIt =
           resourceStorageClassMap.find(resourceDataBindingPair.first);
       if (resourceStorageClassIt == resourceStorageClassMap.end()) {
-        llvm::errs()
+        std::cerr
             << "cannot find storage class for resource with descriptor index: "
             << resourceDataBindingPair.first;
         return failure();
       }
 
       const auto resourceStorageClassBinding = resourceStorageClassIt->second;
       if (failed(mapStorageClassToDescriptorType(resourceStorageClassBinding,
                                                  descriptorType)) ||
           failed(mapStorageClassToBufferUsageFlag(resourceStorageClassBinding,
                                                   bufferUsage))) {
-        llvm::errs() << "storage class for resource with descriptor binding: "
-                     << resourceDataBindingPair.first
-                     << " in the descriptor set: " << descriptorSetIndex
-                     << " is not supported ";
+        std::cerr << "storage class for resource with descriptor binding: "
         return failure();
       }
 
       // Set descriptor type for the specific device memory buffer.
       memoryBuffer.descriptorType = descriptorType;
       const auto bufferSize = resourceDataBindingPair.second.size;
 
       // Specify memory allocation info.
LogicalResult VulkanRuntime::createShaderModule() {
   RETURN_ON_VULKAN_ERROR(
       vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &shaderModule),
       "vkCreateShaderModule");
   return success();
 }
 
 void VulkanRuntime::initDescriptorSetLayoutBindingMap() {
   for (const auto &deviceMemoryBufferMapPair : deviceMemoryBufferMap) {
-    SmallVector<VkDescriptorSetLayoutBinding, 1> descriptorSetLayoutBindings;
+    std::vector<VkDescriptorSetLayoutBinding> descriptorSetLayoutBindings;
     const auto &deviceMemoryBuffers = deviceMemoryBufferMapPair.second;
     const auto descriptorSetIndex = deviceMemoryBufferMapPair.first;
 
     // Create a layout binding for each descriptor.
     for (const auto &memBuffer : deviceMemoryBuffers) {
       VkDescriptorSetLayoutBinding descriptorSetLayoutBinding = {};
       descriptorSetLayoutBinding.binding = memBuffer.bindingIndex;
       descriptorSetLayoutBinding.descriptorType = memBuffer.descriptorType;
for (const auto &deviceMemoryBufferMapPair : deviceMemoryBufferMap) {
     // Each descriptor in a descriptor set must be the same type.
     VkDescriptorType descriptorType =
         deviceMemoryBuffers.front().descriptorType;
     const uint32_t descriptorSize = deviceMemoryBuffers.size();
     const auto descriptorSetLayoutBindingIt =
         descriptorSetLayoutBindingMap.find(descriptorSetIndex);
 
     if (descriptorSetLayoutBindingIt == descriptorSetLayoutBindingMap.end()) {
-      llvm::errs() << "cannot find layout bindings for the set with number: "
-                   << descriptorSetIndex;
+      std::cerr << "cannot find layout bindings for the set with number: "
       return failure();
     }
 
     const auto &descriptorSetLayoutBindings =
         descriptorSetLayoutBindingIt->second;
     // Create descriptor set layout.
     VkDescriptorSetLayout descriptorSetLayout = {};
     VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {};
LogicalResult VulkanRuntime::createComputePipeline() {
   RETURN_ON_VULKAN_ERROR(vkCreateComputePipelines(device, 0, 1,
                                                   &computePipelineCreateInfo, 0,
                                                   &pipeline),
                          "vkCreateComputePipelines");
   return success();
 }
 
 LogicalResult VulkanRuntime::createDescriptorPool() {
-  llvm::SmallVector<VkDescriptorPoolSize, 1> descriptorPoolSizes;
+  std::vector<VkDescriptorPoolSize> descriptorPoolSizes;
   for (const auto &descriptorSetInfo : descriptorSetInfoPool) {
     // For each descriptor set populate descriptor pool size.
     VkDescriptorPoolSize descriptorPoolSize = {};
     descriptorPoolSize.type = descriptorSetInfo.descriptorType;
     descriptorPoolSize.descriptorCount = descriptorSetInfo.descriptorSize;
     descriptorPoolSizes.push_back(descriptorPoolSize);
   }
 
RETURN_ON_VULKAN_ERROR(vkAllocateDescriptorSets(device,
                                                   &descriptorSetAllocateInfo,
                                                   descriptorSets.data()),
                          "vkAllocateDescriptorSets");
   return success();
 }
 
 LogicalResult VulkanRuntime::setWriteDescriptors() {
   if (descriptorSets.size() != descriptorSetInfoPool.size()) {
-    llvm::errs() << "Each descriptor set must have descriptor set information";
+    std::cerr << "Each descriptor set must have descriptor set information";
     return failure();
   }
   // For each descriptor set.
   auto descriptorSetIt = descriptorSets.begin();
   // Each descriptor set is associated with descriptor set info.
   for (const auto &descriptorSetInfo : descriptorSetInfoPool) {
     // For each device memory buffer in the descriptor set.
     const auto &deviceMemoryBuffers =

mlir/tools/mlir-vulkan-runner/vulkan-runtime-wrappers.cpp

 //===- vulkan-runtime-wrappers.cpp - MLIR Vulkan runner wrapper library ---===//
 //
 // Part of the LLVM Project, 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements C runtime wrappers around the VulkanRuntime.
 //
 //===----------------------------------------------------------------------===//
 
+#include <iostream>
 #include <mutex>
 #include <numeric>
 
 #include "VulkanRuntime.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace {
 
 class VulkanRuntimeManager {
 public:
   VulkanRuntimeManager() = default;
   VulkanRuntimeManager(const VulkanRuntimeManager &) = delete;
   VulkanRuntimeManager operator=(const VulkanRuntimeManager &) = delete;
void setShaderModule(uint8_t *shader, uint32_t size) {
     vulkanRuntime.setShaderModule(shader, size);
   }
 
   void runOnVulkan() {
     std::lock_guard<std::mutex> lock(mutex);
     if (failed(vulkanRuntime.initRuntime()) || failed(vulkanRuntime.run()) ||
         failed(vulkanRuntime.updateHostMemoryBuffers()) ||
         failed(vulkanRuntime.destroy())) {
-      llvm::errs() << "runOnVulkan failed";
+      std::cerr << "runOnVulkan failed";
     }
   }
 
 private:
   VulkanRuntime vulkanRuntime;
   std::mutex mutex;
 };