Finally moving VM type registration to iree_vm_instance_t. (#12650)

This allows for thread-safe type registration scoped to instances and
unregistration of types as required by types in dynamically loaded
modules that may wink out of existence at some point. The main trick
here was changing the type ID from an ordinal in the type table to just
the pointer of the type descriptor. This requires an extra 4 bytes per
ref on 64-bit systems but who cares - now there's no round-tripping
through the type table for common operations.

As part of simplifying the way types are referenced VM type descriptors
are now hidden behind iree_vm_ref_type_t. This makes refs much easier to
work with as there's only one way to reference types and it always
bottoms out on the registered descriptor
handle. It also allows us to remove some type descriptor indirection
we'd previously required in order to get reference counter offsets as we
can share the same packed type identifier in type defs, refs, or lists.

Thanks to @simon-camp for the required EmitC changes!

---------

Co-authored-by: Simon Camphausen <simon.camphausen@iml.fraunhofer.de>

Author: benvanik

CMakeLists.txt

@@ -361,11 +361,11 @@ cmake_dependent_option(IREE_OUTPUT_FORMAT_C "Enables the 'vm-c' output format, u
 if(IREE_BUILD_COMPILER)
   message(STATUS "IREE compiler output formats:")
   if(IREE_OUTPUT_FORMAT_C)
-    message(STATUS "  - C source module")
+    message(STATUS "  - 'vm-c': textual C source module")
   endif()
   # The 'vm-bytecode' and 'vm-asm' formats are always enabled.
-  message(STATUS "  - VM Bytecode")
-  message(STATUS "  - VM MLIR Assembly")
+  message(STATUS "  - 'vm-bytecode': VM bytecode")
+  message(STATUS "  - 'vm-asm': VM MLIR assembly")
 endif()
 
 #-------------------------------------------------------------------------------

compiler/src/iree/compiler/ConstEval/Runtime.cpp

@@ -83,9 +83,9 @@ static Attribute createAttributeFromRawData(Location loc,
 
 }  // namespace
 
-CompiledBinary::CompiledBinary() {}
+CompiledBinary::CompiledBinary() = default;
 
-CompiledBinary::~CompiledBinary() {}
+CompiledBinary::~CompiledBinary() = default;
 
 void CompiledBinary::deinitialize() {
   hal_module.reset();
@@ -106,10 +106,10 @@ LogicalResult CompiledBinary::invokeNullary(Location loc, StringRef name,
   }
 
   iree::vm::ref<iree_vm_list_t> inputs;
-  IREE_CHECK_OK(iree_vm_list_create(/*element_type=*/nullptr, 0,
+  IREE_CHECK_OK(iree_vm_list_create(iree_vm_make_undefined_type_def(), 0,
                                     iree_allocator_system(), &inputs));
   iree::vm::ref<iree_vm_list_t> outputs;
-  IREE_CHECK_OK(iree_vm_list_create(/*element_type=*/nullptr, 1,
+  IREE_CHECK_OK(iree_vm_list_create(iree_vm_make_undefined_type_def(), 1,
                                     iree_allocator_system(), &outputs));
 
   if (auto status =
@@ -188,7 +188,7 @@ Attribute CompiledBinary::convertVariantToAttribute(
   auto context = loc.getContext();
   Builder builder(context);
   if (iree_vm_variant_is_value(variant)) {
-    switch (variant.type.value_type) {
+    switch (iree_vm_type_def_as_value(variant.type)) {
       case IREE_VM_VALUE_TYPE_I8:
         return builder.getI8IntegerAttr(variant.i8);
       case IREE_VM_VALUE_TYPE_I16:
@@ -203,7 +203,8 @@ Attribute CompiledBinary::convertVariantToAttribute(
         return builder.getF64FloatAttr(variant.f64);
       default:
         emitError(loc) << "unrecognized evaluated value type: "
-                       << static_cast<int>(variant.type.value_type);
+                       << static_cast<int>(
+                              iree_vm_type_def_as_value(variant.type));
         return {};
     }
   }
@@ -248,7 +249,7 @@ Attribute CompiledBinary::convertVariantToAttribute(
       return convertedAttr;
     } else {
       iree_string_view_t typeName =
-          iree_vm_ref_type_name(variant.type.ref_type);
+          iree_vm_ref_type_name(iree_vm_type_def_as_ref(variant.type));
       emitError(loc) << "unrecognized evaluated ref type: "
                      << StringRef(typeName.data, typeName.size);
       return {};
@@ -311,7 +312,8 @@ Runtime::Runtime() {
   IREE_CHECK_OK(
       iree_hal_driver_registry_allocate(iree_allocator_system(), &registry));
   IREE_CHECK_OK(iree_hal_local_task_driver_module_register(registry));
-  IREE_CHECK_OK(iree_vm_instance_create(iree_allocator_system(), &instance));
+  IREE_CHECK_OK(iree_vm_instance_create(IREE_VM_TYPE_CAPACITY_DEFAULT,
+                                        iree_allocator_system(), &instance));
   IREE_CHECK_OK(iree_hal_module_register_all_types(instance.get()));
 }
 

compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/BUILD.bazel

@@ -41,6 +41,7 @@ iree_compiler_cc_library(
         "//compiler/src/iree/compiler/Dialect/VM/Analysis",
         "//compiler/src/iree/compiler/Dialect/VM/IR",
         "//compiler/src/iree/compiler/Dialect/VM/Utils:CallingConvention",
+        "//compiler/src/iree/compiler/Dialect/VM/Utils:TypeTable",
         "@llvm-project//llvm:Support",
         "@llvm-project//mlir:ArithDialect",
         "@llvm-project//mlir:ControlFlowDialect",

compiler/src/iree/compiler/Dialect/VM/Conversion/VMToEmitC/CMakeLists.txt

@@ -43,6 +43,7 @@ iree_cc_library(
     iree::compiler::Dialect::VM::Analysis
     iree::compiler::Dialect::VM::IR
     iree::compiler::Dialect::VM::Utils::CallingConvention
+    iree::compiler::Dialect::VM::Utils::TypeTable
   PUBLIC
 )