Simple load store test works

Author: akroviakov

include/gc/Conversion/Passes.h

@@ -10,6 +10,8 @@
 #define GC_CONVERSION_PASSES_H
 
 #include "gc/Conversion/XeVMToLLVM/XeVMToLLVM.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassOptions.h"
 
 namespace mlir {
 

include/gc/ExecutionEngine/Driver/Driver.h

@@ -18,7 +18,7 @@ namespace mlir {
 class DialectRegistry;
 namespace gc {
 
-const DialectRegistry &initCompilerAndGetDialects();
+DialectRegistry &initCompilerAndGetDialects();
 
 // the pointers to XXXMemRefType
 using GeneralMemrefPtr = void *;

lib/gc/Conversion/XeVMToLLVM/XeVMToLLVM.cpp

@@ -11,6 +11,7 @@
 #include "gc/Dialect/LLVMIR/XeVMDialect.h"
 #include "mlir/Conversion/ConvertToLLVM/ToLLVMInterface.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
+#include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Pass/Pass.h"
@@ -115,13 +116,13 @@ getCacheControlMetadata(ConversionPatternRewriter &rewriter, OpType op,
   return rewriter.getArrayAttr(combinedAttrs);
 }
 
-static LLVM::CallOp
-createDeviceFunctionCall(ConversionPatternRewriter &rewriter,
-                         StringRef funcName, Type retType,
-                         ArrayRef<Type> argTypes, ArrayRef<Value> args,
-                         ArrayRef<std::pair<unsigned, StringRef>> paramAttrs,
-                         LLVMFuncAttributeOptions funcAttributeOptions) {
-  auto moduleOp = rewriter.getBlock()->getParent()->getParentOfType<ModuleOp>();
+static LLVM::CallOp createDeviceFunctionCall(
+    ConversionPatternRewriter &rewriter, StringRef funcName, Type retType,
+    ArrayRef<Type> argTypes, ArrayRef<Value> args,
+    mlir::ArrayRef<std::pair<unsigned, mlir::StringRef>> paramAttrs,
+    LLVMFuncAttributeOptions funcAttributeOptions) {
+  auto moduleOp =
+      rewriter.getBlock()->getParent()->getParentOfType<gpu::GPUModuleOp>();
   MLIRContext *ctx = rewriter.getContext();
   Location loc = UnknownLoc::get(ctx);
 

lib/gc/ExecutionEngine/Driver/CMakeLists.txt

@@ -25,6 +25,7 @@ else()
     MLIRToLLVMIRTranslationRegistration
   )
 endif()
+get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 set(GC_PASSES GcInterface GcPasses)
 if(GC_ENABLE_IMEX)
@@ -38,6 +39,8 @@ gc_add_mlir_library(GcJitWrapper
     ${MLIR_LINK_COMPONENTS}
     ${dialect_libs}
     ${conversion_libs}
+    ${extension_libs}
     ${GC_PASSES}
     GcAnalysis
+    MLIRXeVMToLLVMIRTranslation
   )

lib/gc/ExecutionEngine/Driver/Driver.cpp

@@ -11,8 +11,12 @@
 #ifdef GC_HAS_ONEDNN_DIALECT
 #include "gc/Dialect/OneDNNGraph/OneDNNGraphDialect.h"
 #endif
+#include "gc/Conversion/Passes.h"
+#include "gc/Target/LLVM/XeVM/Target.h"
+#include "gc/Target/LLVMIR/Dialect/XeVM/XeVMToLLVMIRTranslation.h"
 #include "gc/Transforms/Passes.h"
 #include "mlir/InitAllDialects.h"
+#include "mlir/InitAllExtensions.h"
 #include "mlir/InitAllPasses.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR/Dialect/All.h"
@@ -26,22 +30,29 @@ namespace gc {
 static DialectRegistry initDialects() {
   mlir::registerAllPasses();
   mlir::gc::registerGraphCompilerPasses();
+  mlir::registerGCConversionPasses();
   mlir::cpuruntime::registerCPURuntimePasses();
   mlir::DialectRegistry registry;
   registry.insert<mlir::cpuruntime::CPURuntimeDialect>();
   mlir::registerAllDialects(registry);
   mlir::cpuruntime::registerConvertCPURuntimeToLLVMInterface(registry);
+  mlir::registerAllExtensions(registry);
+  // Adds missing `LLVMTranslationDialectInterface` registration for dialect for
+  // gpu.module op
+  mlir::registerAllToLLVMIRTranslations(registry);
+  mlir::registerConvertXeVMToLLVMInterface(registry);
+  mlir::registerXeVMDialectTranslation(registry);
+  mlir::xevm::registerXeVMTargetInterfaceExternalModels(registry);
 #ifdef GC_HAS_ONEDNN_DIALECT
   registry.insert<mlir::onednn_graph::OneDNNGraphDialect>();
 #endif
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
   llvm::InitializeNativeTargetAsmParser();
-  mlir::registerAllToLLVMIRTranslations(registry);
   return registry;
 }
 
-const DialectRegistry &initCompilerAndGetDialects() {
+DialectRegistry &initCompilerAndGetDialects() {
   static DialectRegistry reg = initDialects();
   return reg;
 }

lib/gc/ExecutionEngine/OpenCLRuntime/OpenCLRuntimeWrappers.cpp

@@ -23,12 +23,79 @@
 #define OCL_RUNTIME_EXPORT GC_DLL_EXPORT
 
 namespace {
+/* clang-format off */
+#define CaseToString(x) case x: return #x;
+const char* opencl_errstr(cl_int err) {
+  switch (err){
+    CaseToString(CL_SUCCESS)
+    CaseToString(CL_DEVICE_NOT_FOUND)
+    CaseToString(CL_DEVICE_NOT_AVAILABLE)
+    CaseToString(CL_COMPILER_NOT_AVAILABLE) 
+    CaseToString(CL_MEM_OBJECT_ALLOCATION_FAILURE)
+    CaseToString(CL_OUT_OF_RESOURCES)
+    CaseToString(CL_OUT_OF_HOST_MEMORY)
+    CaseToString(CL_PROFILING_INFO_NOT_AVAILABLE)
+    CaseToString(CL_MEM_COPY_OVERLAP)
+    CaseToString(CL_IMAGE_FORMAT_MISMATCH)
+    CaseToString(CL_IMAGE_FORMAT_NOT_SUPPORTED)
+    CaseToString(CL_BUILD_PROGRAM_FAILURE)
+    CaseToString(CL_MAP_FAILURE)
+    CaseToString(CL_MISALIGNED_SUB_BUFFER_OFFSET)
+    CaseToString(CL_COMPILE_PROGRAM_FAILURE)
+    CaseToString(CL_LINKER_NOT_AVAILABLE)
+    CaseToString(CL_LINK_PROGRAM_FAILURE)
+    CaseToString(CL_DEVICE_PARTITION_FAILED)
+    CaseToString(CL_KERNEL_ARG_INFO_NOT_AVAILABLE)
+    CaseToString(CL_INVALID_VALUE)
+    CaseToString(CL_INVALID_DEVICE_TYPE)
+    CaseToString(CL_INVALID_PLATFORM)
+    CaseToString(CL_INVALID_DEVICE)
+    CaseToString(CL_INVALID_CONTEXT)
+    CaseToString(CL_INVALID_QUEUE_PROPERTIES)
+    CaseToString(CL_INVALID_COMMAND_QUEUE)
+    CaseToString(CL_INVALID_HOST_PTR)
+    CaseToString(CL_INVALID_MEM_OBJECT)
+    CaseToString(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR)
+    CaseToString(CL_INVALID_IMAGE_SIZE)
+    CaseToString(CL_INVALID_SAMPLER)
+    CaseToString(CL_INVALID_BINARY)
+    CaseToString(CL_INVALID_BUILD_OPTIONS)
+    CaseToString(CL_INVALID_PROGRAM)
+    CaseToString(CL_INVALID_PROGRAM_EXECUTABLE)
+    CaseToString(CL_INVALID_KERNEL_NAME)
+    CaseToString(CL_INVALID_KERNEL_DEFINITION)
+    CaseToString(CL_INVALID_KERNEL)
+    CaseToString(CL_INVALID_ARG_INDEX)
+    CaseToString(CL_INVALID_ARG_VALUE)
+    CaseToString(CL_INVALID_ARG_SIZE)
+    CaseToString(CL_INVALID_KERNEL_ARGS)
+    CaseToString(CL_INVALID_WORK_DIMENSION)
+    CaseToString(CL_INVALID_WORK_GROUP_SIZE)
+    CaseToString(CL_INVALID_WORK_ITEM_SIZE)
+    CaseToString(CL_INVALID_GLOBAL_OFFSET)
+    CaseToString(CL_INVALID_EVENT_WAIT_LIST)
+    CaseToString(CL_INVALID_EVENT)
+    CaseToString(CL_INVALID_OPERATION)
+    CaseToString(CL_INVALID_GL_OBJECT)
+    CaseToString(CL_INVALID_BUFFER_SIZE)
+    CaseToString(CL_INVALID_MIP_LEVEL)
+    CaseToString(CL_INVALID_GLOBAL_WORK_SIZE)
+    CaseToString(CL_INVALID_PROPERTY)
+    CaseToString(CL_INVALID_IMAGE_DESCRIPTOR)
+    CaseToString(CL_INVALID_COMPILER_OPTIONS)
+    CaseToString(CL_INVALID_LINKER_OPTIONS)
+    CaseToString(CL_INVALID_DEVICE_PARTITION_COUNT)
+    default : return "Unknown OpenCL error code";
+  }
+}
+/* clang-format on */
 
 #define CL_SAFE_CALL2(a)                                                       \
   do {                                                                         \
     (a);                                                                       \
     if (err != CL_SUCCESS) {                                                   \
-      fprintf(stderr, "FAIL: err=%d @ line=%d (%s)\n", err, __LINE__, (#a));   \
+      fprintf(stderr, "FAIL: err=%d (%s) @ line=%d (%s)\n", err,               \
+              opencl_errstr(err), __LINE__, (#a));                             \
       abort();                                                                 \
     }                                                                          \
   } while (0)
@@ -37,8 +104,8 @@ namespace {
   {                                                                            \
     auto status = (call);                                                      \
     if (status != CL_SUCCESS) {                                                \
-      fprintf(stderr, "CL error %d @ line=%d (%s)\n", status, __LINE__,        \
-              (#call));                                                        \
+      fprintf(stderr, "CL error %d (%s) @ line=%d (%s)\n", status,             \
+              opencl_errstr(status), __LINE__, (#call));                       \
       abort();                                                                 \
     }                                                                          \
   }
@@ -159,7 +226,8 @@ static cl_device_id getDevice(cl_device_type *devtype) {
     }
 
     std::vector<cl_device_id> devices(uintValue);
-    clGetDeviceIDs(platform, *devtype, uintValue, devices.data(), nullptr);
+    CL_SAFE_CALL(
+        clGetDeviceIDs(platform, *devtype, uintValue, devices.data(), nullptr));
 
     for (auto &device : devices) {
       CL_SAFE_CALL(clGetDeviceInfo(device, CL_DEVICE_VENDOR_ID, sizeof(cl_uint),
@@ -447,29 +515,35 @@ extern "C" OCL_RUNTIME_EXPORT void gpuWait(GPUCLQUEUE *queue) {
 
 // a silly workaround for mgpuModuleLoad. OCL needs context and device to load
 // the module. We remember the last call to any mgpu* APIs
-static thread_local GPUCLQUEUE *lastQueue;
+static thread_local GPUCLQUEUE *lastQueue{nullptr};
 extern "C" OCL_RUNTIME_EXPORT GPUCLQUEUE *mgpuStreamCreate() {
   auto ret =
       new GPUCLQUEUE(static_cast<cl_device_id>(nullptr), nullptr, nullptr);
   lastQueue = ret;
   return ret;
 }
 
+GPUCLQUEUE *getOrCreateStaticQueue() {
+  if (!lastQueue) {
+    return mgpuStreamCreate();
+  }
+  return lastQueue;
+}
+
 extern "C" OCL_RUNTIME_EXPORT void mgpuStreamDestroy(GPUCLQUEUE *queue) {
   lastQueue = nullptr;
   delete queue;
 }
 
 extern "C" OCL_RUNTIME_EXPORT void *
 mgpuMemAlloc(uint64_t size, GPUCLQUEUE *queue, bool isShared) {
-  lastQueue = queue;
-  return allocDeviceMemory(queue, size, /*alignment*/ 64, isShared);
+  return allocDeviceMemory(queue ? queue : getOrCreateStaticQueue(), size,
+                           /*alignment*/ 64, isShared);
 }
 
 extern "C" OCL_RUNTIME_EXPORT void mgpuMemFree(void *ptr, GPUCLQUEUE *queue) {
-  lastQueue = queue;
   if (ptr) {
-    deallocDeviceMemory(queue, ptr);
+    deallocDeviceMemory(queue ? queue : getOrCreateStaticQueue(), ptr);
   }
 }
 
@@ -498,8 +572,8 @@ mgpuLaunchKernel(cl_kernel kernel, size_t gridX, size_t gridY, size_t gridZ,
                  size_t sharedMemBytes, GPUCLQUEUE *queue, void **params,
                  void ** /*extra*/, size_t paramsCount) {
   launchKernel(
-      queue, kernel, gridX, gridY, gridZ, blockX, blockY, blockZ,
-      sharedMemBytes,
+      queue ? queue : getOrCreateStaticQueue(), kernel, gridX, gridY, gridZ,
+      blockX, blockY, blockZ, sharedMemBytes,
       [&]() {
         // todo (yijie): do we need to handle shared mem? If there is dynamic
         // shared mem required, which value should paramsCount be?
@@ -512,5 +586,5 @@ mgpuLaunchKernel(cl_kernel kernel, size_t gridX, size_t gridY, size_t gridZ,
 }
 
 extern "C" OCL_RUNTIME_EXPORT void mgpuStreamSynchronize(GPUCLQUEUE *queue) {
-  CL_SAFE_CALL(clFinish(queue->queue_));
+  CL_SAFE_CALL(clFinish((queue ? queue : getOrCreateStaticQueue())->queue_));
 }

lib/gc/Target/LLVM/XeVM/Target.cpp

@@ -144,9 +144,11 @@ SpirSerializer::moduleToObject(llvm::Module &llvmModule) {
     getOperation().emitError() << "Failed translating the module to Binary.";
     return std::nullopt;
   }
-
-  StringRef bin(serializedSPIRVBinary->c_str(),
-                serializedSPIRVBinary->size() + 1);
+  if (serializedSPIRVBinary->size() % 4) {
+    getOperation().emitError() << "SPIRV code size must be a multiple of 4.";
+    return std::nullopt;
+  }
+  StringRef bin(serializedSPIRVBinary->c_str(), serializedSPIRVBinary->size());
   return SmallVector<char, 0>(bin.begin(), bin.end());
 }
 
@@ -166,7 +168,7 @@ SpirSerializer::translateToSPIRVBinary(llvm::Module &llvmModule,
 
     codegenPasses.run(llvmModule);
   }
-  return stream.str();
+  return targetISA;
 }
 
 std::optional<SmallVector<char, 0>>

src/gc-cpu-runner/CMakeLists.txt

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2025 Intel Corporation
 # 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -32,5 +32,5 @@ if(GC_DEV_LINK_LLVM_DYLIB)
 endif()
 
 gc_add_mlir_tool(gc-cpu-runner gc-cpu-runner.cpp)
-target_link_libraries(gc-cpu-runner PRIVATE GcCpuRuntime)
+target_link_libraries(gc-cpu-runner PRIVATE GcJitWrapper GcCpuRuntime)
 mlir_check_all_link_libraries(gc-cpu-runner)

src/gc-cpu-runner/gc-cpu-runner.cpp

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2025 Intel Corporation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include "gc/ExecutionEngine/Driver/Driver.h"
+
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/ExecutionEngine/JitRunner.h"
@@ -34,13 +36,8 @@ int main(int argc, char **argv) {
   // keeps GCCPURuntime linked
   gc_runtime_keep_alive = 0;
   llvm::InitLLVM y(argc, argv);
-  llvm::InitializeNativeTarget();
-  llvm::InitializeNativeTargetAsmPrinter();
-  llvm::InitializeNativeTargetAsmParser();
-
-  mlir::DialectRegistry registry;
+  mlir::DialectRegistry &registry{mlir::gc::initCompilerAndGetDialects()};
   registry.insert<mlir::arith::ArithDialect>();
-  mlir::registerAllToLLVMIRTranslations(registry);
 
   return mlir::JitRunnerMain(argc, argv, registry);
 }

src/gc-opt/gc-opt.cpp

@@ -1,6 +1,6 @@
 
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2025 Intel Corporation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.