threads: add component model canonical functions (#1783)

* threads: add component model canonical functions

The shared-everything-threads [proposal] adds two new component model
canonical functions, `thread.spawn` and `thread.hw_concurrency`. This
change adds initial support for these new functions, which should match
what is specified in the [canonical ABI]. All of this support should be
gated behind checks that ensure the shared-everything-threads proposal
has been enabled.

[proposal]: https://github.com/WebAssembly/shared-everything-threads
[canonical ABI]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#-canon-threadspawn

* Rework using core types

* refactor: add `SubType::func` for brevity

* Create concrete ref from core type ID

* review: use core type index in reencoder

* review: add `intern_sub_type` helper

* review: move proposal check, add missing-features tests

* refactor: rename CM builtins test

* refactor: pass down `WasmFeatures`

* fix: re-bless

* review: make `thread.*` canonicals `shared`

Author: abrown

crates/wasm-encoder/src/component/builder.rs

@@ -386,6 +386,18 @@ impl ComponentBuilder {
         inc(&mut self.core_funcs)
     }
 
+    /// Declares a new `thread.spawn` intrinsic.
+    pub fn thread_spawn(&mut self, ty: u32) -> u32 {
+        self.canonical_functions().thread_spawn(ty);
+        inc(&mut self.core_funcs)
+    }
+
+    /// Declares a new `thread.hw_concurrency` intrinsic.
+    pub fn thread_hw_concurrency(&mut self) -> u32 {
+        self.canonical_functions().thread_hw_concurrency();
+        inc(&mut self.core_funcs)
+    }
+
     /// Adds a new custom section to this component.
     pub fn custom_section(&mut self, section: &CustomSection<'_>) {
         self.flush();

crates/wasm-encoder/src/component/canonicals.rs

@@ -144,6 +144,23 @@ impl CanonicalFunctionSection {
         self.num_added += 1;
         self
     }
+
+    /// Defines a function which will spawns a new thread by invoking a shared
+    /// function of type `ty_index`.
+    pub fn thread_spawn(&mut self, ty_index: u32) -> &mut Self {
+        self.bytes.push(0x05);
+        ty_index.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
+    /// Defines a function which will return the number of threads that can be
+    /// expected to execute concurrently.
+    pub fn thread_hw_concurrency(&mut self) -> &mut Self {
+        self.bytes.push(0x06);
+        self.num_added += 1;
+        self
+    }
 }
 
 impl Encode for CanonicalFunctionSection {

crates/wasm-encoder/src/reencode/component.rs

@@ -945,6 +945,13 @@ pub mod component_utils {
                 let resource = reencoder.component_type_index(resource);
                 section.resource_rep(resource);
             }
+            wasmparser::CanonicalFunction::ThreadSpawn { func_ty_index } => {
+                let func_ty = reencoder.type_index(func_ty_index);
+                section.thread_spawn(func_ty);
+            }
+            wasmparser::CanonicalFunction::ThreadHwConcurrency => {
+                section.thread_hw_concurrency();
+            }
         }
         Ok(())
     }

crates/wasmparser/src/readers/component/canonicals.rs

@@ -60,6 +60,14 @@ pub enum CanonicalFunction {
         /// The type index of the resource that's being accessed.
         resource: u32,
     },
+    /// A function which spawns a new thread by invoking the shared function.
+    ThreadSpawn {
+        /// The index of the function to spawn.
+        func_ty_index: u32,
+    },
+    /// A function which returns the number of threads that can be expected to
+    /// execute concurrently
+    ThreadHwConcurrency,
 }
 
 /// A reader for the canonical section of a WebAssembly component.
@@ -101,6 +109,10 @@ impl<'a> FromReader<'a> for CanonicalFunction {
             0x04 => CanonicalFunction::ResourceRep {
                 resource: reader.read()?,
             },
+            0x05 => CanonicalFunction::ThreadSpawn {
+                func_ty_index: reader.read()?,
+            },
+            0x06 => CanonicalFunction::ThreadHwConcurrency,
             x => return reader.invalid_leading_byte(x, "canonical function"),
         })
     }

crates/wasmparser/src/readers/core/types.rs

@@ -480,6 +480,18 @@ impl SubType {
         self.composite_type.unwrap_array()
     }
 
+    /// Construct a function `SubType`.
+    pub fn func(signature: FuncType, shared: bool) -> Self {
+        Self {
+            is_final: true,
+            supertype_idx: None,
+            composite_type: CompositeType {
+                inner: CompositeInnerType::Func(signature),
+                shared,
+            },
+        }
+    }
+
     /// Unwrap an `FuncType` or panic.
     ///
     /// Does not check finality or whether there is a supertype.

crates/wasmparser/src/validator.rs

@@ -1217,7 +1217,7 @@ impl Validator {
                 current.funcs.reserve(count as usize);
                 Ok(())
             },
-            |components, types, _, func, offset| {
+            |components, types, features, func, offset| {
                 let current = components.last_mut().unwrap();
                 match func {
                     crate::CanonicalFunction::Lift {
@@ -1244,6 +1244,12 @@ impl Validator {
                     crate::CanonicalFunction::ResourceRep { resource } => {
                         current.resource_rep(resource, types, offset)
                     }
+                    crate::CanonicalFunction::ThreadSpawn { func_ty_index } => {
+                        current.thread_spawn(func_ty_index, types, offset, features)
+                    }
+                    crate::CanonicalFunction::ThreadHwConcurrency => {
+                        current.thread_hw_concurrency(types, offset, features)
+                    }
                 }
             },
         )

crates/wasmparser/src/validator/component.rs

@@ -10,20 +10,20 @@ use super::{
         ModuleType, RecordType, Remapping, ResourceId, TypeAlloc, TypeList, VariantCase,
     },
 };
+use crate::collections::index_map::Entry;
+use crate::limits::*;
 use crate::prelude::*;
+use crate::types::{
+    ComponentAnyTypeId, ComponentCoreModuleTypeId, ComponentCoreTypeId, ComponentDefinedType,
+    ComponentEntityType, Context, CoreInstanceTypeKind, LoweringInfo, Remap, SubtypeCx, TupleType,
+    TypeInfo, VariantType,
+};
 use crate::validator::names::{ComponentName, ComponentNameKind, KebabStr, KebabString};
-use crate::{collections::index_map::Entry, CompositeInnerType};
 use crate::{
-    limits::*,
-    types::{
-        ComponentAnyTypeId, ComponentCoreModuleTypeId, ComponentCoreTypeId, ComponentDefinedType,
-        ComponentEntityType, Context, CoreInstanceTypeKind, LoweringInfo, Remap, SubtypeCx,
-        TupleType, TypeInfo, VariantType,
-    },
     BinaryReaderError, CanonicalOption, ComponentExportName, ComponentExternalKind,
-    ComponentOuterAliasKind, ComponentTypeRef, CompositeType, ExternalKind, FuncType, GlobalType,
-    InstantiationArgKind, MemoryType, RecGroup, Result, SubType, TableType, TypeBounds, ValType,
-    WasmFeatures,
+    ComponentOuterAliasKind, ComponentTypeRef, CompositeInnerType, ExternalKind, FuncType,
+    GlobalType, InstantiationArgKind, MemoryType, PackedIndex, RefType, Result, SubType, TableType,
+    TypeBounds, ValType, WasmFeatures,
 };
 use core::mem;
 
@@ -127,7 +127,7 @@ pub(crate) struct ComponentState {
     /// itself.
     ///
     /// The `Option<ValType>` in this mapping is whether or not the underlying
-    /// reprsentation of the resource is known to this component. Immediately
+    /// representation of the resource is known to this component. Immediately
     /// defined resources, for example, will have `Some(I32)` here. Resources
     /// that come from transitively defined components, for example, will have
     /// `None`. In the type context all entries here are `None`.
@@ -1001,19 +1001,8 @@ impl ComponentState {
 
         self.check_options(None, &info, &options, types, offset)?;
 
-        let composite_type = CompositeType {
-            inner: CompositeInnerType::Func(info.into_func_type()),
-            shared: false,
-        };
-        let lowered_ty = SubType {
-            is_final: true,
-            supertype_idx: None,
-            composite_type,
-        };
-
-        let (_is_new, group_id) =
-            types.intern_canonical_rec_group(RecGroup::implicit(offset, lowered_ty));
-        let id = types[group_id].start;
+        let lowered_ty = SubType::func(info.into_func_type(), false);
+        let id = types.intern_sub_type(lowered_ty, offset);
         self.core_funcs.push(id);
 
         Ok(())
@@ -1026,18 +1015,9 @@ impl ComponentState {
         offset: usize,
     ) -> Result<()> {
         let rep = self.check_local_resource(resource, types, offset)?;
-        let composite_type = CompositeType {
-            inner: CompositeInnerType::Func(FuncType::new([rep], [ValType::I32])),
-            shared: false,
-        };
-        let core_ty = SubType {
-            is_final: true,
-            supertype_idx: None,
-            composite_type,
-        };
-        let (_is_new, group_id) =
-            types.intern_canonical_rec_group(RecGroup::implicit(offset, core_ty));
-        let id = types[group_id].start;
+        let func_ty = FuncType::new([rep], [ValType::I32]);
+        let core_ty = SubType::func(func_ty, false);
+        let id = types.intern_sub_type(core_ty, offset);
         self.core_funcs.push(id);
         Ok(())
     }
@@ -1049,18 +1029,9 @@ impl ComponentState {
         offset: usize,
     ) -> Result<()> {
         self.resource_at(resource, types, offset)?;
-        let composite_type = CompositeType {
-            inner: CompositeInnerType::Func(FuncType::new([ValType::I32], [])),
-            shared: false,
-        };
-        let core_ty = SubType {
-            is_final: true,
-            supertype_idx: None,
-            composite_type,
-        };
-        let (_is_new, group_id) =
-            types.intern_canonical_rec_group(RecGroup::implicit(offset, core_ty));
-        let id = types[group_id].start;
+        let func_ty = FuncType::new([ValType::I32], []);
+        let core_ty = SubType::func(func_ty, false);
+        let id = types.intern_sub_type(core_ty, offset);
         self.core_funcs.push(id);
         Ok(())
     }
@@ -1072,18 +1043,9 @@ impl ComponentState {
         offset: usize,
     ) -> Result<()> {
         let rep = self.check_local_resource(resource, types, offset)?;
-        let composite_type = CompositeType {
-            inner: CompositeInnerType::Func(FuncType::new([ValType::I32], [rep])),
-            shared: false,
-        };
-        let core_ty = SubType {
-            is_final: true,
-            supertype_idx: None,
-            composite_type,
-        };
-        let (_is_new, group_id) =
-            types.intern_canonical_rec_group(RecGroup::implicit(offset, core_ty));
-        let id = types[group_id].start;
+        let func_ty = FuncType::new([ValType::I32], [rep]);
+        let core_ty = SubType::func(func_ty, false);
+        let id = types.intern_sub_type(core_ty, offset);
         self.core_funcs.push(id);
         Ok(())
     }
@@ -1112,6 +1074,78 @@ impl ComponentState {
         bail!(offset, "type index {} is not a resource type", idx)
     }
 
+    pub fn thread_spawn(
+        &mut self,
+        func_ty_index: u32,
+        types: &mut TypeAlloc,
+        offset: usize,
+        features: &WasmFeatures,
+    ) -> Result<()> {
+        if !features.shared_everything_threads() {
+            bail!(
+                offset,
+                "`thread.spawn` requires the shared-everything-threads proposal"
+            )
+        }
+
+        // Validate the type accepted by `thread.spawn`.
+        let core_type_id = match self.core_type_at(func_ty_index, offset)? {
+            ComponentCoreTypeId::Sub(c) => c,
+            ComponentCoreTypeId::Module(_) => bail!(offset, "expected a core function type"),
+        };
+        let sub_ty = &types[core_type_id];
+        if !sub_ty.composite_type.shared {
+            bail!(offset, "spawn type must be shared");
+        }
+        match &sub_ty.composite_type.inner {
+            CompositeInnerType::Func(func_ty) => {
+                if func_ty.params() != [ValType::I32] {
+                    bail!(
+                        offset,
+                        "spawn function must take a single `i32` argument (currently)"
+                    );
+                }
+                if func_ty.results() != [] {
+                    bail!(offset, "spawn function must not return any values");
+                }
+            }
+            _ => bail!(offset, "spawn type must be a function"),
+        }
+
+        // Insert the core function.
+        let packed_index = PackedIndex::from_id(core_type_id).ok_or_else(|| {
+            format_err!(offset, "implementation limit: too many types in `TypeList`")
+        })?;
+        let start_func_ref = RefType::concrete(true, packed_index);
+        let func_ty = FuncType::new([ValType::Ref(start_func_ref), ValType::I32], [ValType::I32]);
+        let core_ty = SubType::func(func_ty, true);
+        let id = types.intern_sub_type(core_ty, offset);
+        self.core_funcs.push(id);
+
+        Ok(())
+    }
+
+    pub fn thread_hw_concurrency(
+        &mut self,
+        types: &mut TypeAlloc,
+        offset: usize,
+        features: &WasmFeatures,
+    ) -> Result<()> {
+        if !features.shared_everything_threads() {
+            bail!(
+                offset,
+                "`thread.hw_concurrency` requires the shared-everything-threads proposal"
+            )
+        }
+
+        let func_ty = FuncType::new([], [ValType::I32]);
+        let core_ty = SubType::func(func_ty, true);
+        let id = types.intern_sub_type(core_ty, offset);
+        self.core_funcs.push(id);
+
+        Ok(())
+    }
+
     pub fn add_component(&mut self, component: ComponentType, types: &mut TypeAlloc) -> Result<()> {
         let id = types.push_ty(component);
         self.components.push(id);

crates/wasmparser/src/validator/types.rs

@@ -2627,6 +2627,14 @@ impl TypeList {
         return (true, rec_group_id);
     }
 
+    /// Helper for interning a sub type as a rec group; see
+    /// [`Self::intern_canonical_rec_group`].
+    pub fn intern_sub_type(&mut self, sub_ty: SubType, offset: usize) -> CoreTypeId {
+        let (_is_new, group_id) =
+            self.intern_canonical_rec_group(RecGroup::implicit(offset, sub_ty));
+        self[group_id].start
+    }
+
     /// Get the `CoreTypeId` for a local index into a rec group.
     pub fn rec_group_local_id(
         &self,

crates/wasmprinter/src/lib.rs

@@ -2377,6 +2377,27 @@ impl Printer<'_, '_> {
                     self.end_group()?;
                     state.core.funcs += 1;
                 }
+                CanonicalFunction::ThreadSpawn {
+                    func_ty_index: func_index,
+                } => {
+                    self.start_group("core func ")?;
+                    self.print_name(&state.core.func_names, state.core.funcs)?;
+                    self.result.write_str(" ")?;
+                    self.start_group("canon thread.spawn ")?;
+                    self.print_idx(&state.core.type_names, func_index)?;
+                    self.end_group()?;
+                    self.end_group()?;
+                    state.core.funcs += 1;
+                }
+                CanonicalFunction::ThreadHwConcurrency => {
+                    self.start_group("core func ")?;
+                    self.print_name(&state.core.func_names, state.core.funcs)?;
+                    self.result.write_str(" ")?;
+                    self.start_group("canon thread.hw_concurrency")?;
+                    self.end_group()?;
+                    self.end_group()?;
+                    state.core.funcs += 1;
+                }
             }
         }
 

crates/wast/src/component/binary.rs

@@ -347,6 +347,14 @@ impl<'a> Encoder<'a> {
                 self.core_func_names.push(name);
                 self.funcs.resource_rep(info.ty.into());
             }
+            CanonicalFuncKind::ThreadSpawn(info) => {
+                self.core_func_names.push(name);
+                self.funcs.thread_spawn(info.ty.into());
+            }
+            CanonicalFuncKind::ThreadHwConcurrency(_info) => {
+                self.core_func_names.push(name);
+                self.funcs.thread_hw_concurrency();
+            }
         }
 
         self.flush(Some(self.funcs.id()));