threads: rename thread.hw_concurrency to thread.available_parallelism (#2043)

This propagates @sunfishcode's renaming of the built-in upstream (see
[#419]) to these crates.

[#419]: WebAssembly/component-model#419

Author: abrown

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

@@ -379,9 +379,9 @@ impl ComponentBuilder {
         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();
+    /// Declares a new `thread.available_parallelism` intrinsic.
+    pub fn thread_available_parallelism(&mut self) -> u32 {
+        self.canonical_functions().thread_available_parallelism();
         inc(&mut self.core_funcs)
     }
 

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

@@ -169,7 +169,7 @@ impl CanonicalFunctionSection {
 
     /// 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 {
+    pub fn thread_available_parallelism(&mut self) -> &mut Self {
         self.bytes.push(0x06);
         self.num_added += 1;
         self

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

@@ -964,8 +964,8 @@ pub mod component_utils {
                 let func_ty = reencoder.type_index(func_ty_index);
                 section.thread_spawn(func_ty);
             }
-            wasmparser::CanonicalFunction::ThreadHwConcurrency => {
-                section.thread_hw_concurrency();
+            wasmparser::CanonicalFunction::ThreadAvailableParallelism => {
+                section.thread_available_parallelism();
             }
             wasmparser::CanonicalFunction::TaskBackpressure => {
                 section.task_backpressure();

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

@@ -74,7 +74,7 @@ pub enum CanonicalFunction {
     },
     /// A function which returns the number of threads that can be expected to
     /// execute concurrently
-    ThreadHwConcurrency,
+    ThreadAvailableParallelism,
     /// A function which tells the host to enable or disable backpressure for
     /// the caller's instance.
     TaskBackpressure,
@@ -272,7 +272,7 @@ impl<'a> FromReader<'a> for CanonicalFunction {
             0x05 => CanonicalFunction::ThreadSpawn {
                 func_ty_index: reader.read()?,
             },
-            0x06 => CanonicalFunction::ThreadHwConcurrency,
+            0x06 => CanonicalFunction::ThreadAvailableParallelism,
             0x08 => CanonicalFunction::TaskBackpressure,
             0x09 => CanonicalFunction::TaskReturn {
                 result: match reader.read_u8()? {

crates/wasmparser/src/validator.rs

@@ -1307,8 +1307,8 @@ impl Validator {
                     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)
+                    crate::CanonicalFunction::ThreadAvailableParallelism => {
+                        current.thread_available_parallelism(types, offset, features)
                     }
                     crate::CanonicalFunction::TaskBackpressure => {
                         current.task_backpressure(types, offset, features)

crates/wasmparser/src/validator/component.rs

@@ -1733,7 +1733,7 @@ impl ComponentState {
         Ok(())
     }
 
-    pub fn thread_hw_concurrency(
+    pub fn thread_available_parallelism(
         &mut self,
         types: &mut TypeAlloc,
         offset: usize,
@@ -1742,7 +1742,7 @@ impl ComponentState {
         if !features.shared_everything_threads() {
             bail!(
                 offset,
-                "`thread.hw_concurrency` requires the shared-everything-threads proposal"
+                "`thread.available_parallelism` requires the shared-everything-threads proposal"
             )
         }
 

crates/wasmprinter/src/component.rs

@@ -902,11 +902,11 @@ impl Printer<'_, '_> {
                     self.end_group()?;
                     state.core.funcs += 1;
                 }
-                CanonicalFunction::ThreadHwConcurrency => {
+                CanonicalFunction::ThreadAvailableParallelism => {
                     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.start_group("canon thread.available_parallelism")?;
                     self.end_group()?;
                     self.end_group()?;
                     state.core.funcs += 1;

crates/wast/src/component/binary.rs

@@ -353,9 +353,9 @@ impl<'a> Encoder<'a> {
                 self.core_func_names.push(name);
                 self.funcs.thread_spawn(info.ty.into());
             }
-            CanonicalFuncKind::ThreadHwConcurrency(_info) => {
+            CanonicalFuncKind::ThreadAvailableParallelism(_info) => {
                 self.core_func_names.push(name);
-                self.funcs.thread_hw_concurrency();
+                self.funcs.thread_available_parallelism();
             }
             CanonicalFuncKind::TaskBackpressure => {
                 self.core_func_names.push(name);

crates/wast/src/component/expand.rs

@@ -269,7 +269,7 @@ impl<'a> Expander<'a> {
             | CanonicalFuncKind::ResourceRep(_)
             | CanonicalFuncKind::ResourceDrop(_)
             | CanonicalFuncKind::ThreadSpawn(_)
-            | CanonicalFuncKind::ThreadHwConcurrency(_)
+            | CanonicalFuncKind::ThreadAvailableParallelism(_)
             | CanonicalFuncKind::TaskBackpressure
             | CanonicalFuncKind::TaskReturn(_)
             | CanonicalFuncKind::TaskWait(_)
@@ -338,12 +338,12 @@ impl<'a> Expander<'a> {
                 name: func.name,
                 kind: CanonicalFuncKind::ThreadSpawn(info),
             }),
-            CoreFuncKind::ThreadHwConcurrency(info) => {
+            CoreFuncKind::ThreadAvailableParallelism(info) => {
                 ComponentField::CanonicalFunc(CanonicalFunc {
                     span: func.span,
                     id: func.id,
                     name: func.name,
-                    kind: CanonicalFuncKind::ThreadHwConcurrency(info),
+                    kind: CanonicalFuncKind::ThreadAvailableParallelism(info),
                 })
             }
             CoreFuncKind::TaskBackpressure => ComponentField::CanonicalFunc(CanonicalFunc {

crates/wast/src/component/func.rs

@@ -52,7 +52,7 @@ pub enum CoreFuncKind<'a> {
     ResourceDrop(CanonResourceDrop<'a>),
     ResourceRep(CanonResourceRep<'a>),
     ThreadSpawn(CanonThreadSpawn<'a>),
-    ThreadHwConcurrency(CanonThreadHwConcurrency),
+    ThreadAvailableParallelism(CanonThreadAvailableParallelism),
     TaskBackpressure,
     TaskReturn(CanonTaskReturn<'a>),
     TaskWait(CanonTaskWait<'a>),
@@ -100,8 +100,8 @@ impl<'a> Parse<'a> for CoreFuncKind<'a> {
                 Ok(CoreFuncKind::ResourceRep(parser.parse()?))
             } else if l.peek::<kw::thread_spawn>()? {
                 Ok(CoreFuncKind::ThreadSpawn(parser.parse()?))
-            } else if l.peek::<kw::thread_hw_concurrency>()? {
-                Ok(CoreFuncKind::ThreadHwConcurrency(parser.parse()?))
+            } else if l.peek::<kw::thread_available_parallelism>()? {
+                Ok(CoreFuncKind::ThreadAvailableParallelism(parser.parse()?))
             } else if l.peek::<kw::task_backpressure>()? {
                 parser.parse::<kw::task_backpressure>()?;
                 Ok(CoreFuncKind::TaskBackpressure)
@@ -341,7 +341,7 @@ pub enum CanonicalFuncKind<'a> {
     ResourceRep(CanonResourceRep<'a>),
 
     ThreadSpawn(CanonThreadSpawn<'a>),
-    ThreadHwConcurrency(CanonThreadHwConcurrency),
+    ThreadAvailableParallelism(CanonThreadAvailableParallelism),
 
     TaskBackpressure,
     TaskReturn(CanonTaskReturn<'a>),
@@ -509,11 +509,11 @@ impl<'a> Parse<'a> for CanonThreadSpawn<'a> {
 
 /// Information relating to the `thread.spawn` intrinsic.
 #[derive(Debug)]
-pub struct CanonThreadHwConcurrency;
+pub struct CanonThreadAvailableParallelism;
 
-impl<'a> Parse<'a> for CanonThreadHwConcurrency {
+impl<'a> Parse<'a> for CanonThreadAvailableParallelism {
     fn parse(parser: Parser<'a>) -> Result<Self> {
-        parser.parse::<kw::thread_hw_concurrency>()?;
+        parser.parse::<kw::thread_available_parallelism>()?;
         Ok(Self)
     }
 }